>", PATTERN.format(template=correct_cased_template)
+ )
+ pyproject_dest.write_text(pyproject_contents)
+
+ demo_dir = directory / "demo"
+ demo_dir.mkdir(exist_ok=True, parents=True)
+
+ (demo_dir / "app.py").write_text(
+ f"""
+import gradio as gr
+from {package_name} import {name}
+
+{component.demo_code.format(name=name)}
+
+if __name__ == "__main__":
+ demo.launch()
+"""
+ )
+ (demo_dir / "__init__.py").touch()
+
+ init = backend / "__init__.py"
+ init.write_text(
+ f"""
+from .{name.lower()} import {name}
+
+__all__ = ['{name}']
+"""
+ )
+
+ p = Path(inspect.getfile(gradio)).parent
+ python_file = backend / f"{name.lower()}.py"
+
+ shutil.copy(
+ str(p / module / component.python_file_name),
+ str(python_file),
+ )
+
+ source_pyi_file = p / module / component.python_file_name.replace(".py", ".pyi")
+ pyi_file = backend / f"{name.lower()}.pyi"
+ if source_pyi_file.exists():
+ shutil.copy(str(source_pyi_file), str(pyi_file))
+
+ content = python_file.read_text()
+ content = _replace_old_class_name(correct_cased_template, name, content)
+ content = _strip_document_lines(content)
+ python_file.write_text(content)
+ if pyi_file.exists():
+ pyi_content = pyi_file.read_text()
+ pyi_content = _replace_old_class_name(correct_cased_template, name, content)
+ pyi_content = _strip_document_lines(pyi_content)
+ pyi_file.write_text(pyi_content)
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/_docs_assets.py b/lib/python3.11/site-packages/gradio/cli/commands/components/_docs_assets.py
new file mode 100644
index 0000000000000000000000000000000000000000..524fd937fef997fd85bb6d0c6d854a38178776b2
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/_docs_assets.py
@@ -0,0 +1,158 @@
+css = """html {
+ font-family: Inter;
+ font-size: 16px;
+ font-weight: 400;
+ line-height: 1.5;
+ -webkit-text-size-adjust: 100%;
+ background: #fff;
+ color: #323232;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+ text-rendering: optimizeLegibility;
+}
+
+:root {
+ --space: 1;
+ --vspace: calc(var(--space) * 1rem);
+ --vspace-0: calc(3 * var(--space) * 1rem);
+ --vspace-1: calc(2 * var(--space) * 1rem);
+ --vspace-2: calc(1.5 * var(--space) * 1rem);
+ --vspace-3: calc(0.5 * var(--space) * 1rem);
+}
+
+.app {
+ max-width: 748px !important;
+}
+
+.prose p {
+ margin: var(--vspace) 0;
+ line-height: var(--vspace * 2);
+ font-size: 1rem;
+}
+
+code {
+ font-family: "Inconsolata", sans-serif;
+ font-size: 16px;
+}
+
+h1,
+h1 code {
+ font-weight: 400;
+ line-height: calc(2.5 / var(--space) * var(--vspace));
+}
+
+h1 code {
+ background: none;
+ border: none;
+ letter-spacing: 0.05em;
+ padding-bottom: 5px;
+ position: relative;
+ padding: 0;
+}
+
+h2 {
+ margin: var(--vspace-1) 0 var(--vspace-2) 0;
+ line-height: 1em;
+}
+
+h3,
+h3 code {
+ margin: var(--vspace-1) 0 var(--vspace-2) 0;
+ line-height: 1em;
+}
+
+h4,
+h5,
+h6 {
+ margin: var(--vspace-3) 0 var(--vspace-3) 0;
+ line-height: var(--vspace);
+}
+
+.bigtitle,
+h1,
+h1 code {
+ font-size: calc(8px * 4.5);
+ word-break: break-word;
+}
+
+.title,
+h2,
+h2 code {
+ font-size: calc(8px * 3.375);
+ font-weight: lighter;
+ word-break: break-word;
+ border: none;
+ background: none;
+}
+
+.subheading1,
+h3,
+h3 code {
+ font-size: calc(8px * 1.8);
+ font-weight: 600;
+ border: none;
+ background: none;
+ letter-spacing: 0.1em;
+ text-transform: uppercase;
+}
+
+h2 code {
+ padding: 0;
+ position: relative;
+ letter-spacing: 0.05em;
+}
+
+blockquote {
+ font-size: calc(8px * 1.1667);
+ font-style: italic;
+ line-height: calc(1.1667 * var(--vspace));
+ margin: var(--vspace-2) var(--vspace-2);
+}
+
+.subheading2,
+h4 {
+ font-size: calc(8px * 1.4292);
+ text-transform: uppercase;
+ font-weight: 600;
+}
+
+.subheading3,
+h5 {
+ font-size: calc(8px * 1.2917);
+ line-height: calc(1.2917 * var(--vspace));
+
+ font-weight: lighter;
+ text-transform: uppercase;
+ letter-spacing: 0.15em;
+}
+
+h6 {
+ font-size: calc(8px * 1.1667);
+ font-size: 1.1667em;
+ font-weight: normal;
+ font-style: italic;
+ font-family: "le-monde-livre-classic-byol", serif !important;
+ letter-spacing: 0px !important;
+}
+
+#start .md > *:first-child {
+ margin-top: 0;
+}
+
+h2 + h3 {
+ margin-top: 0;
+}
+
+.md hr {
+ border: none;
+ border-top: 1px solid var(--block-border-color);
+ margin: var(--vspace-2) 0 var(--vspace-2) 0;
+}
+.prose ul {
+ margin: var(--vspace-2) 0 var(--vspace-1) 0;
+}
+
+.gap {
+ gap: 0;
+}
+"""
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/_docs_utils.py b/lib/python3.11/site-packages/gradio/cli/commands/components/_docs_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..38bdc4802a0856c0773ebbce871f53c1da4b8512
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/_docs_utils.py
@@ -0,0 +1,929 @@
+from __future__ import annotations
+
+import inspect
+import re
+import shutil
+import types
+import typing
+from subprocess import PIPE, Popen
+
+RUFF_INSTALLED = bool(shutil.which("ruff"))
+
+
+def find_first_non_return_key(some_dict):
+ """Finds the first key in a dictionary that is not "return"."""
+ for key, value in some_dict.items():
+ if key != "return":
+ return value
+ return None
+
+
+def format(code: str, type: str):
+ """Formats code using ruff."""
+ if type == "value":
+ code = f"value = {code}"
+
+ if not RUFF_INSTALLED:
+ return code
+
+ ruff_args = ["ruff", "format", "-", "--line-length=60"]
+
+ process = Popen(
+ ruff_args,
+ stdin=PIPE,
+ stdout=PIPE,
+ stderr=PIPE,
+ universal_newlines=True,
+ )
+
+ formatted_code, err = process.communicate(input=str(code))
+
+ if type == "value":
+ formatted_code = re.sub(
+ r"^\s*value =\s*", "", formatted_code, flags=re.MULTILINE
+ )
+
+ stripped_source = re.search(r"^\s*\((.*)\)\s*$", formatted_code, re.DOTALL)
+
+ if stripped_source:
+ return stripped_source.group(1).strip()
+ elif formatted_code.strip() == "":
+ return code
+ else:
+ return formatted_code.strip()
+
+
+def get_param_name(param):
+ """Gets the name of a parameter."""
+
+ if isinstance(param, str):
+ return f'"{param}"'
+ if inspect.isclass(param) and param.__module__ == "builtins":
+ p = getattr(param, "__name__", None)
+ if p is None and inspect.isclass(param):
+ p = f"{param.__module__}.{param.__name__}"
+ return p
+
+ if inspect.isclass(param):
+ return f"{param.__module__}.{param.__name__}"
+
+ param_name = getattr(param, "__name__", None)
+
+ if param_name is None:
+ param_name = str(param)
+
+ return param_name
+
+
+def format_none(value):
+ """Formats None and NonType values."""
+ if value is None or value is type(None) or value in ("None", "NoneType"):
+ return "None"
+ return value
+
+
+def format_value(value):
+ """Formats a value."""
+ if value is None:
+ return "None"
+ if isinstance(value, str):
+ return f'"{value}"'
+ return str(value)
+
+
+def get_parameter_docstring(docstring: str, parameter_name: str):
+ """Gets the docstring for a parameter."""
+ pattern = rf"\b{parameter_name}\b:[ \t]*(.*?)(?=\n|$)"
+
+ match = re.search(pattern, docstring, flags=re.DOTALL)
+ if match:
+ return match.group(1).strip()
+
+ return None
+
+
+def get_return_docstring(docstring: str):
+ """Gets the docstring for a return value."""
+ pattern = r"\bReturn(?:s){0,1}\b:[ \t\n]*(.*?)(?=\n|$)"
+
+ match = re.search(pattern, docstring, flags=re.DOTALL | re.IGNORECASE)
+ if match:
+ return match.group(1).strip()
+
+ return None
+
+
+def add_value(obj: dict, key: str, value: typing.Any):
+ """Adds a value to a dictionary."""
+ type = "value" if key == "default" else "type"
+
+ obj[key] = format(value, type)
+
+ return obj
+
+
+def set_deep(dictionary: dict, keys: list[str], value: typing.Any):
+ """Sets a value in a nested dictionary for a key path that may not exist"""
+ for key in keys[:-1]:
+ dictionary = dictionary.setdefault(key, {})
+ dictionary[keys[-1]] = value
+
+
+def get_deep(dictionary: dict, keys: list[str], default=None):
+ """Gets a value from a nested dictionary without erroring if the key doesn't exist."""
+ try:
+ for key in keys:
+ dictionary = dictionary[key]
+ return dictionary
+ except KeyError:
+ return default
+
+
+def get_type_arguments(type_hint) -> tuple:
+ """Gets the type arguments for a type hint."""
+ if hasattr(type_hint, "__args__"):
+ return type_hint.__args__
+ elif hasattr(type_hint, "__extra__"):
+ return type_hint.__extra__.__args__
+ else:
+ return typing.get_args(type_hint)
+
+
+def get_container_name(arg):
+ """Gets a human readable name for a type."""
+ if inspect.isclass(arg):
+ return arg.__name__
+ if isinstance(arg, types.GenericAlias):
+ return arg.__origin__.__name__
+ elif isinstance(arg, types.UnionType):
+ return "Union"
+ elif getattr(arg, "__origin__", None) is typing.Literal:
+ return "Literal"
+ else:
+ return str(arg)
+
+
+def format_type(_type: list[typing.Any]):
+ """Pretty formats a possibly nested type hint."""
+
+ s = []
+ _current = None
+ for t in _type:
+ if isinstance(t, str):
+ _current = format_none(t)
+ continue
+
+ elif isinstance(t, list):
+ if len(t) == 0:
+ continue
+ s.append(f"{format_type(t)}")
+ else:
+ s.append(t)
+ if len(s) == 0:
+ return _current
+ elif _current in ("Literal", "Union"):
+ return "| ".join(s)
+ else:
+ return f"{_current}[{','.join(s)}]"
+
+
+def get_type_hints(param, module):
+ """Gets the type hints for a parameter."""
+
+ def extract_args(
+ arg,
+ module_name_prefix,
+ additional_interfaces,
+ user_fn_refs: list[str],
+ append=True,
+ arg_of=None,
+ ):
+ """Recursively extracts the arguments from a type hint."""
+ arg_names = []
+ args = get_type_arguments(arg)
+
+ # These are local classes that are used in types
+ if inspect.isclass(arg) and arg.__module__.startswith(module_name_prefix):
+ # get sourcecode for the class
+
+ source_code = inspect.getsource(arg)
+ source_code = format(
+ re.sub(r"(\"\"\".*?\"\"\")", "", source_code, flags=re.DOTALL), "other"
+ )
+
+ if arg_of is not None:
+ refs = get_deep(additional_interfaces, [arg_of, "refs"])
+
+ if refs is None:
+ refs = [arg.__name__]
+ elif isinstance(refs, list) and arg.__name__ not in refs:
+ refs.append(arg.__name__)
+
+ set_deep(additional_interfaces, [arg_of, "refs"], refs)
+
+ if get_deep(additional_interfaces, [arg.__name__, "source"]) is None:
+ set_deep(additional_interfaces, [arg.__name__, "source"], source_code)
+
+ for field_type in typing.get_type_hints(arg).values():
+ # We want to recursively extract the source code for the fields but we don't want to add them to the list of arguments
+ new_args = extract_args(
+ field_type,
+ module_name_prefix,
+ additional_interfaces,
+ user_fn_refs,
+ False,
+ arg.__name__,
+ )
+
+ if len(new_args) > 0:
+ arg_names.append(new_args)
+
+ if append:
+ arg_names.append(arg.__name__)
+ if arg.__name__ not in user_fn_refs:
+ user_fn_refs.append(arg.__name__)
+ elif len(args) > 0:
+ if append:
+ arg_names.append(get_container_name(arg))
+ for inner_arg in list(args):
+ new_args = extract_args(
+ inner_arg,
+ module_name_prefix,
+ additional_interfaces,
+ user_fn_refs,
+ append,
+ arg_of,
+ )
+
+ if len(new_args) > 0:
+ arg_names.append(new_args)
+ else: # noqa: PLR5501
+ if append:
+ arg_names.append(get_param_name(arg))
+ return arg_names
+
+ module_name_prefix = module.__name__ + "."
+ additional_interfaces = {}
+ user_fn_refs = []
+
+ args = extract_args(
+ param,
+ module_name_prefix,
+ additional_interfaces,
+ user_fn_refs,
+ True,
+ )
+
+ formatted_type = format_type(args)
+
+ return (formatted_type, additional_interfaces, user_fn_refs)
+
+
+def extract_docstrings(module):
+ docs = {}
+ global_type_mode = "complex"
+ for name, obj in inspect.getmembers(module):
+ # filter out the builtins etc
+ if name.startswith("_"):
+ continue
+ # this could be expanded but i think is ok for now
+ if inspect.isfunction(obj) or inspect.isclass(obj):
+ docs[name] = {}
+
+ main_docstring = inspect.getdoc(obj) or ""
+ cleaned_docstring = str.join(
+ "\n",
+ [s for s in main_docstring.split("\n") if not re.match(r"^\S+:", s)],
+ )
+
+ docs[name]["description"] = cleaned_docstring
+ docs[name]["members"] = {}
+ docs["__meta__"] = {"additional_interfaces": {}}
+ for member_name, member in inspect.getmembers(obj):
+ if inspect.ismethod(member) or inspect.isfunction(member):
+ # we are are only interested in these methods
+ if member_name not in ("__init__", "preprocess", "postprocess"):
+ continue
+
+ docs[name]["members"][member_name] = {}
+
+ member_docstring = inspect.getdoc(member) or ""
+ type_mode = "complex"
+ try:
+ hints = typing.get_type_hints(member)
+ except Exception:
+ type_mode = "simple"
+ hints = member.__annotations__
+ global_type_mode = "simple"
+
+ signature = inspect.signature(member)
+
+ # we iterate over the parameters and get the type information
+ for param_name, param in hints.items():
+ if (
+ param_name == "return" and member_name == "postprocess"
+ ) or (param_name != "return" and member_name == "preprocess"):
+ continue
+
+ if type_mode == "simple":
+ arg_names = hints.get(param_name, "")
+ additional_interfaces = {}
+ user_fn_refs = []
+ else:
+ (
+ arg_names,
+ additional_interfaces,
+ user_fn_refs,
+ ) = get_type_hints(param, module)
+
+ # These interfaces belong to the whole module, so we add them 'globally' for later
+ docs["__meta__"]["additional_interfaces"].update(
+ additional_interfaces
+ )
+
+ docs[name]["members"][member_name][param_name] = {}
+
+ if param_name == "return":
+ docstring = get_return_docstring(member_docstring)
+ else:
+ docstring = get_parameter_docstring(
+ member_docstring, param_name
+ )
+
+ add_value(
+ docs[name]["members"][member_name][param_name],
+ "type",
+ arg_names,
+ )
+
+ if signature.parameters.get(param_name, None) is not None:
+ default_value = signature.parameters[param_name].default
+ if default_value is not inspect._empty:
+ add_value(
+ docs[name]["members"][member_name][param_name],
+ "default",
+ format_value(default_value),
+ )
+
+ docs[name]["members"][member_name][param_name][
+ "description"
+ ] = docstring
+
+ # We just want to normalise the arg name to 'value' for the preprocess and postprocess methods
+ if member_name in ("postprocess", "preprocess"):
+ docs[name]["members"][member_name]["value"] = (
+ find_first_non_return_key(
+ docs[name]["members"][member_name]
+ )
+ )
+ additional_refs = get_deep(
+ docs, ["__meta__", "user_fn_refs", name]
+ )
+ if additional_refs is None:
+ set_deep(
+ docs,
+ ["__meta__", "user_fn_refs", name],
+ set(user_fn_refs),
+ )
+ else:
+ additional_refs = set(additional_refs)
+ additional_refs.update(user_fn_refs)
+ set_deep(
+ docs,
+ ["__meta__", "user_fn_refs", name],
+ additional_refs,
+ )
+ if member_name == "EVENTS":
+ docs[name]["events"] = {}
+ if isinstance(member, list):
+ for event in member:
+ docs[name]["events"][str(event)] = {
+ "type": None,
+ "default": None,
+ "description": event.doc.replace(
+ "{{ component }}", name
+ ),
+ }
+ final_user_fn_refs = get_deep(docs, ["__meta__", "user_fn_refs", name])
+ if final_user_fn_refs is not None:
+ set_deep(docs, ["__meta__", "user_fn_refs", name], list(final_user_fn_refs))
+
+ return (docs, global_type_mode)
+
+
+class AdditionalInterface(typing.TypedDict):
+ refs: list[str]
+ source: str
+
+
+def make_js(
+ interfaces: dict[str, AdditionalInterface] | None = None,
+ user_fn_refs: dict[str, list[str]] | None = None,
+):
+ """Makes the javascript code for the additional interfaces."""
+ js_obj_interfaces = "{"
+ if interfaces is not None:
+ for interface_name, interface in interfaces.items():
+ js_obj_interfaces += f"""
+ {interface_name}: {interface.get("refs", None) or "[]"}, """
+ js_obj_interfaces += "}"
+
+ js_obj_user_fn_refs = "{"
+ if user_fn_refs is not None:
+ for class_name, refs in user_fn_refs.items():
+ js_obj_user_fn_refs += f"""
+ {class_name}: {refs}, """
+
+ js_obj_user_fn_refs += "}"
+
+ return rf"""function() {{
+ const refs = {js_obj_interfaces};
+ const user_fn_refs = {js_obj_user_fn_refs};
+ requestAnimationFrame(() => {{
+
+ Object.entries(user_fn_refs).forEach(([key, refs]) => {{
+ if (refs.length > 0) {{
+ const el = document.querySelector(`.${{key}}-user-fn`);
+ if (!el) return;
+ refs.forEach(ref => {{
+ el.innerHTML = el.innerHTML.replace(
+ new RegExp("\\b"+ref+"\\b", "g"),
+ `${{ref}}`
+ );
+ }})
+ }}
+ }})
+
+ Object.entries(refs).forEach(([key, refs]) => {{
+ if (refs.length > 0) {{
+ const el = document.querySelector(`.${{key}}`);
+ if (!el) return;
+ refs.forEach(ref => {{
+ el.innerHTML = el.innerHTML.replace(
+ new RegExp("\\b"+ref+"\\b", "g"),
+ `${{ref}}`
+ );
+ }})
+ }}
+ }})
+ }})
+}}
+"""
+
+
+def render_additional_interfaces(interfaces):
+ """Renders additional helper classes or types that were extracted earlier."""
+
+ source = ""
+ for interface_name, interface in interfaces.items():
+ source += f"""
+ code_{interface_name} = gr.Markdown(\"\"\"
+## `{interface_name}`
+```python
+{interface["source"]}
+```\"\"\", elem_classes=["md-custom", "{interface_name}"], header_links=True)
+"""
+ return source
+
+
+def render_additional_interfaces_markdown(interfaces):
+ """Renders additional helper classes or types that were extracted earlier."""
+
+ source = ""
+ for interface_name, interface in interfaces.items():
+ source += f"""
+## `{interface_name}`
+```python
+{interface["source"]}
+```
+"""
+ return source
+
+
+def render_version_badge(pypi_exists, local_version, name):
+ """Renders a version badge for the package. PyPi badge if it exists, otherwise a static badge."""
+ if pypi_exists:
+ return f"""
"""
+ else:
+ return f"""
"""
+
+
+def render_github_badge(repo):
+ """Renders a github badge for the package if a repo is specified."""
+ if repo is None:
+ return ""
+ else:
+ return f"""
"""
+
+
+def render_discuss_badge(space):
+ """Renders a discuss badge for the package if a space is specified."""
+ if space is None:
+ return ""
+ else:
+ return f"""
"""
+
+
+def render_class_events(events: dict, name):
+ """Renders the events for a class."""
+ if len(events) == 0:
+ return ""
+
+ else:
+ return f"""
+ gr.Markdown("### Events")
+ gr.ParamViewer(value=_docs["{name}"]["events"], linkify={["Event"]})
+
+"""
+
+
+def make_user_fn(
+ class_name,
+ user_fn_input_type,
+ user_fn_input_description,
+ user_fn_output_type,
+ user_fn_output_description,
+):
+ """Makes the user function for the class."""
+ if (
+ user_fn_input_type is None
+ and user_fn_output_type is None
+ and user_fn_input_description is None
+ and user_fn_output_description is None
+ ):
+ return ""
+
+ md = """
+ gr.Markdown(\"\"\"
+
+### User function
+
+The impact on the users predict function varies depending on whether the component is used as an input or output for an event (or both).
+
+- When used as an Input, the component only impacts the input signature of the user function.
+- When used as an output, the component only impacts the return signature of the user function.
+
+The code snippet below is accurate in cases where the component is used as both an input and an output.
+
+"""
+
+ md += (
+ f"- **As input:** Is passed, {format_description(user_fn_input_description)}\n"
+ if user_fn_input_description
+ else ""
+ )
+
+ md += (
+ f"- **As output:** Should return, {format_description(user_fn_output_description)}"
+ if user_fn_output_description
+ else ""
+ )
+
+ if user_fn_input_type is not None or user_fn_output_type is not None:
+ md += f"""
+
+ ```python
+def predict(
+ value: {user_fn_input_type or "Unknown"}
+) -> {user_fn_output_type or "Unknown"}:
+ return value
+```"""
+ return f"""{md}
+\"\"\", elem_classes=["md-custom", "{class_name}-user-fn"], header_links=True)
+"""
+
+
+def format_description(description):
+ description = description[0].lower() + description[1:]
+ description = description.rstrip(".") + "."
+ return description
+
+
+def make_user_fn_markdown(
+ user_fn_input_type,
+ user_fn_input_description,
+ user_fn_output_type,
+ user_fn_output_description,
+):
+ """Makes the user function for the class."""
+ if (
+ user_fn_input_type is None
+ and user_fn_output_type is None
+ and user_fn_input_description is None
+ and user_fn_output_description is None
+ ):
+ return ""
+
+ md = """
+### User function
+
+The impact on the users predict function varies depending on whether the component is used as an input or output for an event (or both).
+
+- When used as an Input, the component only impacts the input signature of the user function.
+- When used as an output, the component only impacts the return signature of the user function.
+
+The code snippet below is accurate in cases where the component is used as both an input and an output.
+
+"""
+
+ md += (
+ f"- **As output:** Is passed, {format_description(user_fn_input_description)}\n"
+ if user_fn_input_description
+ else ""
+ )
+
+ md += (
+ f"- **As input:** Should return, {format_description(user_fn_output_description)}"
+ if user_fn_output_description
+ else ""
+ )
+
+ if user_fn_input_type is not None or user_fn_output_type is not None:
+ md += f"""
+
+ ```python
+ def predict(
+ value: {user_fn_input_type or "Unknown"}
+ ) -> {user_fn_output_type or "Unknown"}:
+ return value
+ ```
+ """
+ return md
+
+
+def render_class_events_markdown(events):
+ """Renders the events for a class."""
+ if len(events) == 0:
+ return ""
+
+ event_table = """
+### Events
+
+| name | description |
+|:-----|:------------|
+"""
+
+ for event_name, event in events.items():
+ event_table += f"| `{event_name}` | {event['description']} |\n"
+
+ return event_table
+
+
+def render_class_docs(exports, docs):
+ """Renders the class documentation for the package."""
+ docs_classes = ""
+ for class_name in exports:
+ user_fn_input_type = get_deep(
+ docs, [class_name, "members", "preprocess", "return", "type"]
+ )
+ user_fn_input_description = get_deep(
+ docs, [class_name, "members", "preprocess", "return", "description"]
+ )
+ user_fn_output_type = get_deep(
+ docs, [class_name, "members", "postprocess", "value", "type"]
+ )
+ user_fn_output_description = get_deep(
+ docs, [class_name, "members", "postprocess", "value", "description"]
+ )
+
+ linkify = get_deep(docs, ["__meta__", "additional_interfaces"], {}) or {}
+
+ docs_classes += f"""
+ gr.Markdown(\"\"\"
+## `{class_name}`
+
+### Initialization
+\"\"\", elem_classes=["md-custom"], header_links=True)
+
+ gr.ParamViewer(value=_docs["{class_name}"]["members"]["__init__"], linkify={
+ list(linkify.keys())
+ })
+
+{render_class_events(docs[class_name].get("events", None), class_name)}
+
+{
+ make_user_fn(
+ class_name,
+ user_fn_input_type,
+ user_fn_input_description,
+ user_fn_output_type,
+ user_fn_output_description,
+ )
+ }
+"""
+ return docs_classes
+
+
+html = """
+
+
+
+| name |
+type |
+default |
+description |
+
+
+
+value |
+list[Parameter] | None |
+None |
+A list of dictionaries with keys "type", "description", and "default" for each parameter. |
+
+
+"""
+
+
+def render_param_table(params):
+ """Renders the parameter table for the package."""
+ table = """
+
+
+| name |
+type |
+default |
+description |
+
+
+"""
+
+ # for class_name in exports:
+ # docs_classes += f"""
+ # """
+ for param_name, param in params.items():
+ table += f"""
+
+{param_name} |
+
+
+```python
+{param["type"]}
+```
+
+ |
+{param["default"]} |
+{param["description"]} |
+
+"""
+ return table + "
"
+
+
+def render_class_docs_markdown(exports, docs):
+ """Renders the class documentation for the package."""
+ docs_classes = ""
+ for class_name in exports:
+ user_fn_input_type = get_deep(
+ docs, [class_name, "members", "preprocess", "return", "type"]
+ )
+ user_fn_input_description = get_deep(
+ docs, [class_name, "members", "preprocess", "return", "description"]
+ )
+ user_fn_output_type = get_deep(
+ docs, [class_name, "members", "postprocess", "value", "type"]
+ )
+ user_fn_output_description = get_deep(
+ docs, [class_name, "members", "postprocess", "value", "description"]
+ )
+ docs_classes += f"""
+## `{class_name}`
+
+### Initialization
+
+{render_param_table(docs[class_name]["members"]["__init__"])}
+
+{render_class_events_markdown(docs[class_name].get("events", None))}
+
+{
+ make_user_fn_markdown(
+ user_fn_input_type,
+ user_fn_input_description,
+ user_fn_output_type,
+ user_fn_output_description,
+ )
+ }
+"""
+ return docs_classes
+
+
+def make_space(
+ docs: dict,
+ name: str,
+ description: str,
+ local_version: str | None,
+ demo: str,
+ space: str | None,
+ repo: str | None,
+ pypi_exists: bool,
+ suppress_demo_check: bool = False,
+):
+ filtered_keys = [key for key in docs if key != "__meta__"]
+
+ if not suppress_demo_check and (
+ demo.find("if __name__ == '__main__'") == -1
+ and demo.find('if __name__ == "__main__"') == -1
+ ):
+ raise ValueError(
+ """The demo must be launched using `if __name__ == '__main__'`, otherwise the docs page will not function correctly.
+
+To fix this error, launch the demo inside of an if statement like this:
+
+if __name__ == '__main__':
+ demo.launch()
+
+To ignore this error pass `--suppress-demo-check` to the docs command."""
+ )
+ demo = demo.replace('"""', '\\"\\"\\"')
+
+ source = """
+import gradio as gr
+from app import demo as app
+import os
+"""
+
+ docs_classes = render_class_docs(filtered_keys, docs)
+
+ source += f"""
+_docs = {docs}
+
+abs_path = os.path.join(os.path.dirname(__file__), "css.css")
+
+with gr.Blocks(
+ css=abs_path,
+ theme=gr.themes.Default(
+ font_mono=[
+ gr.themes.GoogleFont("Inconsolata"),
+ "monospace",
+ ],
+ ),
+) as demo:
+ gr.Markdown(
+\"\"\"
+# `{name}`
+
+
+{render_version_badge(pypi_exists, local_version, name)} {render_github_badge(repo)} {render_discuss_badge(space)}
+
+
+{description}
+\"\"\", elem_classes=["md-custom"], header_links=True)
+ app.render()
+ gr.Markdown(
+\"\"\"
+## Installation
+
+```bash
+pip install {name}
+```
+
+## Usage
+
+```python
+{demo}
+```
+\"\"\", elem_classes=["md-custom"], header_links=True)
+
+{docs_classes}
+
+{render_additional_interfaces(docs["__meta__"]["additional_interfaces"])}
+ demo.load(None, js=r\"\"\"{make_js(get_deep(docs, ["__meta__", "additional_interfaces"]), get_deep(docs, ["__meta__", "user_fn_refs"]))}
+\"\"\")
+
+demo.launch()
+"""
+
+ return source
+
+
+def make_markdown(
+ docs, name, description, local_version, demo, space, repo, pypi_exists
+):
+ filtered_keys = [key for key in docs if key != "__meta__"]
+
+ source = f"""
+# `{name}`
+{render_version_badge(pypi_exists, local_version, name)} {render_github_badge(repo)} {render_discuss_badge(space)}
+
+{description}
+
+## Installation
+
+```bash
+pip install {name}
+```
+
+## Usage
+
+```python
+{demo}
+```
+"""
+
+ docs_classes = render_class_docs_markdown(filtered_keys, docs)
+
+ source += docs_classes
+
+ source += render_additional_interfaces_markdown(
+ docs["__meta__"]["additional_interfaces"]
+ )
+
+ return source
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/app.py b/lib/python3.11/site-packages/gradio/cli/commands/components/app.py
new file mode 100644
index 0000000000000000000000000000000000000000..d42252a024afc6b4753623516ab95ab2d837e688
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/app.py
@@ -0,0 +1,24 @@
+from typer import Typer
+
+from .build import _build
+from .create import _create
+from .dev import _dev
+from .docs import _docs
+from .install_component import _install
+from .publish import _publish
+from .show import _show
+
+app = Typer(help="Create and publish a new Gradio component")
+
+app.command("create", help="Create a new component.")(_create)
+app.command(
+ "build",
+ help="Build the component for distribution. Must be called from the component directory.",
+)(_build)
+app.command("dev", help="Launch the custom component demo in development mode.")(_dev)
+app.command("show", help="Show the list of available templates")(_show)
+app.command("install", help="Install the custom component in the current environment")(
+ _install
+)
+app.command("publish", help="Publish a component to PyPI and HuggingFace Hub")(_publish)
+app.command("docs", help="Generate documentation for a custom components")(_docs)
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/build.py b/lib/python3.11/site-packages/gradio/cli/commands/components/build.py
new file mode 100644
index 0000000000000000000000000000000000000000..c32ed48e0f1d60fa3d0667836a707697df678273
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/build.py
@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import importlib
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Annotated
+
+import semantic_version
+import typer
+from tomlkit import dump, parse
+
+import gradio
+from gradio.analytics import custom_component_analytics
+from gradio.cli.commands.components._docs_utils import (
+ get_deep,
+)
+from gradio.cli.commands.components.docs import run_command
+from gradio.cli.commands.components.install_component import _get_executable_path
+from gradio.cli.commands.display import LivePanelDisplay
+
+gradio_template_path = Path(gradio.__file__).parent / "templates" / "frontend" # type: ignore
+
+
+def _build(
+ path: Annotated[
+ Path, typer.Argument(help="The directory of the custom component.")
+ ] = Path("."),
+ build_frontend: Annotated[
+ bool, typer.Option(help="Whether to build the frontend as well.")
+ ] = True,
+ bump_version: Annotated[
+ bool, typer.Option(help="Whether to bump the version number automatically.")
+ ] = False,
+ generate_docs: Annotated[
+ bool, typer.Option(help="Whether to generate the documentation as well.")
+ ] = True,
+ python_path: Annotated[
+ str | None,
+ typer.Option(
+ help="Path to python executable. If None, will use the default path found by `which python3`. If python3 is not found, `which python` will be tried. If both fail an error will be raised."
+ ),
+ ] = None,
+):
+ custom_component_analytics(
+ "build",
+ None,
+ None,
+ None,
+ None,
+ generate_docs=generate_docs,
+ bump_version=bump_version,
+ )
+ name = Path(path).resolve()
+ if not (name / "pyproject.toml").exists():
+ raise ValueError(f"Cannot find pyproject.toml file in {name}")
+
+ with LivePanelDisplay() as live:
+ live.update(
+ f":package: Building package in [orange3]{str(name.name)}[/]", add_sleep=0.2
+ )
+ pyproject_toml = parse((path / "pyproject.toml").read_text())
+ package_name = get_deep(pyproject_toml, ["project", "name"])
+
+ python_path = _get_executable_path(
+ "python", python_path, "--python-path", check_3=True
+ )
+
+ if not isinstance(package_name, str):
+ raise ValueError(
+ "Your pyproject.toml file does not have a [project] name field!"
+ )
+ try:
+ importlib.import_module(package_name) # type: ignore
+ except ModuleNotFoundError as e:
+ raise ValueError(
+ f"Your custom component package ({package_name}) is not installed! "
+ "Please install it with the gradio cc install command before building it."
+ ) from e
+ if bump_version:
+ pyproject_toml = parse((path / "pyproject.toml").read_text())
+ version = semantic_version.Version(
+ pyproject_toml["project"]["version"] # type: ignore
+ ).next_patch()
+ live.update(
+ f":1234: Using version [bold][magenta]{version}[/][/]. "
+ "Set [bold][magenta]--no-bump-version[/][/] to use the version in pyproject.toml file."
+ )
+ pyproject_toml["project"]["version"] = str(version) # type: ignore
+ with open(path / "pyproject.toml", "w", encoding="utf-8") as f:
+ dump(pyproject_toml, f)
+ else:
+ version = pyproject_toml["project"]["version"] # type: ignore
+ live.update(
+ f":1234: Package will use version [bold][magenta]{version}[/][/] defined in pyproject.toml file. "
+ "Set [bold][magenta]--bump-version[/][/] to automatically bump the version number."
+ )
+
+ if generate_docs:
+ _demo_dir = Path("demo").resolve()
+ _demo_name = "app.py"
+ _demo_path = _demo_dir / _demo_name
+ _readme_path = name / "README.md"
+
+ run_command(
+ live=live,
+ name=package_name,
+ suppress_demo_check=False,
+ pyproject_toml=pyproject_toml,
+ generate_space=True,
+ generate_readme=True,
+ type_mode="simple",
+ _demo_path=_demo_path,
+ _demo_dir=_demo_dir,
+ _readme_path=_readme_path,
+ space_url=None,
+ _component_dir=name,
+ simple=True,
+ )
+
+ if build_frontend:
+ live.update(":art: Building frontend")
+ component_directory = path.resolve()
+
+ node = shutil.which("node")
+ if not node:
+ raise ValueError(
+ "node must be installed in order to run build command."
+ )
+
+ gradio_node_path = subprocess.run(
+ [node, "-e", "console.log(require.resolve('@gradio/preview'))"],
+ cwd=Path(component_directory / "frontend"),
+ check=False,
+ capture_output=True,
+ )
+
+ if gradio_node_path.returncode != 0:
+ raise ValueError(
+ "Could not find `@gradio/preview`. Run `npm i -D @gradio/preview` in your frontend folder."
+ )
+
+ gradio_node_path = gradio_node_path.stdout.decode("utf-8").strip()
+
+ node_cmds = [
+ node,
+ gradio_node_path,
+ "--component-directory",
+ component_directory,
+ "--root",
+ gradio_template_path,
+ "--mode",
+ "build",
+ "--python-path",
+ python_path,
+ ]
+ pipe = subprocess.run(
+ node_cmds, capture_output=True, text=True, check=False
+ )
+ if pipe.returncode != 0:
+ live.update(":red_square: Build failed!")
+ live.update(pipe.stderr)
+ live.update(pipe.stdout)
+ raise SystemExit("Frontend build failed")
+ else:
+ live.update(":white_check_mark: Build succeeded!")
+
+ cmds = [python_path, "-m", "build", str(name)]
+ live.update(f":construction_worker: Building... [grey37]({' '.join(cmds)})[/]")
+ pipe = subprocess.run(cmds, capture_output=True, text=True, check=False)
+ if pipe.returncode != 0:
+ live.update(":red_square: Build failed!")
+ live.update(pipe.stderr)
+ raise SystemExit("Python build failed")
+ else:
+ live.update(":white_check_mark: Build succeeded!")
+ live.update(
+ f":ferris_wheel: Wheel located in [orange3]{str(name / 'dist')}[/]"
+ )
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/create.py b/lib/python3.11/site-packages/gradio/cli/commands/components/create.py
new file mode 100644
index 0000000000000000000000000000000000000000..2867438acf2e2457c1efb06c81b8edcb84502ff9
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/create.py
@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import inspect
+import shutil
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich import print
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from tomlkit import dump, parse
+
+import gradio
+from gradio.analytics import custom_component_analytics
+
+from ..display import LivePanelDisplay
+from . import _create_utils
+from .install_component import _get_npm, _install_command
+
+
+def _create(
+ name: Annotated[
+ str,
+ typer.Argument(
+ help="Name of the component. Preferably in camel case, i.e. MyTextBox."
+ ),
+ ],
+ directory: Annotated[
+ Path | None,
+ typer.Option(
+ help="Directory to create the component in. Default is None. If None, will be created in directory in the current directory."
+ ),
+ ] = None,
+ package_name: Annotated[
+ str | None,
+ typer.Option(help="Name of the package. Default is gradio_{name.lower()}"),
+ ] = None,
+ template: Annotated[
+ str,
+ typer.Option(
+ help="Component to use as a template. Should use exact name of python class."
+ ),
+ ] = "",
+ install: Annotated[
+ bool,
+ typer.Option(
+ help="Whether to install the component in your current environment as a development install. Recommended for development."
+ ),
+ ] = True,
+ npm_install: Annotated[
+ str,
+ typer.Option(help="NPM install command to use. Default is 'npm install'."),
+ ] = "npm install",
+ pip_path: Annotated[
+ str | None,
+ typer.Option(
+ help="Path to pip executable. If None, will use the default path found by `which pip3`. If pip3 is not found, `which pip` will be tried. If both fail an error will be raised."
+ ),
+ ] = None,
+ overwrite: Annotated[
+ bool,
+ typer.Option(help="Whether to overwrite the existing component if it exists."),
+ ] = False,
+ configure_metadata: Annotated[
+ bool,
+ typer.Option(
+ help="Whether to interactively configure project metadata based on user input"
+ ),
+ ] = True,
+):
+ custom_component_analytics(
+ "create",
+ template,
+ None,
+ None,
+ None,
+ npm_install=npm_install,
+ )
+ if not directory:
+ directory = Path(name.lower())
+ if not package_name:
+ package_name = f"gradio_{name.lower()}"
+
+ if directory.exists() and not overwrite:
+ raise ValueError(
+ f"The directory {directory.resolve()} already exists. "
+ "Please set --overwrite flag or pass in the name "
+ "of a directory that does not already exist via the --directory option."
+ )
+ elif directory.exists() and overwrite:
+ _create_utils.delete_contents(directory)
+
+ directory.mkdir(exist_ok=overwrite)
+
+ if _create_utils._in_test_dir():
+ npm_install = f"{shutil.which('pnpm')} i --ignore-scripts"
+ else:
+ npm_install = _get_npm(npm_install)
+
+ with LivePanelDisplay() as live:
+ live.update(
+ f":building_construction: Creating component [orange3]{name}[/] in directory [orange3]{directory}[/]",
+ add_sleep=0.2,
+ )
+ if template:
+ live.update(f":fax: Starting from template [orange3]{template}[/]")
+ else:
+ live.update(":page_facing_up: Creating a new component from scratch.")
+
+ component = _create_utils._get_component_code(template)
+
+ _create_utils._create_backend(name, component, directory, package_name)
+ live.update(":snake: Created backend code", add_sleep=0.2)
+ p = Path(inspect.getfile(gradio)).parent
+ component_source = p / "_frontend_code"
+ if not component_source.exists():
+ live.update(
+ ":fast_down_button: Downloading frontend code from Hugging Face Hub. Set HF_HUB_DISABLE_PROGRESS_BARS to disable progress bars.",
+ add_sleep=0.2,
+ )
+ _create_utils._create_frontend(
+ name.lower(), component, directory=directory, package_name=package_name
+ )
+ live.update(":art: Created frontend code", add_sleep=0.2)
+
+ if install:
+ _install_command(directory, live, npm_install, pip_path)
+
+ live._panel.stop()
+
+ description = "A gradio custom component"
+ keywords = []
+
+ if configure_metadata:
+ print(
+ Panel(
+ "It is recommended to answer the following [bold][magenta]4 questions[/][/] to finish configuring your custom component's metadata."
+ "\nYou can also answer them later by editing the [bold][magenta]pyproject.toml[/][/] file in your component directory."
+ )
+ )
+
+ answer_qs = Confirm.ask("\nDo you want to answer them now?")
+
+ pyproject_toml = parse((directory / "pyproject.toml").read_text())
+
+ if answer_qs:
+ name = pyproject_toml["project"]["name"] # type: ignore
+
+ description = Prompt.ask(
+ "\n:pencil: Please enter a one sentence [bold][magenta]description[/][/] for your component"
+ )
+ if description:
+ pyproject_toml["project"]["description"] = description # type: ignore
+
+ license_ = (
+ Prompt.ask(
+ "\n:bookmark_tabs: Please enter a [bold][magenta]software license[/][/] for your component. Leave blank for 'apache-2.0'"
+ )
+ or "apache-2.0"
+ )
+ print(f":bookmark_tabs: Using license [bold][magenta]{license_}[/][/]")
+ pyproject_toml["project"]["license"] = license_ # type: ignore
+
+ requires_python = Prompt.ask(
+ "\n:snake: Please enter the [bold][magenta]allowed python[/][/] versions for your component. Leave blank for '>=3.10'"
+ )
+ requires_python = requires_python or ">=3.10"
+ print(
+ f":snake: Using requires-python of [bold][magenta]{requires_python}[/][/]"
+ )
+ pyproject_toml["project"]["requires-python"] = ( # type: ignore
+ requires_python or ">=3.10"
+ )
+
+ print(
+ "\n:label: Please add some keywords to help others discover your component."
+ )
+ while True:
+ keyword = Prompt.ask(":label: Leave blank to stop adding keywords")
+ if keyword:
+ keywords.append(keyword)
+ else:
+ break
+ current_keywords = pyproject_toml["project"].get("keywords", []) # type: ignore
+ pyproject_toml["project"]["keywords"] = current_keywords + keywords # type: ignore
+ with open(directory / "pyproject.toml", "w", encoding="utf-8") as f:
+ dump(pyproject_toml, f)
+
+ (directory / "demo" / "requirements.txt").write_text(package_name)
+ readme_path = Path(__file__).parent / "files" / "README.md"
+
+ readme_contents = readme_path.read_text()
+ tags = f", {', '.join(keywords)}" if keywords else ""
+ template = f", {template}"
+ readme_contents = (
+ readme_contents.replace("<>", package_name)
+ .replace("<<short-description>>", description)
+ .replace("<<tags>>", tags)
+ .replace("<<template>>", template)
+ )
+ (directory / "README.md").write_text(readme_contents)
+
+ print("\nComponent creation [bold][magenta]complete[/][/]!")
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/dev.py b/lib/python3.11/site-packages/gradio/cli/commands/components/dev.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbaee98dcd88f222b98f30bd5ae8afd9de1d94c6
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/dev.py
@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich import print
+
+import gradio
+from gradio.analytics import custom_component_analytics
+from gradio.cli.commands.components.install_component import _get_executable_path
+
+gradio_template_path = Path(gradio.__file__).parent / "templates" / "frontend" # type: ignore
+
+
+def _dev(
+ app: Annotated[
+ Path,
+ typer.Argument(
+ help="The path to the app. By default, looks for demo/app.py in the current directory."
+ ),
+ ] = Path("demo") / "app.py",
+ component_directory: Annotated[
+ Path,
+ typer.Option(
+ help="The directory with the custom component source code. By default, uses the current directory."
+ ),
+ ] = Path("."),
+ host: Annotated[
+ str,
+ typer.Option(
+ help="The host to run the front end server on. Defaults to localhost.",
+ ),
+ ] = "localhost",
+ python_path: Annotated[
+ str | None,
+ typer.Option(
+ help="Path to python executable. If None, will use the default path found by `which python3`. If python3 is not found, `which python` will be tried. If both fail an error will be raised."
+ ),
+ ] = None,
+ gradio_path: Annotated[
+ str | None,
+ typer.Option(
+ help="Path to gradio executable. If None, will use the default path found by `shutil.which`."
+ ),
+ ] = None,
+):
+ custom_component_analytics(
+ "dev",
+ None,
+ None,
+ None,
+ None,
+ python_path=python_path,
+ gradio_path=gradio_path,
+ )
+ component_directory = component_directory.resolve()
+
+ print(f":recycle: [green]Launching[/] {app} in reload mode\n")
+
+ node = shutil.which("node")
+ if not node:
+ raise ValueError("node must be installed in order to run dev mode.")
+
+ python_path = _get_executable_path(
+ "python", python_path, cli_arg_name="--python-path", check_3=True
+ )
+ gradio_path = _get_executable_path(
+ "gradio", gradio_path, cli_arg_name="--gradio-path"
+ )
+
+ gradio_node_path = subprocess.run(
+ [node, "-e", "console.log(require.resolve('@gradio/preview'))"],
+ cwd=Path(component_directory / "frontend"),
+ check=False,
+ capture_output=True,
+ )
+
+ if gradio_node_path.returncode != 0:
+ raise ValueError(
+ "Could not find `@gradio/preview`. Run `npm i -D @gradio/preview` in your frontend folder."
+ )
+
+ gradio_node_path = gradio_node_path.stdout.decode("utf-8").strip()
+
+ proc = subprocess.Popen(
+ [
+ node,
+ gradio_node_path,
+ "--component-directory",
+ component_directory,
+ "--root",
+ gradio_template_path,
+ "--app",
+ str(app),
+ "--mode",
+ "dev",
+ "--host",
+ host,
+ "--python-path",
+ python_path,
+ "--gradio-path",
+ gradio_path,
+ ],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT,
+ )
+ while True:
+ proc.poll()
+ text = proc.stdout.readline() # type: ignore
+ err = None
+ if proc.stderr:
+ err = proc.stderr.readline()
+
+ text = (
+ text.decode("utf-8")
+ .replace("Changes detected in:", "[orange3]Changed detected in:[/]")
+ .replace("Watching:", "[orange3]Watching:[/]")
+ .replace("Running on local URL", "[orange3]Backend Server[/]")
+ )
+
+ if "[orange3]Watching:[/]" in text:
+ text += f"'{str(component_directory / 'frontend').strip()}',"
+ if "To create a public link" in text:
+ continue
+ print(text)
+ if err:
+ print(err.decode("utf-8"))
+
+ if proc.returncode is not None:
+ print("Backend server failed to launch. Exiting.")
+ return
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/docs.py b/lib/python3.11/site-packages/gradio/cli/commands/components/docs.py
new file mode 100644
index 0000000000000000000000000000000000000000..73d037228fade658ac5267e94f377b67857634c0
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/docs.py
@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import importlib
+import re
+from pathlib import Path
+from typing import Annotated, Any
+
+import httpx
+import tomlkit as toml
+from typer import Argument, Option
+
+from gradio.analytics import custom_component_analytics
+from gradio.cli.commands.display import LivePanelDisplay
+
+from ._docs_assets import css
+from ._docs_utils import (
+ RUFF_INSTALLED,
+ extract_docstrings,
+ get_deep,
+ make_markdown,
+ make_space,
+)
+
+
+def _docs(
+ path: Annotated[
+ Path, Argument(help="The directory of the custom component.")
+ ] = Path("."),
+ demo_dir: Annotated[Path | None, Option(help="Path to the demo directory.")] = None,
+ demo_name: Annotated[str | None, Option(help="Name of the demo file.")] = None,
+ readme_path: Annotated[
+ Path | None, Option(help="Path to the README.md file.")
+ ] = None,
+ space_url: Annotated[
+ str | None, Option(help="URL of the Space to use for the demo.")
+ ] = None,
+ generate_space: Annotated[
+ bool,
+ Option(
+ help="Create a documentation space for the custom compone.", is_flag=True
+ ),
+ ] = True,
+ generate_readme: Annotated[
+ bool,
+ Option(help="Create a README.md file for the custom component.", is_flag=True),
+ ] = True,
+ suppress_demo_check: Annotated[
+ bool,
+ Option(
+ help="Suppress demo warnings and errors.",
+ is_flag=True,
+ ),
+ ] = False,
+):
+ """Runs the documentation generator."""
+ custom_component_analytics(
+ "docs",
+ None,
+ None,
+ None,
+ None,
+ )
+
+ _component_dir = Path(path).resolve()
+ _demo_dir = Path(demo_dir).resolve() if demo_dir else Path("demo").resolve()
+ _demo_name = demo_name if demo_name else "app.py"
+ _demo_path = _demo_dir / _demo_name
+ _readme_path = (
+ Path(readme_path).resolve() if readme_path else _component_dir / "README.md"
+ )
+
+ if not generate_space and not generate_readme:
+ raise ValueError("Must generate at least one of space or readme")
+
+ with LivePanelDisplay() as live:
+ live.update(
+ f":page_facing_up: Generating documentation for [orange3]{str(_component_dir.name)}[/]",
+ add_sleep=0.2,
+ )
+ live.update(
+ f":eyes: Reading project metadata from [orange3]{_component_dir}/pyproject.toml[/]\n"
+ )
+
+ if not (_component_dir / "pyproject.toml").exists():
+ raise ValueError(
+ f"Cannot find pyproject.toml file in [orange3]{_component_dir}[/]"
+ )
+
+ with open(_component_dir / "pyproject.toml", encoding="utf-8") as f:
+ data = toml.loads(f.read())
+
+ name = get_deep(data, ["project", "name"])
+
+ if not isinstance(name, str):
+ raise ValueError("Name not found in pyproject.toml")
+
+ if not RUFF_INSTALLED:
+ live.update(
+ "\n:warning: [yellow]Ruff is not installed. Code snippets will not be formatted. To install, run `pip install ruff`.[/]"
+ )
+
+ run_command(
+ live=live,
+ name=name,
+ suppress_demo_check=suppress_demo_check,
+ pyproject_toml=data,
+ generate_space=generate_space,
+ generate_readme=generate_readme,
+ type_mode="simple",
+ _demo_path=_demo_path,
+ _demo_dir=_demo_dir,
+ _readme_path=_readme_path,
+ space_url=space_url,
+ _component_dir=_component_dir,
+ )
+
+
+def run_command(
+ live: LivePanelDisplay,
+ name: str,
+ pyproject_toml: dict[str, Any],
+ suppress_demo_check: bool,
+ generate_space: bool,
+ generate_readme: bool,
+ type_mode: str,
+ _demo_path: Path,
+ _demo_dir: Path,
+ _readme_path: Path,
+ space_url: str | None,
+ _component_dir: Path,
+ simple: bool = False,
+):
+ with open(_demo_path, encoding="utf-8") as f:
+ demo = f.read()
+
+ pypi_exists = httpx.get(f"https://pypi.org/pypi/{name}/json").status_code
+
+ pypi_exists = pypi_exists == 200 or False
+
+ local_version = get_deep(pyproject_toml, ["project", "version"])
+ description = str(get_deep(pyproject_toml, ["project", "description"]) or "")
+ repo = get_deep(pyproject_toml, ["project", "urls", "repository"])
+ space = (
+ space_url
+ if space_url
+ else get_deep(pyproject_toml, ["project", "urls", "space"])
+ )
+
+ if not local_version and not pypi_exists:
+ raise ValueError(
+ f"Cannot find version in pyproject.toml or on PyPI for [orange3]{name}[/].\nIf you have just published to PyPI, please wait a few minutes and try again."
+ )
+ module = importlib.import_module(name)
+ (docs, type_mode) = extract_docstrings(module)
+
+ if generate_space:
+ if not simple:
+ live.update(":computer: [blue]Generating space.[/]")
+
+ source = make_space(
+ docs=docs,
+ name=name,
+ description=description,
+ local_version=local_version
+ if local_version is None
+ else str(local_version),
+ demo=demo,
+ space=space if space is None else str(space),
+ repo=repo if repo is None else str(repo),
+ pypi_exists=pypi_exists,
+ suppress_demo_check=suppress_demo_check,
+ )
+
+ with open(_demo_dir / "space.py", "w", encoding="utf-8") as f:
+ f.write(source)
+ if not simple:
+ live.update(
+ f":white_check_mark: Space created in [orange3]{_demo_dir}/space.py[/]\n"
+ )
+ with open(_demo_dir / "css.css", "w", encoding="utf-8") as f:
+ f.write(css)
+
+ if generate_readme:
+ if not simple:
+ live.update(":pencil: [blue]Generating README.[/]")
+ readme = make_markdown(
+ docs, name, description, local_version, demo, space, repo, pypi_exists
+ )
+
+ readme_content = Path(_readme_path).read_text()
+
+ with open(_readme_path, "w", encoding="utf-8") as f:
+ yaml_regex = re.search(
+ "(?:^|[\r\n])---[\n\r]+([\\S\\s]*?)[\n\r]+---([\n\r]|$)", readme_content
+ )
+ if yaml_regex is not None:
+ readme = readme_content[: yaml_regex.span()[-1]] + readme
+ f.write(readme)
+ if not simple:
+ live.update(
+ f":white_check_mark: README generated in [orange3]{_readme_path}[/]"
+ )
+ if simple:
+ short_readme_path = Path(_readme_path).relative_to(_component_dir)
+ short_demo_path = Path(_demo_dir / "space.py").relative_to(_component_dir)
+ live.update(
+ f":white_check_mark: Documentation generated in [orange3]{short_demo_path}[/] and [orange3]{short_readme_path}[/]. Pass --no-generate-docs to disable auto documentation."
+ )
+
+ if type_mode == "simple":
+ live.update(
+ "\n:orange_circle: [red]The docs were generated in simple mode. Updating python to a more recent version will result in richer documentation.[/]"
+ )
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/files/README.md b/lib/python3.11/site-packages/gradio/cli/commands/components/files/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1c8256ec0fdf5c05bebcb6c744391b74cb526f06
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/files/README.md
@@ -0,0 +1,15 @@
+---
+tags: [gradio-custom-component<<template>><<tags>>]
+title: <<title>>
+short_description: <<short-description>>
+colorFrom: blue
+colorTo: yellow
+sdk: gradio
+pinned: false
+app_file: space.py
+---
+
+# <<title>>
+
+You can auto-generate documentation for your custom component with the `gradio cc docs` command.
+You can also edit this file however you like.
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/files/gitignore b/lib/python3.11/site-packages/gradio/cli/commands/components/files/gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..5dd75ecdbb6f74962bbede3376d2f1182679ec19
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/files/gitignore
@@ -0,0 +1,12 @@
+.eggs/
+dist/
+*.pyc
+__pycache__/
+*.py[cod]
+*$py.class
+__tmp/*
+*.pyi
+.mypycache
+.ruff_cache
+node_modules
+backend/**/templates/
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/files/gradio.config.js b/lib/python3.11/site-packages/gradio/cli/commands/components/files/gradio.config.js
new file mode 100644
index 0000000000000000000000000000000000000000..19f8f32584367502b94ff73d80c472108f7a896a
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/files/gradio.config.js
@@ -0,0 +1,9 @@
+export default {
+ plugins: [],
+ svelte: {
+ preprocess: [],
+ },
+ build: {
+ target: "modules",
+ },
+};
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/files/pyproject_.toml b/lib/python3.11/site-packages/gradio/cli/commands/components/files/pyproject_.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a5b978dd64b67657eac5026c88ae2dd20db90dae
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/files/pyproject_.toml
@@ -0,0 +1,54 @@
+[build-system]
+requires = [
+ "hatchling",
+ "hatch-requirements-txt",
+ "hatch-fancy-pypi-readme>=22.5.0",
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "<<name>>"
+version = "0.0.1"
+description = "Python library for easily interacting with trained machine learning models"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.8"
+authors = [{ name = "YOUR NAME", email = "YOUREMAIL@domain.com" }]
+keywords = [
+ "gradio-custom-component",
+ "<<template>>"
+]
+# Add dependencies here
+dependencies = ["gradio>=6.0,<7.0"]
+classifiers = [
+ 'Development Status :: 3 - Alpha',
+ 'Operating System :: OS Independent',
+ 'Programming Language :: Python :: 3',
+ 'Programming Language :: Python :: 3 :: Only',
+ 'Programming Language :: Python :: 3.8',
+ 'Programming Language :: Python :: 3.9',
+ 'Programming Language :: Python :: 3.10',
+ 'Programming Language :: Python :: 3.11',
+ 'Topic :: Scientific/Engineering',
+ 'Topic :: Scientific/Engineering :: Artificial Intelligence',
+ 'Topic :: Scientific/Engineering :: Visualization',
+]
+
+# The repository and space URLs are optional, but recommended.
+# Adding a repository URL will create a badge in the auto-generated README that links to the repository.
+# Adding a space URL will create a badge in the auto-generated README that links to the space.
+# This will make it easy for people to find your deployed demo or source code when they
+# encounter your project in the wild.
+
+# [project.urls]
+# repository = "your github repository"
+# space = "your space url"
+
+[project.optional-dependencies]
+dev = ["build", "twine"]
+
+[tool.hatch.build]
+artifacts = ["/backend/<<name>>/templates", "*.pyi"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["/backend/<<name>>"]
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/files/tsconfig.json b/lib/python3.11/site-packages/gradio/cli/commands/components/files/tsconfig.json
new file mode 100644
index 0000000000000000000000000000000000000000..04273573e42fee3c99beacec3faf9ab94320148a
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/files/tsconfig.json
@@ -0,0 +1,14 @@
+{
+ "compilerOptions": {
+ "allowJs": true,
+ "checkJs": true,
+ "esModuleInterop": true,
+ "forceConsistentCasingInFileNames": true,
+ "resolveJsonModule": true,
+ "skipLibCheck": true,
+ "sourceMap": true,
+ "strict": true,
+ "verbatimModuleSyntax": true
+ },
+ "exclude": ["node_modules", "dist", "./gradio.config.js"]
+}
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/install_component.py b/lib/python3.11/site-packages/gradio/cli/commands/components/install_component.py
new file mode 100644
index 0000000000000000000000000000000000000000..6912e7e65091db49295dc5c15f62d02d7d5f0b86
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/install_component.py
@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Annotated
+
+from rich.markup import escape
+from typer import Argument, Option
+
+from gradio.cli.commands.display import LivePanelDisplay
+from gradio.utils import set_directory
+
+
+def _get_npm(npm_install: str):
+ npm_install = npm_install.strip()
+ if npm_install == "npm install":
+ npm = shutil.which("npm")
+ if not npm:
+ raise ValueError(
+ "By default, the install command uses npm to install "
+ "the frontend dependencies. Please install npm or pass your own install command "
+ "via the --npm-install option."
+ )
+ npm_install = f"{npm} install"
+ return npm_install
+
+
+def _get_executable_path(
+ executable: str,
+ executable_path: str | None,
+ cli_arg_name: str,
+ check_3: bool = False,
+) -> str:
+ """Get the path to an executable, either from the provided path or from the PATH environment variable.
+
+ The value of executable_path takes precedence in case the value in PATH is incorrect.
+ This should give more control to the developer in case their envrinment is not set up correctly.
+
+ If check_3 is True, we append 3 to the executable name to give python3 priority over python (same for pip).
+ """
+ if executable_path:
+ if not Path(executable_path).exists() or not Path(executable_path).is_file():
+ raise ValueError(
+ f"The provided {executable} path ({executable_path}) does not exist or is not a file."
+ )
+ return executable_path
+ path = shutil.which(executable)
+ if check_3:
+ path = shutil.which(f"{executable}3") or path
+ if not path:
+ raise ValueError(
+ f"Could not find {executable}. Please ensure it is installed and in your PATH or pass the {cli_arg_name} parameter."
+ )
+ return path
+
+
+def _install_command(
+ directory: Path, live: LivePanelDisplay, npm_install: str, pip_path: str | None
+):
+ pip_executable_path = _get_executable_path(
+ "pip", executable_path=pip_path, cli_arg_name="--pip-path", check_3=True
+ )
+ cmds = [pip_executable_path, "install", "-e", f"{str(directory)}[dev]"]
+ live.update(
+ f":construction_worker: Installing python... [grey37]({escape(' '.join(cmds))})[/]"
+ )
+ pipe = subprocess.run(cmds, capture_output=True, text=True, check=False)
+
+ if pipe.returncode != 0:
+ live.update(":red_square: Python installation [bold][red]failed[/][/]")
+ live.update(pipe.stderr)
+ raise SystemExit("Python installation failed")
+
+ else:
+ live.update(":white_check_mark: Python install succeeded!")
+
+ live.update(
+ f":construction_worker: Installing javascript... [grey37]({npm_install})[/]"
+ )
+ with set_directory(directory / "frontend"):
+ pipe = subprocess.run(
+ npm_install.split(), capture_output=True, text=True, check=False
+ )
+ if pipe.returncode != 0:
+ live.update(":red_square: NPM install [bold][red]failed[/][/]")
+ live.update(pipe.stdout)
+ live.update(pipe.stderr)
+ raise SystemExit("NPM install failed")
+ else:
+ live.update(":white_check_mark: NPM install succeeded!")
+
+
+def _install(
+ directory: Annotated[
+ Path, Argument(help="The directory containing the custom components.")
+ ] = Path("."),
+ npm_install: Annotated[
+ str, Option(help="NPM install command to use. Default is 'npm install'.")
+ ] = "npm install",
+ pip_path: Annotated[
+ str | None,
+ Option(
+ help="Path to pip executable. If None, will use the default path found by `which pip3`. If pip3 is not found, `which pip` will be tried. If both fail an error will be raised."
+ ),
+ ] = None,
+):
+ npm_install = _get_npm(npm_install)
+ with LivePanelDisplay() as live:
+ _install_command(directory, live, npm_install, pip_path)
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/publish.py b/lib/python3.11/site-packages/gradio/cli/commands/components/publish.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca5c52403cd66415871ec0b6aa5ff6402adf5f5f
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/publish.py
@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+import re
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Annotated
+
+import semantic_version
+from huggingface_hub import HfApi
+from packaging.version import Version as PEP440Version
+from rich import print
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from tomlkit import parse
+from typer import Argument, Option
+
+from gradio.analytics import custom_component_analytics
+
+colors = ["red", "yellow", "green", "blue", "indigo", "purple", "pink", "gray"]
+
+PYPI_REGISTER_URL = "https://pypi.org/account/register/"
+
+
+def _ignore(_src, names):
+ ignored = []
+ for n in names:
+ if "__pycache__" in n or n.startswith("dist") or n.startswith("node_modules"):
+ ignored.append(n)
+ return ignored
+
+
+def _get_version_from_file(dist_file: Path) -> str | None:
+ match = re.search(r"-(\d+\.\d+\.\d+[a-zA-Z]*\d*)-", dist_file.name)
+ if match:
+ return match.group(1)
+ return None
+
+
+def _parse_version(
+ version_string: str,
+) -> semantic_version.Version | PEP440Version | None:
+ """Parse a version string, trying semantic_version first, then PEP440."""
+ try:
+ return semantic_version.Version(version_string)
+ except ValueError:
+ try:
+ return PEP440Version(version_string)
+ except Exception:
+ return None
+
+
+def _get_max_version(distribution_files: list[Path]) -> str | None:
+ versions = []
+ for p in distribution_files:
+ version = _get_version_from_file(p)
+ # If anything goes wrong, just return None so we upload all files
+ # better safe than sorry
+ if version:
+ parsed = _parse_version(version)
+ if parsed:
+ versions.append(parsed)
+ else:
+ return None
+ return str(max(versions)) if versions else None
+
+
+def _publish(
+ dist_dir: Annotated[
+ Path,
+ Argument(help=f"Path to the wheel directory. Default is {Path('.') / 'dist'}"),
+ ] = Path(".") / "dist",
+ upload_pypi: Annotated[bool, Option(help="Whether to upload to PyPI.")] = True,
+ pypi_username: Annotated[str, Option(help="The username for PyPI.")] = "",
+ pypi_password: Annotated[str, Option(help="The password for PyPI.")] = "",
+ upload_demo: Annotated[
+ bool, Option(help="Whether to upload demo to HuggingFace.")
+ ] = True,
+ demo_dir: Annotated[Path | None, Option(help="Path to the demo directory.")] = None,
+ source_dir: Annotated[
+ Path,
+ Option(help="Path to the source directory of the custom component."),
+ ] = Path("."),
+ token: Annotated[
+ str | None,
+ Option(
+ help="HuggingFace token for uploading demo. Can be omitted if already logged in via huggingface cli."
+ ),
+ ] = None,
+ prefer_local: Annotated[
+ bool,
+ Option(
+ help="Install the package from the local wheel in the demo space, even if it exists on PyPi."
+ ),
+ ] = False,
+ upload_source: Annotated[
+ bool,
+ Option(
+ help="Whether to upload the source code of the custom component, to share with the community."
+ ),
+ ] = False,
+ repo_id: Annotated[
+ str | None,
+ Option(
+ help="The repository id to upload the demo to. If not provided, a space will be created with the same name as the package in the HuggingFace account corresponding to the token."
+ ),
+ ] = None,
+):
+ custom_component_analytics(
+ "publish",
+ None,
+ upload_demo=upload_demo,
+ upload_pypi=upload_pypi,
+ upload_source=upload_source,
+ )
+ console = Console()
+ dist_dir = dist_dir.resolve()
+
+ if not dist_dir.exists():
+ raise ValueError(
+ f"{dist_dir} does not exist. Run `gradio cc build` to create a wheel and source distribution."
+ )
+ if not dist_dir.is_dir():
+ raise ValueError(f"{dist_dir} is not a directory")
+ distribution_files = [
+ p.resolve() for p in Path(dist_dir).glob("*") if p.suffix in {".whl", ".gz"}
+ ]
+
+ def _get_wheel_version(path: Path):
+ version_str = str(path.name).split("-")[1]
+ parsed = _parse_version(version_str)
+ if parsed is None:
+ raise ValueError(f"Could not parse version {version_str} from {path.name}")
+ return parsed
+
+ wheel_file = max(
+ (p for p in distribution_files if p.suffix == ".whl"),
+ key=_get_wheel_version,
+ )
+ if not wheel_file:
+ raise ValueError(
+ "A wheel file was not found in the distribution directory. "
+ "Run `gradio cc build` to create a wheel file."
+ )
+ config_file = None
+ if upload_pypi and (not pypi_username or not pypi_password):
+ panel = Panel(
+ "It is recommended to upload your component to pypi so that [bold][magenta]anyone[/][/] "
+ "can install it with [bold][magenta]pip install[/][/].\n\n"
+ f"A PyPi account is needed. If you do not have an account, register account here: [blue]{PYPI_REGISTER_URL}[/]",
+ )
+ print(panel)
+ upload_pypi = Confirm.ask(":snake: Upload to pypi?")
+ if upload_pypi and (Path.home() / ".pypirc").exists():
+ print(":closed_lock_with_key: Found .pypirc file in home directory.")
+ config_file = str(Path.home() / ".pypirc")
+ elif upload_pypi:
+ print(
+ ":light_bulb: If you have Two Factor Authentication enabled, the username is __token__ and your password is your API key."
+ )
+ pypi_username = Prompt.ask(":laptop_computer: Enter your pypi username")
+ pypi_password = Prompt.ask(
+ ":closed_lock_with_key: Enter your pypi password", password=True
+ )
+ if upload_pypi:
+ try:
+ from twine.commands.upload import upload as twine_upload # type: ignore
+ from twine.exceptions import InvalidDistribution # type: ignore
+ from twine.settings import Settings # type: ignore
+ except (ImportError, ModuleNotFoundError) as e:
+ raise ValueError(
+ "The twine library must be installed to publish to pypi."
+ "Install it with pip, pip install twine."
+ ) from e
+ if pypi_username and pypi_password:
+ twine_settings = Settings(username=pypi_username, password=pypi_password)
+ elif config_file:
+ twine_settings = Settings(config_file=config_file)
+ else:
+ raise ValueError(
+ "No pypi username or password provided and no ~/.pypirc file found."
+ )
+ try:
+ # do our best to only upload the latest versions
+ max_version = _get_max_version(distribution_files)
+ twine_files = [
+ str(p)
+ for p in distribution_files
+ if (not max_version or max_version in p.name)
+ ]
+ print(f"Uploading files: {','.join(twine_files)}")
+ try:
+ twine_upload(twine_settings, twine_files)
+ except InvalidDistribution as e:
+ raise ValueError(
+ "Invalid distribution when uploading to pypi. "
+ "Try upgrading 'pkginfo' with python -m pip install pkginfo --upgrade"
+ ) from e
+ except Exception:
+ console.print_exception()
+ if upload_demo and not demo_dir:
+ panel = Panel(
+ "It is recommended you upload a demo of your component to [blue]https://huggingface.co/spaces[/] "
+ "so that anyone can try it from their browser."
+ )
+ print(panel)
+ upload_demo = Confirm.ask(":hugging_face: Upload demo?")
+ if upload_demo:
+ panel = Panel(
+ "Please provide the path to the [magenta]demo directory[/] for your custom component.\n\n"
+ "This directory should contain [magenta]all the files[/] it needs to run successfully.\n\n"
+ "Please make sure the gradio app is in an [magenta]space.py[/] file.\n\n"
+ "If you need additional python requirements, add a [magenta]requirements.txt[/] file to this directory."
+ )
+ print(panel)
+ demo_dir_ = Prompt.ask(
+ f":roller_coaster: Please enter the path to the demo directory. Leave blank to use: {(Path('.') / 'demo')}"
+ )
+ demo_dir_ = demo_dir_ or str(Path(".") / "demo")
+ demo_dir = Path(demo_dir_).resolve()
+
+ if upload_demo and not upload_source:
+ panel = Panel(
+ "It is recommended that you share your [magenta]source code[/] so that others can learn from and improve your component."
+ )
+ print(panel)
+ upload_source = Confirm.ask(":books: Would you like to share your source code?")
+ if upload_source:
+ source_dir_ = (
+ Prompt.ask(
+ f":file_folder: Please enter the path to the source directory. Leave blank to use: {source_dir}"
+ )
+ or source_dir
+ )
+ source_dir = Path(source_dir_).resolve()
+
+ if upload_demo:
+ pyproject_toml_path = source_dir / "pyproject.toml"
+
+ try:
+ pyproject_toml = parse(pyproject_toml_path.read_text())
+ package_name = pyproject_toml["project"]["name"] # type: ignore
+ except Exception:
+ (package_name, _) = wheel_file.name.split("-")[:2]
+
+ if not demo_dir:
+ raise ValueError("demo_dir must be set")
+
+ package_name, _ = wheel_file.name.split("-")[:2]
+ with tempfile.TemporaryDirectory() as tempdir:
+ shutil.copytree(
+ str(demo_dir),
+ str(tempdir),
+ dirs_exist_ok=True,
+ )
+ shutil.copyfile(
+ str(source_dir / ".gitignore"),
+ str(Path(tempdir) / ".gitignore"),
+ )
+ if upload_source:
+ shutil.copytree(
+ str(source_dir),
+ str(Path(tempdir) / "src"),
+ dirs_exist_ok=True,
+ ignore=_ignore,
+ )
+
+ shutil.copyfile(
+ str(source_dir / "README.md"), str(Path(tempdir) / "README.md")
+ )
+
+ api = HfApi(token=token)
+ repo_url = api.create_repo(
+ repo_id=repo_id or package_name,
+ repo_type="space",
+ exist_ok=True,
+ space_sdk="gradio",
+ )
+ repo_id = repo_url.repo_id
+ api.upload_folder(
+ repo_id=repo_id,
+ folder_path=tempdir,
+ repo_type="space",
+ )
+ if prefer_local:
+ api.upload_file(
+ repo_id=repo_id,
+ path_or_fileobj=str(wheel_file),
+ path_in_repo=wheel_file.name,
+ repo_type="space",
+ )
+ print("\n")
+ # Do a factory reboot so that the new dependencies get installed
+ api.restart_space(repo_id=repo_id, factory_reboot=True, token=token)
+ print(f"Demo uploaded to https://huggingface.co/spaces/{repo_id} !")
+
+
+def resolve_demo(demo_dir: Path) -> Path:
+ _demo_dir = demo_dir.resolve()
+ if (_demo_dir / "space.py").exists():
+ return _demo_dir / "space.py"
+ elif (_demo_dir / "app.py").exists():
+ return _demo_dir / "app.py"
+ else:
+ raise FileNotFoundError(
+ f'Could not find "space.py" or "app.py" in "{demo_dir}".'
+ )
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/components/show.py b/lib/python3.11/site-packages/gradio/cli/commands/components/show.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ab8bcfd7421efe5438f3bdd57eef2636bc77dff
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/components/show.py
@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import inspect
+
+from rich.console import Console
+from rich.table import Table
+
+import gradio._simple_templates
+import gradio.components
+import gradio.layouts
+from gradio.analytics import custom_component_analytics
+from gradio.blocks import BlockContext
+from gradio.components import Component, FormComponent
+
+_IGNORE = {
+ "Text",
+ "Dataframe",
+ "Highlightedtext",
+ "Annotatedimage",
+ "Checkboxgroup",
+ "Json",
+ "Highlight",
+ "Component",
+ "Form",
+ "Dataset",
+ "FormComponent",
+ "Fallback",
+ "State",
+ "LogoutButton",
+}
+
+_BEGINNER_FRIENDLY = {"Slider", "Radio", "Checkbox", "Number", "CheckboxGroup", "File"}
+
+
+def _get_table_items(module):
+ items = []
+ for name in module.__all__:
+ if name in _IGNORE:
+ continue
+ gr_cls = getattr(module, name)
+ if not (
+ inspect.isclass(gr_cls) and issubclass(gr_cls, (Component, BlockContext))
+ ):
+ continue
+ tags = []
+ if "Simple" in name or name in _BEGINNER_FRIENDLY:
+ tags.append(":seedling::handshake:Beginner Friendly:seedling::handshake:")
+ if issubclass(gr_cls, FormComponent):
+ tags.append(":pencil::jigsaw:Form Component:pencil::jigsaw:")
+ if name in gradio.layouts.__all__:
+ tags.append(":triangular_ruler:Layout:triangular_ruler:")
+ doc = inspect.getdoc(gr_cls) or "No description available."
+ doc = doc.split(".")[0]
+ if tags:
+ doc = f"[{', '.join(tags)}]" + " " + doc
+ items.append((name, doc))
+
+ return items
+
+
+def _show():
+ custom_component_analytics(
+ "show",
+ None,
+ upload_demo=None,
+ upload_pypi=None,
+ upload_source=None,
+ )
+ items = (
+ _get_table_items(gradio._simple_templates)
+ + _get_table_items(gradio.components)
+ + _get_table_items(gradio.layouts)
+ )
+ table = Table(show_header=True, header_style="orange1", show_lines=True)
+ table.add_column("Name", justify="center")
+ table.add_column("Description", justify="center")
+
+ for item in items:
+ table.add_row(*item)
+
+ console = Console()
+ with console.pager():
+ console.print(table)
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/deploy_space.py b/lib/python3.11/site-packages/gradio/cli/commands/deploy_space.py
new file mode 100644
index 0000000000000000000000000000000000000000..d67de2eb07117f1d47c2e52711d241add6a9171b
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/deploy_space.py
@@ -0,0 +1,321 @@
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+from typing import Annotated
+
+import huggingface_hub
+from rich import print
+from typer import Option
+
+import gradio as gr
+
+repo_directory = os.getcwd()
+readme_file = os.path.join(repo_directory, "README.md")
+github_action_template = os.path.join(
+ os.path.dirname(__file__), "deploy_space_action.yaml"
+)
+
+
+def add_configuration_to_readme(
+ title: str | None,
+ app_file: str | None,
+) -> dict:
+ configuration = {}
+
+ dir_name = os.path.basename(repo_directory)
+ if title is None:
+ title = input(f"Enter Spaces app title [{dir_name}]: ") or dir_name
+ formatted_title = format_title(title)
+ if formatted_title != title:
+ print(f"Formatted to {formatted_title}. ")
+ configuration["title"] = formatted_title
+
+ if app_file is None:
+ for file in os.listdir(repo_directory):
+ file_path = os.path.join(repo_directory, file)
+ if not os.path.isfile(file_path) or not file.endswith(".py"):
+ continue
+
+ with open(file_path, encoding="utf-8", errors="ignore") as f:
+ content = f.read()
+ if "import gradio" in content:
+ app_file = file
+ break
+
+ app_file = (
+ input(f"Enter Gradio app file {f'[{app_file}]' if app_file else ''}: ")
+ or app_file
+ )
+ if not app_file or not os.path.exists(app_file):
+ raise FileNotFoundError("Failed to find Gradio app file.")
+ configuration["app_file"] = app_file
+
+ configuration["sdk"] = "gradio"
+ configuration["sdk_version"] = gr.__version__
+ huggingface_hub.metadata_save(readme_file, configuration)
+
+ configuration["hardware"] = (
+ input(
+ f"Enter Spaces hardware ({', '.join(hardware.value for hardware in huggingface_hub.SpaceHardware)}) [cpu-basic]: "
+ )
+ or "cpu-basic"
+ )
+
+ secrets = {}
+ if input("Any Spaces secrets (y/n) [n]: ") == "y":
+ while True:
+ secret_name = input("Enter secret name (leave blank to end): ")
+ if not secret_name:
+ break
+ secret_value = input(f"Enter secret value for {secret_name}: ")
+ secrets[secret_name] = secret_value
+ configuration["secrets"] = secrets
+
+ requirements_file = os.path.join(repo_directory, "requirements.txt")
+ if (
+ not os.path.exists(requirements_file)
+ and input("Create requirements.txt file? (y/n) [n]: ").lower() == "y"
+ ):
+ while True:
+ requirement = input("Enter a dependency (leave blank to end): ")
+ if not requirement:
+ break
+ with open(requirements_file, "a", encoding="utf-8") as f:
+ f.write(requirement + "\n")
+
+ if (
+ input(
+ "Create Github Action to automatically update Space on 'git push'? [n]: "
+ ).lower()
+ == "y"
+ ):
+ track_branch = input("Enter branch to track [main]: ") or "main"
+ github_action_file = os.path.join(
+ repo_directory, ".github/workflows/update_space.yml"
+ )
+ os.makedirs(os.path.dirname(github_action_file), exist_ok=True)
+ with open(github_action_template, encoding="utf-8") as f:
+ github_action_content = f.read()
+ github_action_content = github_action_content.replace("$branch", track_branch)
+ with open(github_action_file, "w", encoding="utf-8") as f:
+ f.write(github_action_content)
+
+ print(
+ "Github Action created. Add your Hugging Face write token (from https://huggingface.co/settings/tokens) as an Actions Secret named 'hf_token' to your GitHub repository. This can be set in your repository's settings page."
+ )
+
+ return configuration
+
+
+def format_title(title: str):
+ title = title.replace(" ", "_")
+ title = re.sub(r"[^a-zA-Z0-9\-._]", "", title)
+ title = re.sub("-+", "-", title)
+ while title.startswith("."):
+ title = title[1:]
+ return title
+
+
+def check_gcloud_auth():
+ """Check if user is logged in to Google Cloud and has a project selected."""
+ try:
+ auth_result = subprocess.run(
+ ["gcloud", "auth", "list", "--filter=status:ACTIVE"],
+ check=True,
+ text=True,
+ capture_output=True,
+ )
+
+ if not auth_result.stdout.strip():
+ print("[bold yellow]You are not logged in to Google Cloud.[/bold yellow]")
+ print("Running 'gcloud init' to set up authentication...")
+ subprocess.run(["gcloud", "init"], check=True)
+
+ project_result = subprocess.run(
+ ["gcloud", "config", "get-value", "project"],
+ check=True,
+ text=True,
+ capture_output=True,
+ )
+
+ if not project_result.stdout.strip():
+ print("[bold yellow]No Google Cloud project is selected.[/bold yellow]")
+ project_id = input("Enter your Google Cloud project ID: ")
+ if not project_id:
+ print("[red]Project ID is required for deployment.[/red]")
+ return None
+ return project_id
+
+ print(f"[green]✓ Authenticated as: {auth_result.stdout.strip()}[/green]")
+ print(f"[green]✓ Project: {project_result.stdout.strip()}[/green]")
+ return project_result.stdout.strip()
+
+ except subprocess.CalledProcessError as e:
+ print(f"[bold red]Error checking Google Cloud configuration: {e}[/bold red]")
+ print("Running 'gcloud init' to set up configuration...")
+ try:
+ subprocess.run(["gcloud", "init"], check=True)
+ except subprocess.CalledProcessError as init_error:
+ print(f"[red]Failed to run 'gcloud init': {init_error}[/red]")
+ return False
+ except FileNotFoundError:
+ print(
+ "[bold red]gcloud CLI not found. Please install Google Cloud SDK.[/bold red]"
+ )
+ return False
+
+ return True
+
+
+def deploy_to_gcloud():
+ """Deploy a Gradio app to Google Cloud Run. Always uses app.py as the entry point."""
+ if not shutil.which("gcloud"):
+ print(
+ "[bold red]gcloud CLI is not installed.[/bold red]\n"
+ "Please install the Google Cloud SDK from: "
+ "[link]https://cloud.google.com/sdk/docs/install[/link]"
+ )
+ return
+
+ project_id = check_gcloud_auth()
+ if not project_id:
+ print(
+ "[bold red]Google Cloud configuration failed. Please run 'gcloud init' manually.[/bold red]"
+ )
+ return
+
+ if not os.path.exists("app.py") and not os.path.exists("main.py"):
+ print(
+ "[bold red]Error:[/bold red] app.py and main.py not found. Google Cloud Run deployment requires app.py or main.py as the entry point."
+ )
+ return
+
+ requirements_file = "requirements.txt"
+ if not os.path.exists(requirements_file):
+ if (
+ input(
+ f"A requirements.txt file is necessary for Google Cloud Run deployment. Create requirements.txt with gradio=={gr.__version__}? (y/n) [y]: "
+ ).lower()
+ != "n"
+ ):
+ with open(requirements_file, "w", encoding="utf-8") as f:
+ f.write(f"gradio=={gr.__version__}\n")
+ print(f"Created requirements.txt with gradio=={gr.__version__}")
+ else:
+ print("\n[yellow]Deployment cancelled.[/yellow]")
+ return
+ else:
+ with open(requirements_file, encoding="utf-8") as f:
+ requirements_content = f.read()
+
+ if "gradio" not in requirements_content and (
+ input(
+ f"Add gradio=={gr.__version__} to requirements.txt? (y/n) [y]: "
+ ).lower()
+ != "n"
+ ):
+ with open(requirements_file, "a", encoding="utf-8") as f:
+ f.write(f"gradio=={gr.__version__}\n")
+ print(f"Added gradio=={gr.__version__} to requirements.txt")
+
+ print("[bold]Deploying to Google Cloud Run...[/bold]")
+
+ try:
+ deploy_command = [
+ "gcloud",
+ "run",
+ "deploy",
+ "--source=.",
+ "--labels=created-by=gradio",
+ ]
+ if project_id:
+ deploy_command.extend(["--project", project_id])
+
+ subprocess.run(
+ deploy_command,
+ check=True,
+ text=True,
+ capture_output=False,
+ )
+ print("[green]✓ Deployment complete![/green]")
+ except subprocess.CalledProcessError as e:
+ print(f"[red]Deployment failed: {e}[/red]")
+ return
+ except KeyboardInterrupt:
+ print("\n[yellow]Deployment cancelled.[/yellow]")
+ return
+
+
+def deploy(
+ title: Annotated[str | None, Option(help="Spaces app title")] = None,
+ app_file: Annotated[
+ str | None, Option(help="File containing the Gradio app")
+ ] = None,
+ provider: Annotated[
+ str | None, Option(help="Deployment provider (spaces or gcloud)")
+ ] = "spaces",
+):
+ if provider == "gcloud":
+ if app_file and app_file != "app.py":
+ print(
+ "[yellow]Warning:[/yellow] --app-file is ignored for Google Cloud Run deployment. Using app.py as entry point."
+ )
+ deploy_to_gcloud()
+ return
+
+ if provider != "spaces":
+ print(f"[red]Unknown provider: {provider}. Use 'spaces' or 'gcloud'.[/red]")
+ return
+
+ if os.getenv("SYSTEM") == "spaces":
+ return
+
+ hf_api = huggingface_hub.HfApi()
+ whoami = None
+ login = False
+ try:
+ whoami = hf_api.whoami()
+ if whoami["auth"]["accessToken"]["role"] != "write":
+ login = True
+ except OSError:
+ login = True
+ if login:
+ print("Need 'write' access token to create a Spaces repo.")
+ huggingface_hub.login(add_to_git_credential=False)
+ whoami = hf_api.whoami()
+
+ configuration: None | dict = None
+ if os.path.exists(readme_file):
+ try:
+ configuration = huggingface_hub.metadata_load(readme_file)
+ except ValueError:
+ pass
+
+ if configuration is None:
+ print(
+ f"Creating new Spaces Repo in '{repo_directory}'. Collecting metadata, press Enter to accept default value."
+ )
+ configuration = add_configuration_to_readme(
+ title,
+ app_file,
+ )
+
+ space_id = hf_api.create_repo(
+ configuration["title"],
+ space_sdk="gradio",
+ repo_type="space",
+ exist_ok=True,
+ space_hardware=configuration.get("hardware"),
+ ).repo_id
+ hf_api.upload_folder(
+ repo_id=space_id,
+ repo_type="space",
+ folder_path=repo_directory,
+ )
+ if configuration.get("secrets"):
+ for secret_name, secret_value in configuration["secrets"].items():
+ hf_api.add_space_secret(space_id, secret_name, secret_value)
+ print(f"Space available at https://huggingface.co/spaces/{space_id}")
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/deploy_space_action.yaml b/lib/python3.11/site-packages/gradio/cli/commands/deploy_space_action.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..74f4cbdbde13728e57729531ca5de692b8521b69
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/deploy_space_action.yaml
@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+ push:
+ branches:
+ - $branch
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v2
+
+ - name: Set up Python
+ uses: actions/setup-python@v2
+ with:
+ python-version: '3.9'
+
+ - name: Install Gradio
+ run: python -m pip install gradio
+
+ - name: Log in to Hugging Face
+ run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+ - name: Deploy to Spaces
+ run: gradio deploy
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/display.py b/lib/python3.11/site-packages/gradio/cli/commands/display.py
new file mode 100644
index 0000000000000000000000000000000000000000..a031ce8233a863198971264b23fbc2c6a812922f
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/display.py
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import time
+from types import TracebackType
+
+from rich.live import Live
+from rich.panel import Panel
+
+
+class LivePanelDisplay:
+ def __init__(self, msg: str | None = None) -> None:
+ self.lines = [msg] if msg else []
+ self._panel = Live(Panel("\n".join(self.lines)), refresh_per_second=5)
+
+ def update(self, msg: str, add_sleep: float | None = None):
+ self.lines.append(msg)
+ self._panel.update(Panel("\n".join(self.lines)))
+ if add_sleep:
+ time.sleep(add_sleep)
+
+ def __enter__(self) -> LivePanelDisplay:
+ self._panel.__enter__()
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc_val: BaseException | None,
+ exc_tb: TracebackType | None,
+ ) -> None:
+ self._panel.stop()
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/hf_login.py b/lib/python3.11/site-packages/gradio/cli/commands/hf_login.py
new file mode 100644
index 0000000000000000000000000000000000000000..be541c62796dea8306a9aa254cd1c206e8a980a3
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/hf_login.py
@@ -0,0 +1,46 @@
+import os
+
+from huggingface_hub import interpreter_login, whoami
+
+
+def save_login():
+ try:
+ while True:
+ response = input("Stay logged in to Hugging Face? (Y/n): ").strip().lower()
+ if response in ["y", "yes", ""]: # Empty string for just pressing Enter
+ os.environ["GRADIO_AUTO_LOGOUT"] = "false"
+ print("You can logout at any time with: hf auth logout")
+ break
+ elif response in ["n", "no"]:
+ os.environ["GRADIO_AUTO_LOGOUT"] = "true"
+ break
+ else:
+ print("Please answer with 'y' or 'n'")
+ except (EOFError, KeyboardInterrupt):
+ os.environ["GRADIO_AUTO_LOGOUT"] = "true"
+
+
+def hf_login():
+ if os.getenv("HF_TOKEN"):
+ try:
+ user = whoami(token=os.getenv("HF_TOKEN")).get("name")
+ print(
+ f"🔓 Logged in to Hugging Face as {user}. You can logout at any time with: unset HF_TOKEN\n"
+ )
+ except Exception:
+ print("❌ Error logging in to Hugging Face with $HF_TOKEN")
+ print("Logging in with CLI prompt...\n")
+ interpreter_login()
+ save_login()
+ else:
+ try:
+ user = whoami().get("name")
+ print(
+ f"🔓 Logged in to Hugging Face as {user}. You can logout at any time with: hf auth logout\n"
+ )
+ except Exception:
+ print(
+ "🔑 No Hugging Face login found, launching login prompt... \n\nPlease use a token with permission to make calls to Inference Providers \n"
+ )
+ interpreter_login()
+ save_login()
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/load.py b/lib/python3.11/site-packages/gradio/cli/commands/load.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e754d477a8eae1b3001afe39bbdabbf2e4d9855
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/load.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import typer
+
+from .load_chat import main as chat
+
+load_app = typer.Typer(help="Load various types of interfaces and models")
+
+load_app.command("chat", help="Launch a chat interface using OpenAI-compatible API")(
+ chat
+)
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/load_chat.py b/lib/python3.11/site-packages/gradio/cli/commands/load_chat.py
new file mode 100644
index 0000000000000000000000000000000000000000..ded1c9a350707ebddd749aac0a6e509c048b04c8
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/load_chat.py
@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import os
+
+import typer
+
+from gradio.external import load_chat as load_chat_external
+
+
+def main(
+ base_url: str = typer.Argument(
+ ..., help="OpenAI-compatible base URL, e.g. http://localhost:11434/v1/"
+ ),
+ model: str = typer.Argument(..., help="Model name, e.g. llama3.2"),
+ token: str | None = typer.Option(
+ None,
+ "--token",
+ "-t",
+ help="API key (defaults to $OPENAI_API_KEY if not provided)",
+ ),
+ file_types: list[str] = typer.Option(
+ ["text_encoded"],
+ "--file-types",
+ help="Repeatable option. Allowed values: text_encoded, image",
+ ),
+ system_message: str | None = typer.Option(
+ None, "--system-message", help="Optional system prompt"
+ ),
+ stream: bool = typer.Option(
+ True, "--stream/--no-stream", help="Enable or disable streaming"
+ ),
+ host: str | None = typer.Option(
+ None, "--host", help="Server host (maps to launch.server_name)"
+ ),
+ port: int = typer.Option(
+ 7860, "--port", help="Server port (maps to launch.server_port)"
+ ),
+ share: bool = typer.Option(
+ False, "--share/--no-share", help="Create a public share link"
+ ),
+) -> None:
+ """Launch a chat interface using OpenAI-compatible API."""
+ resolved_token = token or os.getenv("OPENAI_API_KEY")
+
+ for ft in file_types:
+ if ft not in {"text_encoded", "image"}:
+ raise typer.BadParameter("file_types must be one of: text_encoded, image")
+
+ demo = load_chat_external(
+ base_url=base_url,
+ model=model,
+ token=resolved_token,
+ file_types=file_types,
+ system_message=system_message,
+ streaming=stream,
+ )
+
+ demo.launch(server_name=host, server_port=port, share=share)
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/reload.py b/lib/python3.11/site-packages/gradio/cli/commands/reload.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d76b3df3d7faf45ab40f390a6faa3a07858916b
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/reload.py
@@ -0,0 +1,147 @@
+"""
+
+Contains the functions that run when `gradio` is called from the command line. Specifically, allows
+
+$ gradio app.py, to run app.py in reload mode where any changes in the app.py file or Gradio library reloads the demo.
+$ gradio app.py my_demo, to use variable names other than "demo"
+"""
+
+from __future__ import annotations
+
+import inspect
+import os
+import signal
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+import typer
+from rich import print
+
+import gradio
+from gradio import utils
+
+reload_thread = threading.local()
+
+
+def _handle_interrupt():
+ """Handle interrupt signals and logout based on user preference"""
+
+ if os.getenv("GRADIO_VIBE_MODE") and os.getenv("GRADIO_AUTO_LOGOUT") == "true":
+ try:
+ from huggingface_hub import logout
+
+ logout()
+ print("\n\nLogged out of Hugging Face")
+ except Exception as e:
+ print(f"\n\nError logging out of Hugging Face: {e}")
+
+ sys.exit(0)
+
+
+def _setup_config(
+ demo_path: Path,
+ additional_watch_dirs: list[str] | None = None,
+ watch_library: bool = False,
+):
+ original_path = Path(demo_path)
+ abs_original_path = utils.abspath(original_path)
+
+ if original_path.is_absolute():
+ relpath = original_path.relative_to(Path.cwd())
+ else:
+ relpath = original_path
+ module_name = str(relpath.parent / relpath.stem).replace(os.path.sep, ".")
+
+ gradio_folder = Path(inspect.getfile(gradio)).parent
+
+ message = "Watching:"
+ message_change_count = 0
+
+ watching_dirs = []
+ if str(gradio_folder).strip() and watch_library:
+ # This is a source install
+ watching_dirs.append(gradio_folder)
+ message += f" '{gradio_folder}'"
+ message_change_count += 1
+
+ abs_parent = abs_original_path.parent
+ if str(abs_parent).strip():
+ watching_dirs.append(abs_parent)
+ if message_change_count == 1:
+ message += ","
+ message += f" '{abs_parent}'"
+
+ abs_current = Path.cwd().absolute()
+ if str(abs_current).strip() and abs_current not in watching_dirs:
+ try:
+ gradio_folder.relative_to(abs_current)
+ is_subdir = True
+ except ValueError:
+ is_subdir = False
+ if is_subdir and not watch_library:
+ pass
+ else:
+ watching_dirs.append(abs_current)
+ if message_change_count == 1:
+ message += ","
+ message += f" '{abs_current}'"
+
+ for wd in additional_watch_dirs or []:
+ if Path(wd) not in watching_dirs:
+ watching_dirs.append(wd)
+
+ if message_change_count == 1:
+ message += ","
+ message += f" '{wd}'"
+
+ print(message + "\n")
+
+ # guarantee access to the module of an app
+ sys.path.insert(0, os.getcwd())
+ return module_name, abs_original_path, [str(s) for s in watching_dirs]
+
+
+def main(
+ demo_path: Path,
+ demo_name: str = "",
+ watch_dirs: list[str] | None = None,
+ encoding: str = "utf-8",
+ watch_library: bool = False,
+):
+ signal.signal(signal.SIGINT, lambda _signum, _frame: _handle_interrupt())
+ signal.signal(signal.SIGTERM, lambda _signum, _frame: _handle_interrupt())
+
+ # default execution pattern to start the server and watch changes
+ module_name, path, watch_sources = _setup_config(
+ demo_path, watch_dirs, watch_library
+ )
+
+ # Pass the following data as environment variables
+ # so that we can set up reload mode correctly in the networking.py module
+ env_vars = dict(
+ os.environ,
+ GRADIO_WATCH_DIRS=",".join(watch_sources),
+ GRADIO_WATCH_MODULE_NAME=module_name,
+ GRADIO_WATCH_DEMO_NAME=demo_name,
+ GRADIO_WATCH_DEMO_PATH=str(path),
+ GRADIO_WATCH_ENCODING=encoding,
+ )
+
+ if "GRADIO_VIBE_MODE" in os.environ:
+ env_vars["GRADIO_VIBE_MODE"] = os.environ["GRADIO_VIBE_MODE"]
+
+ popen = subprocess.Popen(
+ [sys.executable, "-u", path],
+ env=env_vars,
+ )
+ if popen.poll() is None:
+ try:
+ popen.wait()
+ except (KeyboardInterrupt, OSError):
+ pass
+
+
+if __name__ == "__main__":
+ typer.run(main)
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/sketch.py b/lib/python3.11/site-packages/gradio/cli/commands/sketch.py
new file mode 100644
index 0000000000000000000000000000000000000000..38f6ea47aa74071bfc7b1ffad6d9bbb28d137cf7
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/sketch.py
@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+
+def launch(
+ app_file: str = "app.py", # noqa: ARG001
+):
+ raise DeprecationWarning(
+ "The 'gradio sketch' command has been deprecated and removed in Gradio 6. "
+ "Consider using 'gradio --vibe' instead. "
+ )
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/skills.py b/lib/python3.11/site-packages/gradio/cli/commands/skills.py
new file mode 100644
index 0000000000000000000000000000000000000000..076cd7c4e727e550d845b1cbad30373f9d5959a6
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/skills.py
@@ -0,0 +1,413 @@
+"""CLI command to install the Gradio skill for AI coding assistants.
+
+Usage:
+ gradio skills add --cursor
+ gradio skills add --cursor --opencode
+ gradio skills add --cursor --global
+ gradio skills add --dest=~/my-skills
+ gradio skills add abidlabs/english-translator --cursor
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+from typing import Annotated, cast
+
+import typer
+from gradio_client import Client
+from gradio_client.snippet import generate_code_snippets
+from huggingface_hub import HfApi
+
+SKILL_ID = "gradio"
+HF_SKILL_ID = "hf-gradio"
+
+_GITHUB_RAW = "https://raw.githubusercontent.com/gradio-app/gradio/main"
+_SKILL_PREFIX = ".agents/skills/gradio"
+_HF_SKILL_PREFIX = ".agents/skills/hf-gradio"
+
+_SKILL_FILES = ["SKILL.md"]
+_REFERENCE_FILES = ["examples.md", "api-signatures.md", "event-listeners.md"]
+
+_HF_SKILL_FILES = ["SKILL.md"]
+
+skills_app = typer.Typer(help="Manage Gradio skills for AI assistants.")
+
+
+def _get_skill_targets():
+ central_local = Path(".agents/skills")
+ central_global = Path("~/.agents/skills")
+ claude_local = Path(".claude/skills")
+ claude_global = Path("~/.claude/skills")
+ global_targets = {
+ "claude": claude_global,
+ "codex": Path("~/.codex/skills"),
+ "opencode": Path("~/.opencode/skills"),
+ }
+ local_targets = {
+ "claude": claude_local,
+ "codex": Path(".codex/skills"),
+ "opencode": Path(".opencode/skills"),
+ }
+ return central_global, central_local, global_targets, local_targets
+
+
+def _download(url: str) -> str:
+ from huggingface_hub.utils import get_session
+
+ try:
+ response = get_session().get(url)
+ response.raise_for_status()
+ except Exception as e:
+ raise SystemExit(
+ f"Failed to download {url}\n{e}\n\n"
+ "Make sure you have internet access. The skill files are fetched from "
+ "the Gradio GitHub repository."
+ ) from e
+ return response.text
+
+
+def _remove_existing(path: Path, force: bool) -> None:
+ if not (path.exists() or path.is_symlink()):
+ return
+ if not force:
+ raise SystemExit(
+ f"Skill already exists at {path}.\nRe-run with --force to overwrite."
+ )
+ if path.is_dir() and not path.is_symlink():
+ shutil.rmtree(path)
+ else:
+ path.unlink()
+
+
+def _create_symlink(
+ agent_skills_dir: Path,
+ central_skill_path: Path,
+ force: bool,
+ skill_id: str = SKILL_ID,
+) -> Path:
+ agent_skills_dir = agent_skills_dir.expanduser().resolve()
+ agent_skills_dir.mkdir(parents=True, exist_ok=True)
+ link_path = agent_skills_dir / skill_id
+ _remove_existing(link_path, force)
+ link_path.symlink_to(os.path.relpath(central_skill_path, agent_skills_dir))
+ return link_path
+
+
+def _install_to(skills_dir: Path, force: bool) -> Path:
+ """Install the gradio skill (for building apps)."""
+ skills_dir = skills_dir.expanduser().resolve()
+ skills_dir.mkdir(parents=True, exist_ok=True)
+ dest = skills_dir / SKILL_ID
+
+ _remove_existing(dest, force)
+ dest.mkdir()
+
+ # Download main skill files
+ for fname in _SKILL_FILES:
+ content = _download(f"{_GITHUB_RAW}/{_SKILL_PREFIX}/{fname}")
+ (dest / fname).write_text(content, encoding="utf-8")
+
+ # Download reference files to references/ subdirectory
+ references_dir = dest / "references"
+ references_dir.mkdir(exist_ok=True)
+ for fname in _REFERENCE_FILES:
+ content = _download(f"{_GITHUB_RAW}/{_SKILL_PREFIX}/references/{fname}")
+ (references_dir / fname).write_text(content, encoding="utf-8")
+
+ return dest
+
+
+def _install_hf_gradio_to(skills_dir: Path, force: bool) -> Path:
+ """Install the hf-gradio skill (for using Spaces via API)."""
+ skills_dir = skills_dir.expanduser().resolve()
+ skills_dir.mkdir(parents=True, exist_ok=True)
+ dest = skills_dir / HF_SKILL_ID
+
+ _remove_existing(dest, force)
+ dest.mkdir()
+
+ # Download main skill files
+ for fname in _HF_SKILL_FILES:
+ content = _download(f"{_GITHUB_RAW}/{_HF_SKILL_PREFIX}/{fname}")
+ (dest / fname).write_text(content, encoding="utf-8")
+
+ return dest
+
+
+def _space_id_to_skill_id(space_id: str) -> str:
+ return space_id.replace("/", "-")
+
+
+def _render_endpoint_section(
+ api_name: str, endpoint_info: dict, space_id: str, src_url: str
+) -> str:
+ params = endpoint_info.get("parameters", [])
+ returns = endpoint_info.get("returns", [])
+
+ lines: list[str] = []
+ lines.append(f"### `{api_name}`\n")
+
+ if params:
+ lines.append("**Parameters:**\n")
+ for p in params:
+ ptype = p.get("python_type", {})
+ type_str = (
+ ptype.get("type", "Any") if isinstance(ptype, dict) else str(ptype)
+ )
+ name = p.get("parameter_name") or p.get("label", "input")
+ component = p.get("component", "")
+ default_info = ""
+ if p.get("parameter_has_default"):
+ default_info = f", default: `{p.get('parameter_default')}`"
+ required = (
+ " (required)" if not p.get("parameter_has_default", False) else ""
+ )
+ lines.append(
+ f"- `{name}` [{component}]: `{type_str}`{required}{default_info}"
+ )
+ lines.append("")
+
+ if returns:
+ lines.append("**Returns:**\n")
+ for r in returns:
+ rtype = r.get("python_type", {})
+ type_str = (
+ rtype.get("type", "Any") if isinstance(rtype, dict) else str(rtype)
+ )
+ label = r.get("label", "output")
+ component = r.get("component", "")
+ lines.append(f"- `{label}` [{component}]: `{type_str}`")
+ lines.append("")
+
+ snippets = generate_code_snippets(
+ api_name, endpoint_info, src_url, space_id=space_id
+ )
+
+ lines.append("**Python:**\n")
+ lines.append("```python")
+ lines.append(snippets["python"])
+ lines.append("```\n")
+
+ lines.append("**JavaScript:**\n")
+ lines.append("```javascript")
+ lines.append(snippets["javascript"])
+ lines.append("```\n")
+
+ lines.append("**cURL:**\n")
+ lines.append("```bash")
+ lines.append(snippets["bash"])
+ lines.append("```\n")
+
+ return "\n".join(lines)
+
+
+def _get_space_description(space_id: str) -> str | None:
+ try:
+ info = HfApi().space_info(space_id)
+ return getattr(info, "short_description", None) or None
+ except Exception:
+ return None
+
+
+def _generate_space_skill(space_id: str) -> tuple[str, str]:
+ try:
+ client = Client(space_id, download_files=False)
+ except Exception as e:
+ raise SystemExit(
+ f"Failed to connect to Space '{space_id}'.\n{e}\n\n"
+ "Make sure the Space exists, is public (or provide HF_TOKEN), and is running."
+ ) from e
+
+ api_info = cast(dict, client.view_api(print_info=False, return_format="dict"))
+ src_url = client.src
+
+ skill_id = _space_id_to_skill_id(space_id)
+
+ space_description = _get_space_description(space_id)
+
+ lines: list[str] = []
+ lines.append("---")
+ lines.append(f"name: {skill_id}")
+ desc = (
+ f"description: Use the {space_id} Gradio Space via API. "
+ f"Provides Python, JavaScript, and cURL usage examples."
+ )
+ if space_description:
+ desc += f" Space description: {space_description}"
+ lines.append(desc)
+ lines.append("---\n")
+ lines.append(f"# {space_id}\n")
+ lines.append(
+ f"This skill describes how to use the {space_id} "
+ f"Gradio Space programmatically.\n"
+ )
+
+ named = api_info.get("named_endpoints", {})
+ unnamed = api_info.get("unnamed_endpoints", {})
+
+ if named:
+ lines.append("## API Endpoints\n")
+ for api_name, endpoint_info in named.items():
+ lines.append(
+ _render_endpoint_section(api_name, endpoint_info, space_id, src_url)
+ )
+
+ if not named and unnamed:
+ lines.append("## API Endpoints\n")
+ for fn_index, endpoint_info in unnamed.items():
+ lines.append(
+ _render_endpoint_section(
+ f"fn_index={fn_index}", endpoint_info, space_id, src_url
+ )
+ )
+
+ return skill_id, "\n".join(lines) + "\n"
+
+
+def _install_space_skill(
+ skill_id: str, content: str, skills_dir: Path, force: bool
+) -> Path:
+ skills_dir = skills_dir.expanduser().resolve()
+ skills_dir.mkdir(parents=True, exist_ok=True)
+ dest = skills_dir / skill_id
+
+ _remove_existing(dest, force)
+ dest.mkdir()
+ (dest / "SKILL.md").write_text(content, encoding="utf-8")
+ return dest
+
+
+@skills_app.command(
+ "add",
+)
+def skills_add(
+ space_id: Annotated[
+ str | None,
+ typer.Argument(
+ help="HF Space ID (e.g. 'user/my-space'). If omitted, installs the general Gradio skill."
+ ),
+ ] = None,
+ cursor: Annotated[
+ bool, typer.Option("--cursor", help="Install for Cursor.")
+ ] = False,
+ claude: Annotated[
+ bool, typer.Option("--claude", help="Install for Claude.")
+ ] = False,
+ codex: Annotated[bool, typer.Option("--codex", help="Install for Codex.")] = False,
+ opencode: Annotated[
+ bool, typer.Option("--opencode", help="Install for OpenCode.")
+ ] = False,
+ global_: Annotated[
+ bool,
+ typer.Option(
+ "--global",
+ "-g",
+ help="Install globally (user-level) instead of in the current project directory.",
+ ),
+ ] = False,
+ dest: Annotated[
+ Path | None,
+ typer.Option(
+ help="Install into a custom destination (path to skills directory)."
+ ),
+ ] = None,
+ force: Annotated[
+ bool,
+ typer.Option("--force", help="Overwrite existing skills in the destination."),
+ ] = False,
+) -> None:
+ """Download and install Gradio skills for an AI assistant.
+
+ When called without a space_id, installs both the gradio (building apps)
+ and hf-gradio (using Spaces via API) skills.
+ When called with a space_id, generates and installs a skill for that
+ specific Gradio Space with Python, JS, and cURL usage examples.
+ """
+ central_global, central_local, hf_global_targets, hf_local_targets = (
+ _get_skill_targets()
+ )
+
+ if not (cursor or claude or codex or opencode or dest):
+ raise typer.BadParameter(
+ "Pick a destination via --cursor, --claude, --codex, --opencode, or --dest."
+ )
+
+ global_targets = {**hf_global_targets, "cursor": Path("~/.cursor/skills")}
+ local_targets = {**hf_local_targets, "cursor": Path(".cursor/skills")}
+ targets_dict = global_targets if global_ else local_targets
+
+ if space_id is not None:
+ skill_id, content = _generate_space_skill(space_id)
+ print(f"Generated skill for Space '{space_id}'")
+
+ if dest:
+ if cursor or claude or codex or opencode or global_:
+ print("--dest cannot be combined with agent flags or --global.")
+ raise typer.Exit(code=1)
+ skill_dest = _install_space_skill(skill_id, content, dest, force)
+ print(f"Installed '{skill_id}' to {skill_dest}")
+ return
+
+ agent_targets: list[Path] = []
+ if cursor:
+ agent_targets.append(targets_dict["cursor"])
+ if claude:
+ agent_targets.append(targets_dict["claude"])
+ if codex:
+ agent_targets.append(targets_dict["codex"])
+ if opencode:
+ agent_targets.append(targets_dict["opencode"])
+
+ central_path = central_global if global_ else central_local
+ central_skill_path = _install_space_skill(
+ skill_id, content, central_path, force
+ )
+ print(f"Installed '{skill_id}' to central location: {central_skill_path}")
+
+ for agent_target in agent_targets:
+ link_path = _create_symlink(
+ agent_target, central_skill_path, force, skill_id=skill_id
+ )
+ print(f"Created symlink: {link_path}")
+ return
+
+ if dest:
+ if cursor or claude or codex or opencode or global_:
+ print("--dest cannot be combined with agent flags or --global.")
+ raise typer.Exit(code=1)
+ skill_dest = _install_to(dest, force)
+ hf_skill_dest = _install_hf_gradio_to(dest, force)
+ print(f"Installed '{SKILL_ID}' to {skill_dest}")
+ print(f"Installed '{HF_SKILL_ID}' to {hf_skill_dest}")
+ return
+
+ agent_targets = []
+ if cursor:
+ agent_targets.append(targets_dict["cursor"])
+ if claude:
+ agent_targets.append(targets_dict["claude"])
+ if codex:
+ agent_targets.append(targets_dict["codex"])
+ if opencode:
+ agent_targets.append(targets_dict["opencode"])
+
+ central_path = central_global if global_ else central_local
+
+ # Install gradio skill
+ central_skill_path = _install_to(central_path, force)
+ print(f"Installed '{SKILL_ID}' to central location: {central_skill_path}")
+
+ # Install hf-gradio skill
+ central_hf_skill_path = _install_hf_gradio_to(central_path, force)
+ print(f"Installed '{HF_SKILL_ID}' to central location: {central_hf_skill_path}")
+
+ for agent_target in agent_targets:
+ # Create symlinks for both skills
+ link_path = _create_symlink(agent_target, central_skill_path, force)
+ print(f"Created symlink: {link_path}")
+ hf_link_path = _create_symlink(
+ agent_target, central_hf_skill_path, force, skill_id=HF_SKILL_ID
+ )
+ print(f"Created symlink: {hf_link_path}")
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/upload_mcp.py b/lib/python3.11/site-packages/gradio/cli/commands/upload_mcp.py
new file mode 100644
index 0000000000000000000000000000000000000000..66efbbac9fd7b426d1acad53dbe190faefadb421
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/cli/commands/upload_mcp.py
@@ -0,0 +1,44 @@
+def main(url_or_space_id: str, source_directory: str):
+ import httpx
+ from gradio_client.utils import is_http_url_like
+ from huggingface_hub import space_info
+ from mcp.server.fastmcp import FastMCP # type: ignore
+
+ from gradio.utils import abspath, is_in_or_equal
+
+ source_path = abspath(source_directory)
+
+ mcp = FastMCP("upload-mcp")
+
+ if is_http_url_like(url_or_space_id):
+ url = url_or_space_id.rstrip("/")
+ else:
+ url = f"https://{space_info(url_or_space_id).subdomain}.hf.space"
+
+ @mcp.tool()
+ def upload_file_to_gradio(file: str) -> str:
+ """Generate a Gradio File Input for a local file by uploading it to a Gradio app and returning the URL.
+ Arguments:
+ file: A complete, absolute path to a local file to upload.
+ Returns:
+ Gradio File Input - A URL to the uploaded file.
+ """
+
+ target_path = abspath(file)
+
+ if not is_in_or_equal(target_path, source_path):
+ raise ValueError(f"File {file} is not in {source_path}")
+
+ with open(target_path, "rb") as f:
+ response = httpx.post(f"{url}/gradio_api/upload", files={"files": f})
+ response.raise_for_status()
+ result = response.json()[0]
+ return f"{url}/gradio_api/file={result}"
+
+ mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+ import typer
+
+ typer.run(main)
diff --git a/lib/python3.11/site-packages/gradio/cli/commands/utils.py b/lib/python3.11/site-packages/gradio/cli/commands/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/gradio/components/__init__.py b/lib/python3.11/site-packages/gradio/components/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b54a45886ef50f0d3aea3f58814529fe84ba8a1
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/__init__.py
@@ -0,0 +1,133 @@
+from gradio.components.annotated_image import AnnotatedImage
+from gradio.components.audio import Audio
+from gradio.components.base import (
+ Component,
+ FormComponent,
+ StreamingInput,
+ StreamingOutput,
+ _Keywords,
+ component,
+ get_component_instance,
+)
+from gradio.components.browser_state import BrowserState
+from gradio.components.button import Button
+from gradio.components.chatbot import Chatbot, ChatMessage, MessageDict
+from gradio.components.checkbox import Checkbox
+from gradio.components.checkboxgroup import CheckboxGroup
+from gradio.components.clear_button import ClearButton
+from gradio.components.code import Code
+from gradio.components.color_picker import ColorPicker
+from gradio.components.dataframe import Dataframe
+from gradio.components.dataset import Dataset
+from gradio.components.datetime import DateTime
+from gradio.components.deep_link_button import DeepLinkButton
+from gradio.components.dialogue import Dialogue
+from gradio.components.download_button import DownloadButton
+from gradio.components.dropdown import Dropdown
+from gradio.components.duplicate_button import DuplicateButton
+from gradio.components.fallback import Fallback
+from gradio.components.file import File
+from gradio.components.file_explorer import FileExplorer
+from gradio.components.gallery import Gallery
+from gradio.components.highlighted_text import HighlightedText
+from gradio.components.html import HTML
+from gradio.components.image import Image
+from gradio.components.image_editor import ImageEditor
+from gradio.components.imageslider import ImageSlider
+from gradio.components.json_component import JSON
+from gradio.components.label import Label
+from gradio.components.login_button import LoginButton
+from gradio.components.markdown import Markdown
+from gradio.components.model3d import Model3D
+from gradio.components.multimodal_textbox import MultimodalTextbox
+from gradio.components.native_plot import BarPlot, LinePlot, NativePlot, ScatterPlot
+from gradio.components.navbar import Navbar
+from gradio.components.number import Number
+from gradio.components.paramviewer import ParamViewer
+from gradio.components.plot import Plot
+from gradio.components.radio import Radio
+from gradio.components.slider import Slider
+from gradio.components.state import State
+from gradio.components.textbox import InputHTMLAttributes, Textbox
+from gradio.components.timer import Timer
+from gradio.components.upload_button import UploadButton
+from gradio.components.video import Video
+from gradio.layouts import Form
+
+Text = Textbox
+DataFrame = Dataframe
+Highlightedtext = HighlightedText
+Annotatedimage = AnnotatedImage
+Highlight = HighlightedText
+Checkboxgroup = CheckboxGroup
+Json = JSON
+
+__all__ = [
+ "Audio",
+ "BarPlot",
+ "Button",
+ "Chatbot",
+ "ChatMessage",
+ "ClearButton",
+ "Component",
+ "component",
+ "get_component_instance",
+ "_Keywords",
+ "Checkbox",
+ "CheckboxGroup",
+ "Code",
+ "ColorPicker",
+ "Dataframe",
+ "DataFrame",
+ "Dataset",
+ "Dialogue",
+ "DownloadButton",
+ "DuplicateButton",
+ "Fallback",
+ "Form",
+ "FormComponent",
+ "Gallery",
+ "HTML",
+ "FileExplorer",
+ "Image",
+ "JSON",
+ "Json",
+ "Label",
+ "LinePlot",
+ "BrowserState",
+ "LoginButton",
+ "Markdown",
+ "MessageDict",
+ "Textbox",
+ "DateTime",
+ "Dropdown",
+ "Model3D",
+ "File",
+ "HighlightedText",
+ "AnnotatedImage",
+ "CheckboxGroup",
+ "Text",
+ "Highlightedtext",
+ "Annotatedimage",
+ "Highlight",
+ "Checkboxgroup",
+ "Number",
+ "Plot",
+ "Radio",
+ "ScatterPlot",
+ "Slider",
+ "State",
+ "Timer",
+ "UploadButton",
+ "Video",
+ "StreamingInput",
+ "StreamingOutput",
+ "ImageEditor",
+ "ImageSlider",
+ "ParamViewer",
+ "MultimodalTextbox",
+ "Navbar",
+ "NativePlot",
+ "DeepLinkButton",
+ "InputHTMLAttributes",
+]
diff --git a/lib/python3.11/site-packages/gradio/components/annotated_image.py b/lib/python3.11/site-packages/gradio/components/annotated_image.py
new file mode 100644
index 0000000000000000000000000000000000000000..15456e112d55076365f585b2f7c63943f721a554
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/annotated_image.py
@@ -0,0 +1,254 @@
+"""gr.AnnotatedImage() component."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, Literal
+
+import gradio_client.utils as client_utils
+import numpy as np
+import PIL.Image
+from gradio_client import handle_file
+from gradio_client.documentation import document
+
+from gradio import processing_utils, utils
+from gradio.components.base import Component
+from gradio.components.button import Button
+from gradio.data_classes import FileData, GradioModel
+from gradio.events import Events
+from gradio.i18n import I18nData
+from gradio.utils import set_default_buttons
+
+if TYPE_CHECKING:
+ from gradio.components import Timer
+
+PIL.Image.init() # fixes https://github.com/gradio-app/gradio/issues/2843
+
+
+class Annotation(GradioModel):
+ image: FileData
+ label: str
+
+
+class AnnotatedImageData(GradioModel):
+ image: FileData
+ annotations: list[Annotation]
+
+
+@document()
+class AnnotatedImage(Component):
+ """
+ Creates a component to displays a base image and colored annotations on top of that image. Annotations can take the from of rectangles (e.g. object detection) or masks (e.g. image segmentation).
+ As this component does not accept user input, it is rarely used as an input component.
+
+ Demos: image_segmentation
+ """
+
+ EVENTS = [Events.select]
+
+ data_model = AnnotatedImageData
+
+ def __init__(
+ self,
+ value: (
+ tuple[
+ np.ndarray | PIL.Image.Image | str,
+ list[tuple[np.ndarray | tuple[int, int, int, int], str]],
+ ]
+ | None
+ ) = None,
+ *,
+ format: str = "webp",
+ show_legend: bool = True,
+ height: int | str | None = None,
+ width: int | str | None = None,
+ color_map: dict[str, str] | None = None,
+ label: str | I18nData | None = None,
+ every: Timer | float | None = None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ show_label: bool | None = None,
+ container: bool = True,
+ scale: int | None = None,
+ min_width: int = 160,
+ visible: bool | Literal["hidden"] = True,
+ elem_id: str | None = None,
+ elem_classes: list[str] | str | None = None,
+ render: bool = True,
+ key: int | str | tuple[int | str, ...] | None = None,
+ preserved_by_key: list[str] | str | None = "value",
+ buttons: list[Literal["fullscreen"] | Button] | None = None,
+ ):
+ """
+ Parameters:
+ value: Tuple of base image and list of (annotation, label) pairs.
+ format: Format used to save images before it is returned to the front end, such as 'jpeg' or 'png'. This parameter only takes effect when the base image is returned from the prediction function as a numpy array or a PIL Image. The format should be supported by the PIL library.
+ show_legend: If True, will show a legend of the annotations.
+ height: The height of the component, specified in pixels if a number is passed, or in CSS units if a string is passed. This has no effect on the preprocessed image file or numpy array, but will affect the displayed image.
+ width: The width of the component, specified in pixels if a number is passed, or in CSS units if a string is passed. This has no effect on the preprocessed image file or numpy array, but will affect the displayed image.
+ color_map: A dictionary mapping labels to colors. The colors must be specified as hex codes.
+ label: the label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.
+ every: Continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ inputs: Components that are used as inputs to calculate `value` if `value` is a function (has no effect otherwise). `value` is recalculated any time the inputs change.
+ show_label: if True, will display label.
+ container: If True, will place the component in a container - providing some extra padding around the border.
+ scale: Relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
+ min_width: Minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
+ visible: If False, component will be hidden. If "hidden", component will be visually hidden and not take up space in the layout but still exist in the DOM
+ elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+ elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
+ render: If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+ key: in a gr.render, Components with the same key across re-renders are treated as the same component, not a new component. Properties set in 'preserved_by_key' are not reset across a re-render.
+ preserved_by_key: A list of parameters from this component's constructor. Inside a gr.render() function, if a component is re-rendered with the same key, these (and only these) parameters will be preserved in the UI (if they have been changed by the user or an event listener) instead of re-rendered based on the values provided during constructor.
+ buttons: A list of buttons to show for the component. Valid options in the list are "fullscreen" or a gr.Button() instance. The "fullscreen" button allows the user to view the image in fullscreen mode. Custom gr.Button() instances will appear in the toolbar with their configured icon and/or label, and clicking them will trigger any .click() events registered on the button. By default, the fullscreen button is shown, and this can hidden by providing an empty list.
+ """
+ self.format = format
+ self.show_legend = show_legend
+ self.height = height
+ self.width = width
+ self.color_map = color_map
+ self.buttons = set_default_buttons(buttons, ["fullscreen"])
+ self._value_description = "a tuple of type [image: str, annotations: list[tuple[mask: str, label: str]]] where 'image' is the path to the base image and 'annotations' is a list of tuples where each tuple has a 'mask' image filepath and a corresponding label."
+ super().__init__(
+ label=label,
+ every=every,
+ inputs=inputs,
+ show_label=show_label,
+ container=container,
+ scale=scale,
+ min_width=min_width,
+ visible=visible,
+ elem_id=elem_id,
+ elem_classes=elem_classes,
+ render=render,
+ key=key,
+ preserved_by_key=preserved_by_key,
+ value=value,
+ )
+
+ def preprocess(
+ self, payload: AnnotatedImageData | None
+ ) -> tuple[str, list[tuple[str, str]]] | None:
+ """
+ Parameters:
+ payload: Dict of base image and list of annotations.
+ Returns:
+ Passes its value as a `tuple` consisting of:
+ - `str` filepath to a base image
+ - `list` of annotations.
+ -- Each annotation itself is a `tuple` of a mask (as a `str` filepath to image) and a `str` label.
+ """
+ if payload is None:
+ return None
+ base_img = payload.image.path
+ annotations = [(a.image.path, a.label) for a in payload.annotations]
+ return (base_img, annotations)
+
+ def postprocess(
+ self,
+ value: (
+ tuple[
+ np.ndarray | PIL.Image.Image | str,
+ Sequence[tuple[np.ndarray | tuple[int, int, int, int], str]],
+ ]
+ | None
+ ),
+ ) -> AnnotatedImageData | None:
+ """
+ Parameters:
+ value: Expects a tuple consisting of a base image and list of annotations: a `tuple[Image, list[Annotation]]`.
+ - The `Image` itself can be `str` filepath, `numpy.ndarray`, or `PIL.Image`.
+ - Each `Annotation` is a `tuple[Mask, str]`.
+ -- The `Mask` can be either a `tuple` of 4 `int`'s representing the bounding box coordinates (x1, y1, x2, y2), or 0-1 confidence mask in the form of a `numpy.ndarray` of the same shape as the image.
+ -- The second element of the `Annotation` tuple is a `str` label.
+ Returns:
+ Tuple of base image file and list of annotations, with each annotation a two-part tuple where the first element image path of the mask, and the second element is the label.
+ """
+ if value is None:
+ return None
+ base_img = value[0]
+ if isinstance(base_img, str):
+ if client_utils.is_http_url_like(base_img):
+ base_img = processing_utils.save_url_to_cache(
+ base_img, cache_dir=self.GRADIO_CACHE
+ )
+ base_img_path = base_img
+ base_img = np.array(PIL.Image.open(base_img))
+ elif isinstance(base_img, np.ndarray):
+ base_file = processing_utils.save_img_array_to_cache(
+ base_img, cache_dir=self.GRADIO_CACHE, format=self.format
+ )
+ base_img_path = str(utils.abspath(base_file))
+ elif isinstance(base_img, PIL.Image.Image):
+ base_file = processing_utils.save_pil_to_cache(
+ base_img, cache_dir=self.GRADIO_CACHE, format=self.format
+ )
+ base_img_path = str(utils.abspath(base_file))
+ base_img = np.array(base_img)
+ else:
+ raise ValueError(
+ "AnnotatedImage only accepts filepaths, PIL images or numpy arrays for the base image."
+ )
+
+ sections = []
+ color_map = self.color_map or {}
+
+ def hex_to_rgb(value):
+ value = value.lstrip("#")
+ lv = len(value)
+ return [int(value[i : i + lv // 3], 16) for i in range(0, lv, lv // 3)]
+
+ for mask, label in value[1]:
+ mask_array = np.zeros((base_img.shape[0], base_img.shape[1]))
+ if isinstance(mask, np.ndarray):
+ mask_array = mask
+ else:
+ x1, y1, x2, y2 = mask
+ border_width = 3
+ mask_array[y1:y2, x1:x2] = 0.5
+ mask_array[y1:y2, x1 : x1 + border_width] = 1
+ mask_array[y1:y2, x2 - border_width : x2] = 1
+ mask_array[y1 : y1 + border_width, x1:x2] = 1
+ mask_array[y2 - border_width : y2, x1:x2] = 1
+
+ if label in color_map:
+ rgb_color = hex_to_rgb(color_map[label])
+ else:
+ rgb_color = [255, 0, 0]
+ colored_mask = np.zeros((base_img.shape[0], base_img.shape[1], 4))
+ solid_mask = np.copy(mask_array)
+ solid_mask[solid_mask > 0] = 1
+
+ colored_mask[:, :, 0] = rgb_color[0] * solid_mask
+ colored_mask[:, :, 1] = rgb_color[1] * solid_mask
+ colored_mask[:, :, 2] = rgb_color[2] * solid_mask
+ colored_mask[:, :, 3] = mask_array * 255
+
+ colored_mask_img = PIL.Image.fromarray((colored_mask).astype(np.uint8))
+
+ # RGBA does not support transparency
+ mask_file = processing_utils.save_pil_to_cache(
+ colored_mask_img, cache_dir=self.GRADIO_CACHE, format="png"
+ )
+ mask_file_path = str(utils.abspath(mask_file))
+ sections.append(
+ Annotation(image=FileData(path=mask_file_path), label=label)
+ )
+
+ return AnnotatedImageData(
+ image=FileData(path=base_img_path),
+ annotations=sections,
+ )
+
+ def example_payload(self) -> Any:
+ return {
+ "image": handle_file(
+ "https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png"
+ ),
+ "annotations": [],
+ }
+
+ def example_value(self) -> Any:
+ return (
+ "https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png",
+ [([0, 0, 100, 100], "bus")],
+ )
diff --git a/lib/python3.11/site-packages/gradio/components/annotated_image.pyi b/lib/python3.11/site-packages/gradio/components/annotated_image.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..6dfad9ea426d119369fcf4dc2dc006a6c63eb4bd
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/annotated_image.pyi
@@ -0,0 +1,314 @@
+"""gr.AnnotatedImage() component."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, Literal
+
+import gradio_client.utils as client_utils
+import numpy as np
+import PIL.Image
+from gradio_client import handle_file
+from gradio_client.documentation import document
+
+from gradio import processing_utils, utils
+from gradio.components.base import Component
+from gradio.components.button import Button
+from gradio.data_classes import FileData, GradioModel
+from gradio.events import Events
+from gradio.i18n import I18nData
+from gradio.utils import set_default_buttons
+
+if TYPE_CHECKING:
+ from gradio.components import Timer
+
+PIL.Image.init() # fixes https://github.com/gradio-app/gradio/issues/2843
+
+
+class Annotation(GradioModel):
+ image: FileData
+ label: str
+
+
+class AnnotatedImageData(GradioModel):
+ image: FileData
+ annotations: list[Annotation]
+
+from gradio.events import Dependency
+
+@document()
+class AnnotatedImage(Component):
+ """
+ Creates a component to displays a base image and colored annotations on top of that image. Annotations can take the from of rectangles (e.g. object detection) or masks (e.g. image segmentation).
+ As this component does not accept user input, it is rarely used as an input component.
+
+ Demos: image_segmentation
+ """
+
+ EVENTS = [Events.select]
+
+ data_model = AnnotatedImageData
+
+ def __init__(
+ self,
+ value: (
+ tuple[
+ np.ndarray | PIL.Image.Image | str,
+ list[tuple[np.ndarray | tuple[int, int, int, int], str]],
+ ]
+ | None
+ ) = None,
+ *,
+ format: str = "webp",
+ show_legend: bool = True,
+ height: int | str | None = None,
+ width: int | str | None = None,
+ color_map: dict[str, str] | None = None,
+ label: str | I18nData | None = None,
+ every: Timer | float | None = None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ show_label: bool | None = None,
+ container: bool = True,
+ scale: int | None = None,
+ min_width: int = 160,
+ visible: bool | Literal["hidden"] = True,
+ elem_id: str | None = None,
+ elem_classes: list[str] | str | None = None,
+ render: bool = True,
+ key: int | str | tuple[int | str, ...] | None = None,
+ preserved_by_key: list[str] | str | None = "value",
+ buttons: list[Literal["fullscreen"] | Button] | None = None,
+ ):
+ """
+ Parameters:
+ value: Tuple of base image and list of (annotation, label) pairs.
+ format: Format used to save images before it is returned to the front end, such as 'jpeg' or 'png'. This parameter only takes effect when the base image is returned from the prediction function as a numpy array or a PIL Image. The format should be supported by the PIL library.
+ show_legend: If True, will show a legend of the annotations.
+ height: The height of the component, specified in pixels if a number is passed, or in CSS units if a string is passed. This has no effect on the preprocessed image file or numpy array, but will affect the displayed image.
+ width: The width of the component, specified in pixels if a number is passed, or in CSS units if a string is passed. This has no effect on the preprocessed image file or numpy array, but will affect the displayed image.
+ color_map: A dictionary mapping labels to colors. The colors must be specified as hex codes.
+ label: the label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.
+ every: Continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ inputs: Components that are used as inputs to calculate `value` if `value` is a function (has no effect otherwise). `value` is recalculated any time the inputs change.
+ show_label: if True, will display label.
+ container: If True, will place the component in a container - providing some extra padding around the border.
+ scale: Relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
+ min_width: Minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
+ visible: If False, component will be hidden. If "hidden", component will be visually hidden and not take up space in the layout but still exist in the DOM
+ elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+ elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
+ render: If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+ key: in a gr.render, Components with the same key across re-renders are treated as the same component, not a new component. Properties set in 'preserved_by_key' are not reset across a re-render.
+ preserved_by_key: A list of parameters from this component's constructor. Inside a gr.render() function, if a component is re-rendered with the same key, these (and only these) parameters will be preserved in the UI (if they have been changed by the user or an event listener) instead of re-rendered based on the values provided during constructor.
+ buttons: A list of buttons to show for the component. Valid options in the list are "fullscreen" or a gr.Button() instance. The "fullscreen" button allows the user to view the image in fullscreen mode. Custom gr.Button() instances will appear in the toolbar with their configured icon and/or label, and clicking them will trigger any .click() events registered on the button. By default, the fullscreen button is shown, and this can hidden by providing an empty list.
+ """
+ self.format = format
+ self.show_legend = show_legend
+ self.height = height
+ self.width = width
+ self.color_map = color_map
+ self.buttons = set_default_buttons(buttons, ["fullscreen"])
+ self._value_description = "a tuple of type [image: str, annotations: list[tuple[mask: str, label: str]]] where 'image' is the path to the base image and 'annotations' is a list of tuples where each tuple has a 'mask' image filepath and a corresponding label."
+ super().__init__(
+ label=label,
+ every=every,
+ inputs=inputs,
+ show_label=show_label,
+ container=container,
+ scale=scale,
+ min_width=min_width,
+ visible=visible,
+ elem_id=elem_id,
+ elem_classes=elem_classes,
+ render=render,
+ key=key,
+ preserved_by_key=preserved_by_key,
+ value=value,
+ )
+
+ def preprocess(
+ self, payload: AnnotatedImageData | None
+ ) -> tuple[str, list[tuple[str, str]]] | None:
+ """
+ Parameters:
+ payload: Dict of base image and list of annotations.
+ Returns:
+ Passes its value as a `tuple` consisting of:
+ - `str` filepath to a base image
+ - `list` of annotations.
+ -- Each annotation itself is a `tuple` of a mask (as a `str` filepath to image) and a `str` label.
+ """
+ if payload is None:
+ return None
+ base_img = payload.image.path
+ annotations = [(a.image.path, a.label) for a in payload.annotations]
+ return (base_img, annotations)
+
+ def postprocess(
+ self,
+ value: (
+ tuple[
+ np.ndarray | PIL.Image.Image | str,
+ Sequence[tuple[np.ndarray | tuple[int, int, int, int], str]],
+ ]
+ | None
+ ),
+ ) -> AnnotatedImageData | None:
+ """
+ Parameters:
+ value: Expects a tuple consisting of a base image and list of annotations: a `tuple[Image, list[Annotation]]`.
+ - The `Image` itself can be `str` filepath, `numpy.ndarray`, or `PIL.Image`.
+ - Each `Annotation` is a `tuple[Mask, str]`.
+ -- The `Mask` can be either a `tuple` of 4 `int`'s representing the bounding box coordinates (x1, y1, x2, y2), or 0-1 confidence mask in the form of a `numpy.ndarray` of the same shape as the image.
+ -- The second element of the `Annotation` tuple is a `str` label.
+ Returns:
+ Tuple of base image file and list of annotations, with each annotation a two-part tuple where the first element image path of the mask, and the second element is the label.
+ """
+ if value is None:
+ return None
+ base_img = value[0]
+ if isinstance(base_img, str):
+ if client_utils.is_http_url_like(base_img):
+ base_img = processing_utils.save_url_to_cache(
+ base_img, cache_dir=self.GRADIO_CACHE
+ )
+ base_img_path = base_img
+ base_img = np.array(PIL.Image.open(base_img))
+ elif isinstance(base_img, np.ndarray):
+ base_file = processing_utils.save_img_array_to_cache(
+ base_img, cache_dir=self.GRADIO_CACHE, format=self.format
+ )
+ base_img_path = str(utils.abspath(base_file))
+ elif isinstance(base_img, PIL.Image.Image):
+ base_file = processing_utils.save_pil_to_cache(
+ base_img, cache_dir=self.GRADIO_CACHE, format=self.format
+ )
+ base_img_path = str(utils.abspath(base_file))
+ base_img = np.array(base_img)
+ else:
+ raise ValueError(
+ "AnnotatedImage only accepts filepaths, PIL images or numpy arrays for the base image."
+ )
+
+ sections = []
+ color_map = self.color_map or {}
+
+ def hex_to_rgb(value):
+ value = value.lstrip("#")
+ lv = len(value)
+ return [int(value[i : i + lv // 3], 16) for i in range(0, lv, lv // 3)]
+
+ for mask, label in value[1]:
+ mask_array = np.zeros((base_img.shape[0], base_img.shape[1]))
+ if isinstance(mask, np.ndarray):
+ mask_array = mask
+ else:
+ x1, y1, x2, y2 = mask
+ border_width = 3
+ mask_array[y1:y2, x1:x2] = 0.5
+ mask_array[y1:y2, x1 : x1 + border_width] = 1
+ mask_array[y1:y2, x2 - border_width : x2] = 1
+ mask_array[y1 : y1 + border_width, x1:x2] = 1
+ mask_array[y2 - border_width : y2, x1:x2] = 1
+
+ if label in color_map:
+ rgb_color = hex_to_rgb(color_map[label])
+ else:
+ rgb_color = [255, 0, 0]
+ colored_mask = np.zeros((base_img.shape[0], base_img.shape[1], 4))
+ solid_mask = np.copy(mask_array)
+ solid_mask[solid_mask > 0] = 1
+
+ colored_mask[:, :, 0] = rgb_color[0] * solid_mask
+ colored_mask[:, :, 1] = rgb_color[1] * solid_mask
+ colored_mask[:, :, 2] = rgb_color[2] * solid_mask
+ colored_mask[:, :, 3] = mask_array * 255
+
+ colored_mask_img = PIL.Image.fromarray((colored_mask).astype(np.uint8))
+
+ # RGBA does not support transparency
+ mask_file = processing_utils.save_pil_to_cache(
+ colored_mask_img, cache_dir=self.GRADIO_CACHE, format="png"
+ )
+ mask_file_path = str(utils.abspath(mask_file))
+ sections.append(
+ Annotation(image=FileData(path=mask_file_path), label=label)
+ )
+
+ return AnnotatedImageData(
+ image=FileData(path=base_img_path),
+ annotations=sections,
+ )
+
+ def example_payload(self) -> Any:
+ return {
+ "image": handle_file(
+ "https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png"
+ ),
+ "annotations": [],
+ }
+
+ def example_value(self) -> Any:
+ return (
+ "https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png",
+ [([0, 0, 100, 100], "bus")],
+ )
+ from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+ from gradio.blocks import Block
+ if TYPE_CHECKING:
+ from gradio.components import Timer
+ from gradio.components.base import Component
+
+
+ def select(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/gradio/components/api_component.py b/lib/python3.11/site-packages/gradio/components/api_component.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6531b9eab3897ec37abd576cc63d9fa60aa6e25
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/api_component.py
@@ -0,0 +1,46 @@
+"""gr.Api() component."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from gradio.components.base import Component
+
+
+class Api(Component):
+ """
+ A generic component that holds any value. Used for generating APIs with no actual frontend component.
+ """
+
+ EVENTS = []
+
+ def __init__(
+ self,
+ value: Any,
+ _api_info: dict[str, str],
+ label: str = "API",
+ ):
+ """
+ Parameters:
+ value: default value.
+ """
+ self._api_info = _api_info
+ super().__init__(value=value, label=label)
+
+ def preprocess(self, payload: Any) -> Any:
+ return payload
+
+ def postprocess(self, value: Any) -> Any:
+ return value
+
+ def api_info(self) -> dict[str, str]: # type: ignore[override]
+ return self._api_info
+
+ def example_payload(self) -> Any:
+ return self.value if self.value is not None else "..."
+
+ def example_value(self) -> Any:
+ return self.value if self.value is not None else "..."
+
+ # def get_block_name(self) -> str:
+ # return "state" # so that it does not render in the frontend, just like state
diff --git a/lib/python3.11/site-packages/gradio/components/audio.py b/lib/python3.11/site-packages/gradio/components/audio.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a846e323ea91edba6f76deeeba929bfea4768e1
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/audio.py
@@ -0,0 +1,453 @@
+"""gr.Audio() component."""
+
+from __future__ import annotations
+
+import dataclasses
+import io
+import json
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+import anyio
+import httpx
+import numpy as np
+from gradio_client import handle_file
+from gradio_client import utils as client_utils
+from gradio_client.documentation import document
+from pydub import AudioSegment
+
+from gradio import processing_utils
+from gradio.components.base import Component, StreamingInput, StreamingOutput
+from gradio.components.button import Button
+from gradio.data_classes import FileData, FileDataDict, MediaStreamChunk
+from gradio.events import Events
+from gradio.i18n import I18nData
+from gradio.utils import set_default_buttons
+
+if TYPE_CHECKING:
+ from gradio.components import Timer
+
+
+@document()
+@dataclasses.dataclass
+class WaveformOptions:
+ """
+ A dataclass for specifying options for the waveform display in the Audio component. An instance of this class can be passed into the `waveform_options` parameter of `gr.Audio`.
+ Parameters:
+ waveform_color: The color (as a hex string or valid CSS color) of the full waveform representing the amplitude of the audio. Defaults to a light gray color.
+ waveform_progress_color: The color (as a hex string or valid CSS color) that the waveform fills with to as the audio plays. Defaults to the accent color.
+ trim_region_color: The color (as a hex string or valid CSS color) of the trim region. Defaults to the accent color.
+ show_recording_waveform: If True, shows a waveform when recording audio or playing audio. If False, uses the default browser audio players. For streamed audio, the default browser audio player is always used.
+ skip_length: The percentage (between 0 and 100) of the audio to skip when clicking on the skip forward / skip backward buttons.
+ sample_rate: The output sample rate (in Hz) of the audio after editing.
+ """
+
+ waveform_color: str | None = None
+ waveform_progress_color: str | None = None
+ trim_region_color: str | None = None
+ show_recording_waveform: bool = True
+ skip_length: int | float = 5
+ sample_rate: int = 44100
+
+
+@document()
+class Audio(
+ StreamingInput,
+ StreamingOutput,
+ Component,
+):
+ """
+ Creates an audio component that can be used to upload/record audio (as an input) or display audio (as an output).
+ Demos: generate_tone, reverse_audio
+ Guides: streaming-inputs, streaming-outputs, automatic-voice-detection, real-time-speech-recognition
+ """
+
+ EVENTS = [
+ Events.stream,
+ Events.change,
+ Events.clear,
+ Events.play,
+ Events.pause,
+ Events.stop,
+ Events.pause,
+ Events.start_recording,
+ Events.pause_recording,
+ Events.stop_recording,
+ Events.upload,
+ Events.input,
+ ]
+
+ data_model = FileData
+
+ def __init__(
+ self,
+ value: str | Path | tuple[int, np.ndarray] | Callable | None = None,
+ *,
+ sources: list[Literal["upload", "microphone"]]
+ | Literal["upload", "microphone"]
+ | None = None,
+ type: Literal["numpy", "filepath"] = "numpy",
+ label: str | I18nData | None = None,
+ every: Timer | float | None = None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ show_label: bool | None = None,
+ container: bool = True,
+ scale: int | None = None,
+ min_width: int = 160,
+ interactive: bool | None = None,
+ visible: bool | Literal["hidden"] = True,
+ streaming: bool = False,
+ elem_id: str | None = None,
+ elem_classes: list[str] | str | None = None,
+ render: bool = True,
+ key: int | str | tuple[int | str, ...] | None = None,
+ preserved_by_key: list[str] | str | None = "value",
+ format: Literal["wav", "mp3"] | None = None,
+ autoplay: bool = False,
+ editable: bool = True,
+ buttons: list[Literal["download", "share"] | Button] | None = None,
+ waveform_options: WaveformOptions | dict | None = None,
+ loop: bool = False,
+ recording: bool = False,
+ subtitles: str | Path | list[dict[str, Any]] | None = None,
+ playback_position: float = 0,
+ ):
+ """
+ Parameters:
+ value: A path, URL, or [sample_rate, numpy array] tuple (sample rate in Hz, audio data as a float or int numpy array) for the default value that Audio component is going to take. If a function is provided, the function will be called each time the app loads to set the initial value of this component.
+ sources: A list of sources permitted for audio. "upload" creates a box where user can drop an audio file, "microphone" creates a microphone input. The first element in the list will be used as the default source. If None, defaults to ["upload", "microphone"], or ["microphone"] if `streaming` is True.
+ type: The format the audio file is converted to before being passed into the prediction function. "numpy" converts the audio to a tuple consisting of: (int sample rate, numpy.array for the data), "filepath" passes a str path to a temporary file containing the audio.
+ label: the label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.
+ every: Continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ inputs: Components that are used as inputs to calculate `value` if `value` is a function (has no effect otherwise). `value` is recalculated any time the inputs change.
+ show_label: if True, will display label.
+ container: If True, will place the component in a container - providing some extra padding around the border.
+ scale: Relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
+ min_width: Minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
+ interactive: If True, will allow users to upload and edit an audio file. If False, can only be used to play audio. If not provided, this is inferred based on whether the component is used as an input or output.
+ visible: If False, component will be hidden. If "hidden", component will be visually hidden and not take up space in the layout but still exist in the DOM If "hidden", component will be visually hidden and not take up space in the layout but still exist in the DOM.
+ streaming: If set to True when used in a `live` interface as an input, will automatically stream webcam feed. When used set as an output, takes audio chunks yield from the backend and combines them into one streaming audio output.
+ elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+ elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
+ render: if False, component will not be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+ key: in a gr.render, Components with the same key across re-renders are treated as the same component, not a new component. Properties set in 'preserved_by_key' are not reset across a re-render.
+ preserved_by_key: A list of parameters from this component's constructor. Inside a gr.render() function, if a component is re-rendered with the same key, these (and only these) parameters will be preserved in the UI (if they have been changed by the user or an event listener) instead of re-rendered based on the values provided during constructor.
+ format: the file extension with which to save audio files. Either 'wav' or 'mp3'. wav files are lossless but will tend to be larger files. mp3 files tend to be smaller. This parameter applies both when this component is used as an input (and `type` is "filepath") to determine which file format to convert user-provided audio to, and when this component is used as an output to determine the format of audio returned to the user. If None, no file format conversion is done and the audio is kept as is. In the case where output audio is returned from the prediction function as numpy array and no `format` is provided, it will be returned as a "wav" file.
+ autoplay: Whether to automatically play the audio when the component is used as an output. Note: browsers will not autoplay audio files if the user has not interacted with the page yet.
+ buttons: A list of buttons to show in the top right corner of the component. Valid options are "download", "share", or a gr.Button() instance. The "download" button allows the user to save the audio to their device. The "share" button allows the user to share the audio via Hugging Face Spaces Discussions. Custom gr.Button() instances will appear in the toolbar with their configured icon and/or label, and clicking them will trigger any .click() events registered on the button. By default, only the "download" and "share" buttons are shown.
+ editable: If True, allows users to manipulate the audio file if the component is interactive. Defaults to True.
+ waveform_options: A dictionary of options for the waveform display. Options include: waveform_color (str), waveform_progress_color (str), skip_length (int), trim_region_color (str). Default is None, which uses the default values for these options. [See `gr.WaveformOptions` docs](#waveform-options).
+ loop: If True, the audio will loop when it reaches the end and continue playing from the beginning.
+ recording: If True, the audio component will be set to record audio from the microphone if the source is set to "microphone". Defaults to False.
+ subtitles: A subtitle file (srt, vtt, or json) for the audio, or a list of subtitle dictionaries in the format [{"text": str, "timestamp": [start, end]}] where timestamps are in seconds. JSON files should contain an array of subtitle objects.
+ playback_position: The starting playback position in seconds. This value is also updated as the audio plays, reflecting the current playback position.
+ """
+ valid_sources: list[Literal["upload", "microphone"]] = ["upload", "microphone"]
+ if sources is None:
+ self.sources = ["microphone"] if streaming else valid_sources
+ elif isinstance(sources, str) and sources in valid_sources:
+ self.sources = [sources]
+ elif isinstance(sources, list):
+ self.sources = sources
+ else:
+ raise ValueError(
+ f"`sources` must be a list consisting of elements in {valid_sources}"
+ )
+ for source in self.sources:
+ if source not in valid_sources:
+ raise ValueError(
+ f"`sources` must a list consisting of elements in {valid_sources}"
+ )
+ valid_types = ["numpy", "filepath"]
+ if type not in valid_types:
+ raise ValueError(
+ f"Invalid value for parameter `type`: {type}. Please choose from one of: {' '.join(valid_types)}"
+ )
+ self.type = type
+ self.streaming = streaming
+ if self.streaming and "microphone" not in self.sources:
+ raise ValueError(
+ "Audio streaming only available if sources includes 'microphone'."
+ )
+ valid_formats = ["wav", "mp3"]
+ if format is not None and format.lower() not in valid_formats:
+ raise ValueError(
+ f"Invalid value for parameter `format`: {format}. Please choose from one of: {' '.join(valid_formats)}"
+ )
+ self.format = format and format.lower()
+ self.autoplay = autoplay
+ self.loop = loop
+ self.buttons = set_default_buttons(buttons, ["download", "share"])
+ self.editable = editable
+ if waveform_options is None:
+ self.waveform_options = WaveformOptions()
+ elif isinstance(waveform_options, dict):
+ self.waveform_options = WaveformOptions(**waveform_options) # type: ignore
+ else:
+ self.waveform_options = waveform_options
+ self.recording = recording
+ self.playback_position = playback_position
+ super().__init__(
+ label=label,
+ every=every,
+ inputs=inputs,
+ show_label=show_label,
+ container=container,
+ scale=scale,
+ min_width=min_width,
+ interactive=interactive,
+ visible=visible,
+ elem_id=elem_id,
+ elem_classes=elem_classes,
+ render=render,
+ key=key,
+ preserved_by_key=preserved_by_key,
+ value=value,
+ )
+ self._value_description = (
+ "a filepath to an audio file"
+ if self.type == "filepath"
+ else "a tuple of [sample_rate: int, data: np.ndarray] of audio data"
+ )
+ self.subtitles = None
+ if subtitles is not None:
+ if isinstance(subtitles, list):
+ self.subtitles = self._process_json_subtitles(subtitles)
+ else:
+ self.subtitles = self._process_subtitle_file(subtitles)
+
+ def example_payload(self) -> Any:
+ return handle_file(
+ "https://github.com/gradio-app/gradio/raw/main/test/test_files/audio_sample.wav"
+ )
+
+ def example_value(self) -> Any:
+ return "https://github.com/gradio-app/gradio/raw/main/test/test_files/audio_sample.wav"
+
+ def preprocess(
+ self, payload: FileData | None
+ ) -> str | tuple[int, np.ndarray] | None:
+ """
+ Parameters:
+ payload: audio data as a FileData object, or None.
+ Returns:
+ Passes audio as one of these formats (depending on `type`):
+ - `str` filepath
+ - `tuple` of (sample rate in Hz, audio data as numpy array).
+ -- The audio data is a 16-bit `int` array whose values range from -32768 to 32767 and shape of the audio data array is (samples,) for mono audio or (samples, channels) for multi-channel audio.
+ """
+ if payload is None:
+ return payload
+
+ if not payload.path:
+ raise ValueError("payload path missing")
+
+ needs_conversion = False
+ original_suffix = Path(payload.path).suffix.lower()
+ if self.format is not None and original_suffix != f".{self.format}":
+ needs_conversion = True
+ if self.type == "numpy":
+ return processing_utils.audio_from_file(payload.path)
+ elif self.type == "filepath":
+ if not needs_conversion:
+ return payload.path
+ sample_rate, data = processing_utils.audio_from_file(payload.path)
+ output_file = str(Path(payload.path).with_suffix(f".{self.format}"))
+ assert self.format is not None # noqa: S101
+ processing_utils.audio_to_file(
+ sample_rate, data, output_file, format=self.format
+ )
+ return output_file
+ else:
+ raise ValueError(
+ "Unknown type: "
+ + str(self.type)
+ + ". Please choose from: 'numpy', 'filepath'."
+ )
+
+ def postprocess(
+ self, value: str | Path | bytes | tuple[int, np.ndarray] | None
+ ) -> FileData | bytes | None:
+ """
+ Parameters:
+ value: Expects audio data in any of these formats:
+ - `str`
+ - `pathlib.Path` filepath
+ - URL to an audio file
+ - `bytes` object (recommended for streaming)
+ - `tuple` of (sample rate in Hz, audio data as numpy array).
+ -- Note: if audio is supplied as a numpy array, the audio will be normalized by its peak value to avoid distortion or clipping in the resulting audio.
+ Returns:
+ FileData object, bytes, or None.
+ """
+ orig_name = None
+ if value is None:
+ return None
+
+ if isinstance(value, bytes):
+ if self.streaming:
+ return value
+ file_path = processing_utils.save_bytes_to_cache(
+ value, "audio", cache_dir=self.GRADIO_CACHE
+ )
+ orig_name = Path(file_path).name
+ elif isinstance(value, tuple):
+ sample_rate, data = value
+ file_path = processing_utils.save_audio_to_cache(
+ data,
+ sample_rate,
+ format=self.format or "wav",
+ cache_dir=self.GRADIO_CACHE,
+ )
+ orig_name = Path(file_path).name
+ elif isinstance(value, (str, Path)):
+ if client_utils.is_http_url_like(value):
+ original_suffix = Path(httpx.URL(str(value)).path).suffix.lower()
+ else:
+ original_suffix = Path(value).suffix.lower()
+ if self.format is not None and original_suffix != f".{self.format}":
+ sample_rate, data = processing_utils.audio_from_file(str(value))
+ file_path = processing_utils.save_audio_to_cache(
+ data, sample_rate, format=self.format, cache_dir=self.GRADIO_CACHE
+ )
+ else:
+ file_path = str(value)
+ orig_name = Path(file_path).name if Path(file_path).exists() else None
+ else:
+ raise ValueError(f"Cannot process {value} as Audio")
+ return FileData(path=file_path, orig_name=orig_name)
+
+ @staticmethod
+ def _convert_to_adts(data: bytes):
+ segment = AudioSegment.from_file(io.BytesIO(data))
+
+ buffer = io.BytesIO()
+ segment.export(buffer, format="adts") # ADTS is a container format for AAC
+ aac_data = buffer.getvalue()
+ return aac_data, len(segment) / 1000.0
+
+ @staticmethod
+ async def covert_to_adts(data: bytes) -> tuple[bytes, float]:
+ return await anyio.to_thread.run_sync(Audio._convert_to_adts, data)
+
+ async def stream_output(
+ self,
+ value,
+ output_id: str,
+ first_chunk: bool, # noqa: ARG002
+ ) -> tuple[MediaStreamChunk | None, FileDataDict]:
+ output_file: FileDataDict = {
+ "path": output_id,
+ "is_stream": True,
+ "orig_name": "audio-stream.mp3",
+ "meta": {"_type": "gradio.FileData"},
+ }
+ if value is None:
+ return None, output_file
+ if isinstance(value, bytes):
+ value, duration = await self.covert_to_adts(value)
+ return {
+ "data": value,
+ "duration": duration,
+ "extension": ".aac",
+ }, output_file
+ if client_utils.is_http_url_like(value["path"]):
+ response = httpx.get(value["path"])
+ binary_data = response.content
+ else:
+ output_file["orig_name"] = value["orig_name"]
+ file_path = value["path"]
+ with open(file_path, "rb") as f:
+ binary_data = f.read()
+ value, duration = await self.covert_to_adts(binary_data)
+ return {"data": value, "duration": duration, "extension": ".aac"}, output_file
+
+ async def combine_stream(
+ self,
+ stream: list[bytes],
+ desired_output_format: str | None = None,
+ only_file=False, # noqa: ARG002
+ ) -> FileData:
+ output_file = FileData(
+ path=processing_utils.save_bytes_to_cache(
+ b"".join(stream), "audio.mp3", cache_dir=self.GRADIO_CACHE
+ ),
+ is_stream=False,
+ orig_name="audio-stream.mp3",
+ )
+ if desired_output_format and desired_output_format != "mp3":
+ new_path = Path(output_file.path).with_suffix(f".{desired_output_format}")
+ AudioSegment.from_file(output_file.path).export(
+ new_path, format=desired_output_format
+ )
+ output_file.path = str(new_path)
+ return output_file
+
+ def _process_json_subtitles(
+ self, subtitles: list[dict[str, Any]]
+ ) -> list[dict[str, Any]]:
+ for i, subtitle in enumerate(subtitles):
+ if not isinstance(subtitle, dict):
+ raise ValueError(f"Subtitle at index {i} must be a dictionary")
+ if "text" not in subtitle:
+ raise ValueError(f"Subtitle at index {i} missing required 'text' field")
+ if "timestamp" not in subtitle:
+ raise ValueError(
+ f"Subtitle at index {i} missing required 'timestamp' field"
+ )
+ if (
+ not isinstance(subtitle["timestamp"], (list, tuple))
+ or len(subtitle["timestamp"]) != 2
+ ):
+ raise ValueError(
+ f"Subtitle at index {i} 'timestamp' must be a list/tuple of [start, end]"
+ )
+ return [
+ {
+ "start": subtitle["timestamp"][0],
+ "end": subtitle["timestamp"][1],
+ "text": subtitle["text"],
+ }
+ for subtitle in subtitles
+ ]
+
+ def _process_subtitle_file(
+ self, subtitle_file: str | Path
+ ) -> FileData | list[dict[str, Any]]:
+ file_path = Path(subtitle_file)
+ if file_path.suffix.lower() == ".json":
+ try:
+ with open(file_path, encoding="utf-8") as f:
+ json_data = json.load(f)
+ if isinstance(json_data, list):
+ return self._process_json_subtitles(json_data)
+ else:
+ raise ValueError(
+ "JSON subtitle file must contain a list of subtitle objects"
+ ) from None
+
+ except json.JSONDecodeError as e:
+ raise ValueError(f"Invalid JSON format in subtitle file: {e}") from e
+ except Exception as e:
+ raise ValueError(f"Error reading JSON subtitle file: {e}") from e
+ return handle_file(subtitle_file)
+
+ def process_example(
+ self, value: tuple[int, np.ndarray] | str | Path | bytes | None
+ ) -> str:
+ if value is None:
+ return ""
+ elif isinstance(value, (str, Path)):
+ return Path(value).name
+ return "(audio)"
+
+ def check_streamable(self):
+ if (
+ self.sources is not None
+ and "microphone" not in self.sources
+ and self.streaming
+ ):
+ raise ValueError(
+ "Audio streaming only available if source includes 'microphone'."
+ )
diff --git a/lib/python3.11/site-packages/gradio/components/audio.pyi b/lib/python3.11/site-packages/gradio/components/audio.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..b38d4c4772807df5ddd7531f6c7cc27642e2b322
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/audio.pyi
@@ -0,0 +1,1104 @@
+"""gr.Audio() component."""
+
+from __future__ import annotations
+
+import dataclasses
+import io
+import json
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+import anyio
+import httpx
+import numpy as np
+from gradio_client import handle_file
+from gradio_client import utils as client_utils
+from gradio_client.documentation import document
+from pydub import AudioSegment
+
+from gradio import processing_utils
+from gradio.components.base import Component, StreamingInput, StreamingOutput
+from gradio.components.button import Button
+from gradio.data_classes import FileData, FileDataDict, MediaStreamChunk
+from gradio.events import Events
+from gradio.i18n import I18nData
+from gradio.utils import set_default_buttons
+
+if TYPE_CHECKING:
+ from gradio.components import Timer
+
+
+@document()
+@dataclasses.dataclass
+class WaveformOptions:
+ """
+ A dataclass for specifying options for the waveform display in the Audio component. An instance of this class can be passed into the `waveform_options` parameter of `gr.Audio`.
+ Parameters:
+ waveform_color: The color (as a hex string or valid CSS color) of the full waveform representing the amplitude of the audio. Defaults to a light gray color.
+ waveform_progress_color: The color (as a hex string or valid CSS color) that the waveform fills with to as the audio plays. Defaults to the accent color.
+ trim_region_color: The color (as a hex string or valid CSS color) of the trim region. Defaults to the accent color.
+ show_recording_waveform: If True, shows a waveform when recording audio or playing audio. If False, uses the default browser audio players. For streamed audio, the default browser audio player is always used.
+ skip_length: The percentage (between 0 and 100) of the audio to skip when clicking on the skip forward / skip backward buttons.
+ sample_rate: The output sample rate (in Hz) of the audio after editing.
+ """
+
+ waveform_color: str | None = None
+ waveform_progress_color: str | None = None
+ trim_region_color: str | None = None
+ show_recording_waveform: bool = True
+ skip_length: int | float = 5
+ sample_rate: int = 44100
+
+from gradio.events import Dependency
+
+@document()
+class Audio(
+ StreamingInput,
+ StreamingOutput,
+ Component,
+):
+ """
+ Creates an audio component that can be used to upload/record audio (as an input) or display audio (as an output).
+ Demos: generate_tone, reverse_audio
+ Guides: streaming-inputs, streaming-outputs, automatic-voice-detection, real-time-speech-recognition
+ """
+
+ EVENTS = [
+ Events.stream,
+ Events.change,
+ Events.clear,
+ Events.play,
+ Events.pause,
+ Events.stop,
+ Events.pause,
+ Events.start_recording,
+ Events.pause_recording,
+ Events.stop_recording,
+ Events.upload,
+ Events.input,
+ ]
+
+ data_model = FileData
+
+ def __init__(
+ self,
+ value: str | Path | tuple[int, np.ndarray] | Callable | None = None,
+ *,
+ sources: list[Literal["upload", "microphone"]]
+ | Literal["upload", "microphone"]
+ | None = None,
+ type: Literal["numpy", "filepath"] = "numpy",
+ label: str | I18nData | None = None,
+ every: Timer | float | None = None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ show_label: bool | None = None,
+ container: bool = True,
+ scale: int | None = None,
+ min_width: int = 160,
+ interactive: bool | None = None,
+ visible: bool | Literal["hidden"] = True,
+ streaming: bool = False,
+ elem_id: str | None = None,
+ elem_classes: list[str] | str | None = None,
+ render: bool = True,
+ key: int | str | tuple[int | str, ...] | None = None,
+ preserved_by_key: list[str] | str | None = "value",
+ format: Literal["wav", "mp3"] | None = None,
+ autoplay: bool = False,
+ editable: bool = True,
+ buttons: list[Literal["download", "share"] | Button] | None = None,
+ waveform_options: WaveformOptions | dict | None = None,
+ loop: bool = False,
+ recording: bool = False,
+ subtitles: str | Path | list[dict[str, Any]] | None = None,
+ playback_position: float = 0,
+ ):
+ """
+ Parameters:
+ value: A path, URL, or [sample_rate, numpy array] tuple (sample rate in Hz, audio data as a float or int numpy array) for the default value that Audio component is going to take. If a function is provided, the function will be called each time the app loads to set the initial value of this component.
+ sources: A list of sources permitted for audio. "upload" creates a box where user can drop an audio file, "microphone" creates a microphone input. The first element in the list will be used as the default source. If None, defaults to ["upload", "microphone"], or ["microphone"] if `streaming` is True.
+ type: The format the audio file is converted to before being passed into the prediction function. "numpy" converts the audio to a tuple consisting of: (int sample rate, numpy.array for the data), "filepath" passes a str path to a temporary file containing the audio.
+ label: the label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.
+ every: Continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ inputs: Components that are used as inputs to calculate `value` if `value` is a function (has no effect otherwise). `value` is recalculated any time the inputs change.
+ show_label: if True, will display label.
+ container: If True, will place the component in a container - providing some extra padding around the border.
+ scale: Relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
+ min_width: Minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
+ interactive: If True, will allow users to upload and edit an audio file. If False, can only be used to play audio. If not provided, this is inferred based on whether the component is used as an input or output.
+ visible: If False, component will be hidden. If "hidden", component will be visually hidden and not take up space in the layout but still exist in the DOM If "hidden", component will be visually hidden and not take up space in the layout but still exist in the DOM.
+ streaming: If set to True when used in a `live` interface as an input, will automatically stream webcam feed. When used set as an output, takes audio chunks yield from the backend and combines them into one streaming audio output.
+ elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+ elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
+ render: if False, component will not be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+ key: in a gr.render, Components with the same key across re-renders are treated as the same component, not a new component. Properties set in 'preserved_by_key' are not reset across a re-render.
+ preserved_by_key: A list of parameters from this component's constructor. Inside a gr.render() function, if a component is re-rendered with the same key, these (and only these) parameters will be preserved in the UI (if they have been changed by the user or an event listener) instead of re-rendered based on the values provided during constructor.
+ format: the file extension with which to save audio files. Either 'wav' or 'mp3'. wav files are lossless but will tend to be larger files. mp3 files tend to be smaller. This parameter applies both when this component is used as an input (and `type` is "filepath") to determine which file format to convert user-provided audio to, and when this component is used as an output to determine the format of audio returned to the user. If None, no file format conversion is done and the audio is kept as is. In the case where output audio is returned from the prediction function as numpy array and no `format` is provided, it will be returned as a "wav" file.
+ autoplay: Whether to automatically play the audio when the component is used as an output. Note: browsers will not autoplay audio files if the user has not interacted with the page yet.
+ buttons: A list of buttons to show in the top right corner of the component. Valid options are "download", "share", or a gr.Button() instance. The "download" button allows the user to save the audio to their device. The "share" button allows the user to share the audio via Hugging Face Spaces Discussions. Custom gr.Button() instances will appear in the toolbar with their configured icon and/or label, and clicking them will trigger any .click() events registered on the button. By default, only the "download" and "share" buttons are shown.
+ editable: If True, allows users to manipulate the audio file if the component is interactive. Defaults to True.
+ waveform_options: A dictionary of options for the waveform display. Options include: waveform_color (str), waveform_progress_color (str), skip_length (int), trim_region_color (str). Default is None, which uses the default values for these options. [See `gr.WaveformOptions` docs](#waveform-options).
+ loop: If True, the audio will loop when it reaches the end and continue playing from the beginning.
+ recording: If True, the audio component will be set to record audio from the microphone if the source is set to "microphone". Defaults to False.
+ subtitles: A subtitle file (srt, vtt, or json) for the audio, or a list of subtitle dictionaries in the format [{"text": str, "timestamp": [start, end]}] where timestamps are in seconds. JSON files should contain an array of subtitle objects.
+ playback_position: The starting playback position in seconds. This value is also updated as the audio plays, reflecting the current playback position.
+ """
+ valid_sources: list[Literal["upload", "microphone"]] = ["upload", "microphone"]
+ if sources is None:
+ self.sources = ["microphone"] if streaming else valid_sources
+ elif isinstance(sources, str) and sources in valid_sources:
+ self.sources = [sources]
+ elif isinstance(sources, list):
+ self.sources = sources
+ else:
+ raise ValueError(
+ f"`sources` must be a list consisting of elements in {valid_sources}"
+ )
+ for source in self.sources:
+ if source not in valid_sources:
+ raise ValueError(
+ f"`sources` must a list consisting of elements in {valid_sources}"
+ )
+ valid_types = ["numpy", "filepath"]
+ if type not in valid_types:
+ raise ValueError(
+ f"Invalid value for parameter `type`: {type}. Please choose from one of: {' '.join(valid_types)}"
+ )
+ self.type = type
+ self.streaming = streaming
+ if self.streaming and "microphone" not in self.sources:
+ raise ValueError(
+ "Audio streaming only available if sources includes 'microphone'."
+ )
+ valid_formats = ["wav", "mp3"]
+ if format is not None and format.lower() not in valid_formats:
+ raise ValueError(
+ f"Invalid value for parameter `format`: {format}. Please choose from one of: {' '.join(valid_formats)}"
+ )
+ self.format = format and format.lower()
+ self.autoplay = autoplay
+ self.loop = loop
+ self.buttons = set_default_buttons(buttons, ["download", "share"])
+ self.editable = editable
+ if waveform_options is None:
+ self.waveform_options = WaveformOptions()
+ elif isinstance(waveform_options, dict):
+ self.waveform_options = WaveformOptions(**waveform_options) # type: ignore
+ else:
+ self.waveform_options = waveform_options
+ self.recording = recording
+ self.playback_position = playback_position
+ super().__init__(
+ label=label,
+ every=every,
+ inputs=inputs,
+ show_label=show_label,
+ container=container,
+ scale=scale,
+ min_width=min_width,
+ interactive=interactive,
+ visible=visible,
+ elem_id=elem_id,
+ elem_classes=elem_classes,
+ render=render,
+ key=key,
+ preserved_by_key=preserved_by_key,
+ value=value,
+ )
+ self._value_description = (
+ "a filepath to an audio file"
+ if self.type == "filepath"
+ else "a tuple of [sample_rate: int, data: np.ndarray] of audio data"
+ )
+ self.subtitles = None
+ if subtitles is not None:
+ if isinstance(subtitles, list):
+ self.subtitles = self._process_json_subtitles(subtitles)
+ else:
+ self.subtitles = self._process_subtitle_file(subtitles)
+
+ def example_payload(self) -> Any:
+ return handle_file(
+ "https://github.com/gradio-app/gradio/raw/main/test/test_files/audio_sample.wav"
+ )
+
+ def example_value(self) -> Any:
+ return "https://github.com/gradio-app/gradio/raw/main/test/test_files/audio_sample.wav"
+
+ def preprocess(
+ self, payload: FileData | None
+ ) -> str | tuple[int, np.ndarray] | None:
+ """
+ Parameters:
+ payload: audio data as a FileData object, or None.
+ Returns:
+ Passes audio as one of these formats (depending on `type`):
+ - `str` filepath
+ - `tuple` of (sample rate in Hz, audio data as numpy array).
+ -- The audio data is a 16-bit `int` array whose values range from -32768 to 32767 and shape of the audio data array is (samples,) for mono audio or (samples, channels) for multi-channel audio.
+ """
+ if payload is None:
+ return payload
+
+ if not payload.path:
+ raise ValueError("payload path missing")
+
+ needs_conversion = False
+ original_suffix = Path(payload.path).suffix.lower()
+ if self.format is not None and original_suffix != f".{self.format}":
+ needs_conversion = True
+ if self.type == "numpy":
+ return processing_utils.audio_from_file(payload.path)
+ elif self.type == "filepath":
+ if not needs_conversion:
+ return payload.path
+ sample_rate, data = processing_utils.audio_from_file(payload.path)
+ output_file = str(Path(payload.path).with_suffix(f".{self.format}"))
+ assert self.format is not None # noqa: S101
+ processing_utils.audio_to_file(
+ sample_rate, data, output_file, format=self.format
+ )
+ return output_file
+ else:
+ raise ValueError(
+ "Unknown type: "
+ + str(self.type)
+ + ". Please choose from: 'numpy', 'filepath'."
+ )
+
+ def postprocess(
+ self, value: str | Path | bytes | tuple[int, np.ndarray] | None
+ ) -> FileData | bytes | None:
+ """
+ Parameters:
+ value: Expects audio data in any of these formats:
+ - `str`
+ - `pathlib.Path` filepath
+ - URL to an audio file
+ - `bytes` object (recommended for streaming)
+ - `tuple` of (sample rate in Hz, audio data as numpy array).
+ -- Note: if audio is supplied as a numpy array, the audio will be normalized by its peak value to avoid distortion or clipping in the resulting audio.
+ Returns:
+ FileData object, bytes, or None.
+ """
+ orig_name = None
+ if value is None:
+ return None
+
+ if isinstance(value, bytes):
+ if self.streaming:
+ return value
+ file_path = processing_utils.save_bytes_to_cache(
+ value, "audio", cache_dir=self.GRADIO_CACHE
+ )
+ orig_name = Path(file_path).name
+ elif isinstance(value, tuple):
+ sample_rate, data = value
+ file_path = processing_utils.save_audio_to_cache(
+ data,
+ sample_rate,
+ format=self.format or "wav",
+ cache_dir=self.GRADIO_CACHE,
+ )
+ orig_name = Path(file_path).name
+ elif isinstance(value, (str, Path)):
+ if client_utils.is_http_url_like(value):
+ original_suffix = Path(httpx.URL(str(value)).path).suffix.lower()
+ else:
+ original_suffix = Path(value).suffix.lower()
+ if self.format is not None and original_suffix != f".{self.format}":
+ sample_rate, data = processing_utils.audio_from_file(str(value))
+ file_path = processing_utils.save_audio_to_cache(
+ data, sample_rate, format=self.format, cache_dir=self.GRADIO_CACHE
+ )
+ else:
+ file_path = str(value)
+ orig_name = Path(file_path).name if Path(file_path).exists() else None
+ else:
+ raise ValueError(f"Cannot process {value} as Audio")
+ return FileData(path=file_path, orig_name=orig_name)
+
+ @staticmethod
+ def _convert_to_adts(data: bytes):
+ segment = AudioSegment.from_file(io.BytesIO(data))
+
+ buffer = io.BytesIO()
+ segment.export(buffer, format="adts") # ADTS is a container format for AAC
+ aac_data = buffer.getvalue()
+ return aac_data, len(segment) / 1000.0
+
+ @staticmethod
+ async def covert_to_adts(data: bytes) -> tuple[bytes, float]:
+ return await anyio.to_thread.run_sync(Audio._convert_to_adts, data)
+
+ async def stream_output(
+ self,
+ value,
+ output_id: str,
+ first_chunk: bool, # noqa: ARG002
+ ) -> tuple[MediaStreamChunk | None, FileDataDict]:
+ output_file: FileDataDict = {
+ "path": output_id,
+ "is_stream": True,
+ "orig_name": "audio-stream.mp3",
+ "meta": {"_type": "gradio.FileData"},
+ }
+ if value is None:
+ return None, output_file
+ if isinstance(value, bytes):
+ value, duration = await self.covert_to_adts(value)
+ return {
+ "data": value,
+ "duration": duration,
+ "extension": ".aac",
+ }, output_file
+ if client_utils.is_http_url_like(value["path"]):
+ response = httpx.get(value["path"])
+ binary_data = response.content
+ else:
+ output_file["orig_name"] = value["orig_name"]
+ file_path = value["path"]
+ with open(file_path, "rb") as f:
+ binary_data = f.read()
+ value, duration = await self.covert_to_adts(binary_data)
+ return {"data": value, "duration": duration, "extension": ".aac"}, output_file
+
+ async def combine_stream(
+ self,
+ stream: list[bytes],
+ desired_output_format: str | None = None,
+ only_file=False, # noqa: ARG002
+ ) -> FileData:
+ output_file = FileData(
+ path=processing_utils.save_bytes_to_cache(
+ b"".join(stream), "audio.mp3", cache_dir=self.GRADIO_CACHE
+ ),
+ is_stream=False,
+ orig_name="audio-stream.mp3",
+ )
+ if desired_output_format and desired_output_format != "mp3":
+ new_path = Path(output_file.path).with_suffix(f".{desired_output_format}")
+ AudioSegment.from_file(output_file.path).export(
+ new_path, format=desired_output_format
+ )
+ output_file.path = str(new_path)
+ return output_file
+
+ def _process_json_subtitles(
+ self, subtitles: list[dict[str, Any]]
+ ) -> list[dict[str, Any]]:
+ for i, subtitle in enumerate(subtitles):
+ if not isinstance(subtitle, dict):
+ raise ValueError(f"Subtitle at index {i} must be a dictionary")
+ if "text" not in subtitle:
+ raise ValueError(f"Subtitle at index {i} missing required 'text' field")
+ if "timestamp" not in subtitle:
+ raise ValueError(
+ f"Subtitle at index {i} missing required 'timestamp' field"
+ )
+ if (
+ not isinstance(subtitle["timestamp"], (list, tuple))
+ or len(subtitle["timestamp"]) != 2
+ ):
+ raise ValueError(
+ f"Subtitle at index {i} 'timestamp' must be a list/tuple of [start, end]"
+ )
+ return [
+ {
+ "start": subtitle["timestamp"][0],
+ "end": subtitle["timestamp"][1],
+ "text": subtitle["text"],
+ }
+ for subtitle in subtitles
+ ]
+
+ def _process_subtitle_file(
+ self, subtitle_file: str | Path
+ ) -> FileData | list[dict[str, Any]]:
+ file_path = Path(subtitle_file)
+ if file_path.suffix.lower() == ".json":
+ try:
+ with open(file_path, encoding="utf-8") as f:
+ json_data = json.load(f)
+ if isinstance(json_data, list):
+ return self._process_json_subtitles(json_data)
+ else:
+ raise ValueError(
+ "JSON subtitle file must contain a list of subtitle objects"
+ ) from None
+
+ except json.JSONDecodeError as e:
+ raise ValueError(f"Invalid JSON format in subtitle file: {e}") from e
+ except Exception as e:
+ raise ValueError(f"Error reading JSON subtitle file: {e}") from e
+ return handle_file(subtitle_file)
+
+ def process_example(
+ self, value: tuple[int, np.ndarray] | str | Path | bytes | None
+ ) -> str:
+ if value is None:
+ return ""
+ elif isinstance(value, (str, Path)):
+ return Path(value).name
+ return "(audio)"
+
+ def check_streamable(self):
+ if (
+ self.sources is not None
+ and "microphone" not in self.sources
+ and self.streaming
+ ):
+ raise ValueError(
+ "Audio streaming only available if source includes 'microphone'."
+ )
+ from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+ from gradio.blocks import Block
+ if TYPE_CHECKING:
+ from gradio.components import Timer
+ from gradio.components.base import Component
+
+
+ def stream(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ stream_every: float = 0.5,
+
+ time_limit: float | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ stream_every: The latency (in seconds) at which stream chunks are sent to the backend. Defaults to 0.5 seconds. Parameter only used for the `.stream()` event.,
+
+ time_limit: The time limit for the function to run. Parameter only used for the `.stream()` event.,
+
+ """
+ ...
+
+ def change(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def clear(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def play(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def pause(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def stop(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def pause(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def start_recording(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def pause_recording(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def stop_recording(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def upload(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
+
+ def input(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/gradio/components/base.py b/lib/python3.11/site-packages/gradio/components/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..b59487d37e37553ee0d4b4031a70e97605418448
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/base.py
@@ -0,0 +1,452 @@
+"""Contains all of the components that can be used with Gradio Interface / Blocks.
+Along with the docs for each component, you can find the names of example demos that use
+each component. These demos are located in the `demo` directory."""
+
+from __future__ import annotations
+
+import abc
+import json
+import warnings
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Sequence
+from enum import Enum
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+import gradio_client.utils as client_utils
+
+from gradio import utils
+from gradio.blocks import Block
+from gradio.component_meta import ComponentMeta
+from gradio.data_classes import (
+ BaseModel,
+ DeveloperPath,
+ FileData,
+ FileDataDict,
+ GradioDataModel,
+ MediaStreamChunk,
+)
+from gradio.events import EventListener
+from gradio.i18n import I18nData
+from gradio.layouts import Form
+from gradio.processing_utils import move_files_to_cache
+
+if TYPE_CHECKING:
+ from typing import TypedDict
+
+ class DataframeData(TypedDict):
+ headers: list[str]
+ data: list[list[str | int | bool]]
+
+ from gradio.components import Timer
+
+
+class _Keywords(Enum):
+ NO_VALUE = "NO_VALUE" # Used as a sentinel to determine if nothing is provided as a argument for `value` in `Component.update()`
+ FINISHED_ITERATING = "FINISHED_ITERATING" # Used to skip processing of a component's value (needed for generators + state)
+
+
+class ComponentBase(ABC, metaclass=ComponentMeta):
+ EVENTS: list[EventListener | str] = []
+
+ @abstractmethod
+ def preprocess(self, payload: Any) -> Any:
+ """
+ Any preprocessing needed to be performed on function input.
+ Parameters:
+ payload: The input data received by the component from the frontend.
+ Returns:
+ The preprocessed input data sent to the user's function in the backend.
+ """
+ return payload
+
+ @abstractmethod
+ def postprocess(self, value):
+ """
+ Any postprocessing needed to be performed on function output.
+ Parameters:
+ value: The output data received by the component from the user's function in the backend.
+ Returns:
+ The postprocessed output data sent to the frontend.
+ """
+ return value
+
+ @abstractmethod
+ def process_example(self, value):
+ """
+ Process the input data in a way that can be displayed by the examples dataset component in the front-end.
+
+ For example, only return the name of a file as opposed to a full path. Or get the head of a dataframe.
+ The return value must be able to be json-serializable to put in the config.
+ """
+ pass
+
+ @abstractmethod
+ def api_info(self) -> dict[str, list[str]]:
+ """
+ The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
+ Keys of the dictionary are: raw_input, raw_output, serialized_input, serialized_output
+ """
+ pass
+
+ @abstractmethod
+ def example_inputs(self) -> Any:
+ """
+ Deprecated and replaced by `example_payload()` and `example_value()`.
+ """
+ pass
+
+ @abstractmethod
+ def flag(self, payload: Any | GradioDataModel, flag_dir: str | Path = "") -> str:
+ """
+ Write the component's value to a format that can be stored in a csv or jsonl format for flagging.
+ """
+ pass
+
+ @abstractmethod
+ def read_from_flag(self, payload: Any) -> GradioDataModel | Any:
+ """
+ Convert the data from the csv or jsonl file into the component state.
+ """
+ return payload
+
+ @property
+ @abstractmethod
+ def skip_api(self) -> bool:
+ """Whether this component should be skipped from the api return value"""
+
+ @classmethod
+ def has_event(cls, event: str | EventListener) -> bool:
+ return event in cls.EVENTS
+
+
+def server(fn):
+ fn._is_server_fn = True
+ return fn
+
+
+class Component(ComponentBase, Block):
+ """
+ A base class for defining methods that all input/output components should have.
+ """
+
+ def __init__(
+ self,
+ value: Any = None,
+ *,
+ label: str | I18nData | None = None,
+ info: str | I18nData | None = None,
+ show_label: bool | None = None,
+ container: bool = True,
+ scale: int | None = None,
+ min_width: int | None = None,
+ interactive: bool | None = None,
+ visible: bool | Literal["hidden"] = True,
+ elem_id: str | None = None,
+ elem_classes: list[str] | str | None = None,
+ render: bool = True,
+ key: int | str | tuple[int | str, ...] | None = None,
+ preserved_by_key: list[str] | str | None = "value",
+ load_fn: Callable | None = None,
+ every: Timer | float | None = None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ ):
+ self._api_info_cache = None
+ self.server_fns = [
+ getattr(self, value)
+ for value in dir(self.__class__)
+ if callable(getattr(self, value))
+ and getattr(getattr(self, value), "_is_server_fn", False)
+ ]
+
+ # This gets overridden when `select` is called
+ self._selectable = False
+ if not hasattr(self, "data_model"):
+ self.data_model: type[GradioDataModel] | None = None
+
+ Block.__init__(
+ self,
+ elem_id=elem_id,
+ elem_classes=elem_classes,
+ visible=visible,
+ render=render,
+ key=key,
+ preserved_by_key=preserved_by_key,
+ )
+ if isinstance(self, StreamingInput):
+ self.check_streamable()
+
+ self.label = label
+ self.info = info
+ if not container:
+ if show_label:
+ warnings.warn("show_label has no effect when container is False.")
+ show_label = False
+ if show_label is None:
+ show_label = True
+ self.show_label = show_label
+ self.container = container
+ if scale is not None and scale != round(scale):
+ warnings.warn(
+ f"'scale' value should be an integer. Using {scale} will cause issues."
+ )
+ self.scale = scale
+ self.min_width = min_width
+ self.interactive = interactive
+
+ # load_event is set in the Blocks.attach_load_events method
+ self.load_event: None | dict[str, Any] = None
+ self.load_event_to_attach: (
+ None
+ | tuple[
+ Callable,
+ list[tuple[Block, str]],
+ Component | Sequence[Component] | set[Component] | None,
+ ]
+ ) = None
+ load_fn, initial_value = self.get_load_fn_and_initial_value(value, inputs)
+ initial_value = self.postprocess(initial_value)
+ # Serialize the json value so that it gets stored in the
+ # config as plain json, for images/audio etc. `move_files_to_cache`
+ # will call model_dump
+ if isinstance(initial_value, BaseModel):
+ initial_value = initial_value.model_dump()
+ self.value = move_files_to_cache(
+ initial_value,
+ self, # type: ignore
+ postprocess=True,
+ keep_in_cache=True,
+ )
+ if client_utils.is_file_obj(self.value):
+ self.keep_in_cache.add(self.value["path"])
+
+ if callable(load_fn):
+ self.attach_load_event(load_fn, every, inputs)
+
+ TEMPLATE_DIR = DeveloperPath("./templates/")
+ FRONTEND_DIR = "../../frontend/"
+
+ def get_config(self, cls: type[Block] | None = None) -> dict[str, Any]:
+ config = super().get_config(cls)
+ if self.info:
+ config["info"] = self.info
+ if len(self.server_fns):
+ config["server_fns"] = [fn.__name__ for fn in self.server_fns]
+ config.pop("render", None)
+ return config
+
+ @property
+ def skip_api(self):
+ return False
+
+ @staticmethod
+ def get_load_fn_and_initial_value(value, inputs=None):
+ initial_value = None
+ if callable(value):
+ if not inputs:
+ initial_value = value()
+ load_fn = value
+ else:
+ initial_value = value
+ load_fn = None
+ return load_fn, initial_value
+
+ def attach_load_event(
+ self,
+ callable: Callable,
+ every: Timer | float | None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ ):
+ """Add an event that runs `callable`, optionally at interval specified by `every`."""
+ if isinstance(inputs, Component):
+ inputs = [inputs]
+ changeable_events: list[tuple[Block, str]] = (
+ [(i, "change") for i in inputs if hasattr(i, "change")] if inputs else []
+ )
+ if isinstance(every, (int, float)):
+ from gradio.components import Timer
+
+ every = Timer(every)
+ if every:
+ changeable_events.append((every, "tick"))
+ self.load_event_to_attach = (
+ callable,
+ changeable_events,
+ inputs,
+ )
+
+ def process_example(self, value):
+ """
+ Process the input data in a way that can be displayed by the examples dataset component in the front-end.
+ By default, this calls the `.postprocess()` method of the component. However, if the `.postprocess()` method is
+ computationally intensive, or returns a large payload, a custom implementation may be appropriate.
+
+ For example, the `process_example()` method of the `gr.Audio()` component only returns the name of the file, not
+ the processed audio file. The `.process_example()` method of the `gr.Dataframe()` returns the head of a dataframe
+ instead of the full dataframe.
+
+ The return value of this method must be json-serializable to put in the config.
+ """
+ return self.postprocess(value)
+
+ def as_example(self, value):
+ """Deprecated and replaced by `process_example()`."""
+ return self.process_example(value)
+
+ def example_inputs(self) -> Any:
+ """Deprecated and replaced by `example_payload()` and `example_value()`."""
+ return self.example_payload()
+
+ def example_payload(self) -> Any:
+ """
+ An example input data for this component, e.g. what is passed to this component's preprocess() method.
+ This is used to generate the docs for the View API page for Gradio apps using this component.
+ """
+ raise NotImplementedError()
+
+ def example_value(self) -> Any:
+ """
+ An example output data for this component, e.g. what is passed to this component's postprocess() method.
+ This is used to generate an example value if this component is used as a template for a custom component.
+ """
+ raise NotImplementedError()
+
+ def api_info(self) -> dict[str, Any]:
+ """
+ The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
+ Keys of the dictionary are: raw_input, raw_output, serialized_input, serialized_output
+ """
+ if self._api_info_cache is not None:
+ return self._api_info_cache
+ if self.data_model is not None:
+ schema = self.data_model.model_json_schema()
+ desc = schema.pop("description", None)
+ schema["additional_description"] = desc
+ self._api_info_cache = schema
+ return schema
+ raise NotImplementedError(
+ f"The api_info method has not been implemented for {self.get_block_name()}"
+ )
+
+ def api_info_as_input(self) -> dict[str, Any]:
+ return self.api_info()
+
+ def api_info_as_output(self) -> dict[str, Any]:
+ return self.api_info()
+
+ def flag(self, payload: Any, flag_dir: str | Path = "") -> str:
+ """
+ Write the component's value to a format that can be stored in a csv or jsonl format for flagging.
+ """
+ if self.data_model:
+ payload = self.data_model.from_json(payload)
+ Path(flag_dir).mkdir(exist_ok=True)
+ payload = payload.copy_to_dir(flag_dir).model_dump()
+ if isinstance(payload, BaseModel):
+ payload = payload.model_dump()
+ if not isinstance(payload, str):
+ payload = json.dumps(payload)
+ return payload
+
+ def read_from_flag(self, payload: Any):
+ """
+ Convert the data from the csv or jsonl file into the component state.
+ """
+ if self.data_model:
+ return self.data_model.from_json(json.loads(payload))
+ return payload
+
+
+class FormComponent(Component):
+ """
+ A base class for components that are typically used in forms (e.g. Textbox, Dropdown). These
+ components will be grouped together in the UI to provide a more condensed layout. Components
+ that are not rendered in the UI (e.g. State) should also inherit from this class, as it will
+ prevent them from breaking the grouping, see: https://github.com/gradio-app/gradio/issues/10330
+ """
+
+ def get_expected_parent(self) -> type[Form] | None:
+ if getattr(self, "container", None) is False:
+ return None
+ return Form
+
+ def preprocess(self, payload: Any) -> Any:
+ return payload
+
+
+class StreamingOutput(metaclass=abc.ABCMeta):
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.streaming: bool
+
+ @abc.abstractmethod
+ async def stream_output(
+ self, value, output_id: str, first_chunk: bool
+ ) -> tuple[MediaStreamChunk | None, FileDataDict | dict]:
+ pass
+
+ @abc.abstractmethod
+ async def combine_stream(
+ self,
+ stream: list[bytes],
+ desired_output_format: str | None = None,
+ only_file=False,
+ ) -> GradioDataModel | FileData:
+ """Combine all of the stream chunks into a single file.
+
+ This is needed for downloading the stream and for caching examples.
+ If `only_file` is True, only the FileData corresponding to the file should be returned (needed for downloading the stream).
+ The desired_output_format optionally converts the combined file. Should only be used for cached examples.
+ """
+ pass
+
+
+class StreamingInput(metaclass=abc.ABCMeta):
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+
+ @abc.abstractmethod
+ def check_streamable(self):
+ """Used to check if streaming is supported given the input."""
+ pass
+
+
+def component(cls_name: str, render: bool) -> Component:
+ obj = utils.component_or_layout_class(cls_name)(render=render)
+ if not isinstance(obj, Component):
+ raise TypeError(f"Expected a Component instance, but got {obj.__class__}")
+ return obj
+
+
+def get_component_instance(
+ comp: str | dict | Component, render: bool = False, unrender: bool = False
+) -> Component:
+ """
+ Returns a component instance from a string, dict, or Component object.
+ Parameters:
+ comp: the component to instantiate. If a string, must be the name of a component, e.g. "dropdown". If a dict, must have a "name" key, e.g. {"name": "dropdown", "choices": ["a", "b"]}. If a Component object, will be returned as is.
+ render: whether to render the component. If True, renders the component (if not already rendered). If False, does not do anything.
+ unrender: whether to unrender the component. If True, unrenders the the component (if already rendered) -- this is useful when constructing an Interface or ChatInterface inside of a Blocks. If False, does not do anything.
+ """
+ if isinstance(comp, str):
+ component_obj = component(comp, render=render)
+ elif isinstance(comp, dict):
+ name = comp.pop("name") # type: ignore
+ component_cls = utils.component_or_layout_class(name)
+ component_obj = component_cls(**comp, render=render) # type: ignore
+ elif isinstance(comp, Component):
+ component_obj = comp
+ else:
+ raise ValueError(
+ f"Component must be provided as a `str` or `dict` or `Component` but is {comp}"
+ )
+
+ if render and not component_obj.is_rendered:
+ component_obj.render()
+ elif unrender and component_obj.is_rendered:
+ component_obj.unrender()
+ if not isinstance(component_obj, Component):
+ raise TypeError(
+ f"Expected a Component instance, but got {component_obj.__class__}"
+ )
+ return component_obj
diff --git a/lib/python3.11/site-packages/gradio/components/base.pyi b/lib/python3.11/site-packages/gradio/components/base.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..d700cd608a00ece06a4e5ea8d3633202065bb15e
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/base.pyi
@@ -0,0 +1,468 @@
+"""Contains all of the components that can be used with Gradio Interface / Blocks.
+Along with the docs for each component, you can find the names of example demos that use
+each component. These demos are located in the `demo` directory."""
+
+from __future__ import annotations
+
+import abc
+import json
+import warnings
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Sequence
+from enum import Enum
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+import gradio_client.utils as client_utils
+
+from gradio import utils
+from gradio.blocks import Block
+from gradio.component_meta import ComponentMeta
+from gradio.data_classes import (
+ BaseModel,
+ DeveloperPath,
+ FileData,
+ FileDataDict,
+ GradioDataModel,
+ MediaStreamChunk,
+)
+from gradio.events import EventListener
+from gradio.i18n import I18nData
+from gradio.layouts import Form
+from gradio.processing_utils import move_files_to_cache
+
+if TYPE_CHECKING:
+ from typing import TypedDict
+
+ class DataframeData(TypedDict):
+ headers: list[str]
+ data: list[list[str | int | bool]]
+
+ from gradio.components import Timer
+
+
+class _Keywords(Enum):
+ NO_VALUE = "NO_VALUE" # Used as a sentinel to determine if nothing is provided as a argument for `value` in `Component.update()`
+ FINISHED_ITERATING = "FINISHED_ITERATING" # Used to skip processing of a component's value (needed for generators + state)
+
+from gradio.events import Dependency
+
+class ComponentBase(ABC, metaclass=ComponentMeta):
+ EVENTS: list[EventListener | str] = []
+
+ @abstractmethod
+ def preprocess(self, payload: Any) -> Any:
+ """
+ Any preprocessing needed to be performed on function input.
+ Parameters:
+ payload: The input data received by the component from the frontend.
+ Returns:
+ The preprocessed input data sent to the user's function in the backend.
+ """
+ return payload
+
+ @abstractmethod
+ def postprocess(self, value):
+ """
+ Any postprocessing needed to be performed on function output.
+ Parameters:
+ value: The output data received by the component from the user's function in the backend.
+ Returns:
+ The postprocessed output data sent to the frontend.
+ """
+ return value
+
+ @abstractmethod
+ def process_example(self, value):
+ """
+ Process the input data in a way that can be displayed by the examples dataset component in the front-end.
+
+ For example, only return the name of a file as opposed to a full path. Or get the head of a dataframe.
+ The return value must be able to be json-serializable to put in the config.
+ """
+ pass
+
+ @abstractmethod
+ def api_info(self) -> dict[str, list[str]]:
+ """
+ The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
+ Keys of the dictionary are: raw_input, raw_output, serialized_input, serialized_output
+ """
+ pass
+
+ @abstractmethod
+ def example_inputs(self) -> Any:
+ """
+ Deprecated and replaced by `example_payload()` and `example_value()`.
+ """
+ pass
+
+ @abstractmethod
+ def flag(self, payload: Any | GradioDataModel, flag_dir: str | Path = "") -> str:
+ """
+ Write the component's value to a format that can be stored in a csv or jsonl format for flagging.
+ """
+ pass
+
+ @abstractmethod
+ def read_from_flag(self, payload: Any) -> GradioDataModel | Any:
+ """
+ Convert the data from the csv or jsonl file into the component state.
+ """
+ return payload
+
+ @property
+ @abstractmethod
+ def skip_api(self) -> bool:
+ """Whether this component should be skipped from the api return value"""
+
+ @classmethod
+ def has_event(cls, event: str | EventListener) -> bool:
+ return event in cls.EVENTS
+ from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+ from gradio.blocks import Block
+ if TYPE_CHECKING:
+ from gradio.components import Timer
+ from gradio.components.base import Component
+
+
+def server(fn):
+ fn._is_server_fn = True
+ return fn
+
+
+class Component(ComponentBase, Block):
+ """
+ A base class for defining methods that all input/output components should have.
+ """
+
+ def __init__(
+ self,
+ value: Any = None,
+ *,
+ label: str | I18nData | None = None,
+ info: str | I18nData | None = None,
+ show_label: bool | None = None,
+ container: bool = True,
+ scale: int | None = None,
+ min_width: int | None = None,
+ interactive: bool | None = None,
+ visible: bool | Literal["hidden"] = True,
+ elem_id: str | None = None,
+ elem_classes: list[str] | str | None = None,
+ render: bool = True,
+ key: int | str | tuple[int | str, ...] | None = None,
+ preserved_by_key: list[str] | str | None = "value",
+ load_fn: Callable | None = None,
+ every: Timer | float | None = None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ ):
+ self._api_info_cache = None
+ self.server_fns = [
+ getattr(self, value)
+ for value in dir(self.__class__)
+ if callable(getattr(self, value))
+ and getattr(getattr(self, value), "_is_server_fn", False)
+ ]
+
+ # This gets overridden when `select` is called
+ self._selectable = False
+ if not hasattr(self, "data_model"):
+ self.data_model: type[GradioDataModel] | None = None
+
+ Block.__init__(
+ self,
+ elem_id=elem_id,
+ elem_classes=elem_classes,
+ visible=visible,
+ render=render,
+ key=key,
+ preserved_by_key=preserved_by_key,
+ )
+ if isinstance(self, StreamingInput):
+ self.check_streamable()
+
+ self.label = label
+ self.info = info
+ if not container:
+ if show_label:
+ warnings.warn("show_label has no effect when container is False.")
+ show_label = False
+ if show_label is None:
+ show_label = True
+ self.show_label = show_label
+ self.container = container
+ if scale is not None and scale != round(scale):
+ warnings.warn(
+ f"'scale' value should be an integer. Using {scale} will cause issues."
+ )
+ self.scale = scale
+ self.min_width = min_width
+ self.interactive = interactive
+
+ # load_event is set in the Blocks.attach_load_events method
+ self.load_event: None | dict[str, Any] = None
+ self.load_event_to_attach: (
+ None
+ | tuple[
+ Callable,
+ list[tuple[Block, str]],
+ Component | Sequence[Component] | set[Component] | None,
+ ]
+ ) = None
+ load_fn, initial_value = self.get_load_fn_and_initial_value(value, inputs)
+ initial_value = self.postprocess(initial_value)
+ # Serialize the json value so that it gets stored in the
+ # config as plain json, for images/audio etc. `move_files_to_cache`
+ # will call model_dump
+ if isinstance(initial_value, BaseModel):
+ initial_value = initial_value.model_dump()
+ self.value = move_files_to_cache(
+ initial_value,
+ self, # type: ignore
+ postprocess=True,
+ keep_in_cache=True,
+ )
+ if client_utils.is_file_obj(self.value):
+ self.keep_in_cache.add(self.value["path"])
+
+ if callable(load_fn):
+ self.attach_load_event(load_fn, every, inputs)
+
+ TEMPLATE_DIR = DeveloperPath("./templates/")
+ FRONTEND_DIR = "../../frontend/"
+
+ def get_config(self, cls: type[Block] | None = None) -> dict[str, Any]:
+ config = super().get_config(cls)
+ if self.info:
+ config["info"] = self.info
+ if len(self.server_fns):
+ config["server_fns"] = [fn.__name__ for fn in self.server_fns]
+ config.pop("render", None)
+ return config
+
+ @property
+ def skip_api(self):
+ return False
+
+ @staticmethod
+ def get_load_fn_and_initial_value(value, inputs=None):
+ initial_value = None
+ if callable(value):
+ if not inputs:
+ initial_value = value()
+ load_fn = value
+ else:
+ initial_value = value
+ load_fn = None
+ return load_fn, initial_value
+
+ def attach_load_event(
+ self,
+ callable: Callable,
+ every: Timer | float | None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ ):
+ """Add an event that runs `callable`, optionally at interval specified by `every`."""
+ if isinstance(inputs, Component):
+ inputs = [inputs]
+ changeable_events: list[tuple[Block, str]] = (
+ [(i, "change") for i in inputs if hasattr(i, "change")] if inputs else []
+ )
+ if isinstance(every, (int, float)):
+ from gradio.components import Timer
+
+ every = Timer(every)
+ if every:
+ changeable_events.append((every, "tick"))
+ self.load_event_to_attach = (
+ callable,
+ changeable_events,
+ inputs,
+ )
+
+ def process_example(self, value):
+ """
+ Process the input data in a way that can be displayed by the examples dataset component in the front-end.
+ By default, this calls the `.postprocess()` method of the component. However, if the `.postprocess()` method is
+ computationally intensive, or returns a large payload, a custom implementation may be appropriate.
+
+ For example, the `process_example()` method of the `gr.Audio()` component only returns the name of the file, not
+ the processed audio file. The `.process_example()` method of the `gr.Dataframe()` returns the head of a dataframe
+ instead of the full dataframe.
+
+ The return value of this method must be json-serializable to put in the config.
+ """
+ return self.postprocess(value)
+
+ def as_example(self, value):
+ """Deprecated and replaced by `process_example()`."""
+ return self.process_example(value)
+
+ def example_inputs(self) -> Any:
+ """Deprecated and replaced by `example_payload()` and `example_value()`."""
+ return self.example_payload()
+
+ def example_payload(self) -> Any:
+ """
+ An example input data for this component, e.g. what is passed to this component's preprocess() method.
+ This is used to generate the docs for the View API page for Gradio apps using this component.
+ """
+ raise NotImplementedError()
+
+ def example_value(self) -> Any:
+ """
+ An example output data for this component, e.g. what is passed to this component's postprocess() method.
+ This is used to generate an example value if this component is used as a template for a custom component.
+ """
+ raise NotImplementedError()
+
+ def api_info(self) -> dict[str, Any]:
+ """
+ The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
+ Keys of the dictionary are: raw_input, raw_output, serialized_input, serialized_output
+ """
+ if self._api_info_cache is not None:
+ return self._api_info_cache
+ if self.data_model is not None:
+ schema = self.data_model.model_json_schema()
+ desc = schema.pop("description", None)
+ schema["additional_description"] = desc
+ self._api_info_cache = schema
+ return schema
+ raise NotImplementedError(
+ f"The api_info method has not been implemented for {self.get_block_name()}"
+ )
+
+ def api_info_as_input(self) -> dict[str, Any]:
+ return self.api_info()
+
+ def api_info_as_output(self) -> dict[str, Any]:
+ return self.api_info()
+
+ def flag(self, payload: Any, flag_dir: str | Path = "") -> str:
+ """
+ Write the component's value to a format that can be stored in a csv or jsonl format for flagging.
+ """
+ if self.data_model:
+ payload = self.data_model.from_json(payload)
+ Path(flag_dir).mkdir(exist_ok=True)
+ payload = payload.copy_to_dir(flag_dir).model_dump()
+ if isinstance(payload, BaseModel):
+ payload = payload.model_dump()
+ if not isinstance(payload, str):
+ payload = json.dumps(payload)
+ return payload
+
+ def read_from_flag(self, payload: Any):
+ """
+ Convert the data from the csv or jsonl file into the component state.
+ """
+ if self.data_model:
+ return self.data_model.from_json(json.loads(payload))
+ return payload
+ from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+ from gradio.blocks import Block
+ if TYPE_CHECKING:
+ from gradio.components import Timer
+ from gradio.components.base import Component
+
+
+class FormComponent(Component):
+ """
+ A base class for components that are typically used in forms (e.g. Textbox, Dropdown). These
+ components will be grouped together in the UI to provide a more condensed layout. Components
+ that are not rendered in the UI (e.g. State) should also inherit from this class, as it will
+ prevent them from breaking the grouping, see: https://github.com/gradio-app/gradio/issues/10330
+ """
+
+ def get_expected_parent(self) -> type[Form] | None:
+ if getattr(self, "container", None) is False:
+ return None
+ return Form
+
+ def preprocess(self, payload: Any) -> Any:
+ return payload
+ from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+ from gradio.blocks import Block
+ if TYPE_CHECKING:
+ from gradio.components import Timer
+ from gradio.components.base import Component
+
+
+class StreamingOutput(metaclass=abc.ABCMeta):
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+ self.streaming: bool
+
+ @abc.abstractmethod
+ async def stream_output(
+ self, value, output_id: str, first_chunk: bool
+ ) -> tuple[MediaStreamChunk | None, FileDataDict | dict]:
+ pass
+
+ @abc.abstractmethod
+ async def combine_stream(
+ self,
+ stream: list[bytes],
+ desired_output_format: str | None = None,
+ only_file=False,
+ ) -> GradioDataModel | FileData:
+ """Combine all of the stream chunks into a single file.
+
+ This is needed for downloading the stream and for caching examples.
+ If `only_file` is True, only the FileData corresponding to the file should be returned (needed for downloading the stream).
+ The desired_output_format optionally converts the combined file. Should only be used for cached examples.
+ """
+ pass
+
+
+class StreamingInput(metaclass=abc.ABCMeta):
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs)
+
+ @abc.abstractmethod
+ def check_streamable(self):
+ """Used to check if streaming is supported given the input."""
+ pass
+
+
+def component(cls_name: str, render: bool) -> Component:
+ obj = utils.component_or_layout_class(cls_name)(render=render)
+ if not isinstance(obj, Component):
+ raise TypeError(f"Expected a Component instance, but got {obj.__class__}")
+ return obj
+
+
+def get_component_instance(
+ comp: str | dict | Component, render: bool = False, unrender: bool = False
+) -> Component:
+ """
+ Returns a component instance from a string, dict, or Component object.
+ Parameters:
+ comp: the component to instantiate. If a string, must be the name of a component, e.g. "dropdown". If a dict, must have a "name" key, e.g. {"name": "dropdown", "choices": ["a", "b"]}. If a Component object, will be returned as is.
+ render: whether to render the component. If True, renders the component (if not already rendered). If False, does not do anything.
+ unrender: whether to unrender the component. If True, unrenders the the component (if already rendered) -- this is useful when constructing an Interface or ChatInterface inside of a Blocks. If False, does not do anything.
+ """
+ if isinstance(comp, str):
+ component_obj = component(comp, render=render)
+ elif isinstance(comp, dict):
+ name = comp.pop("name") # type: ignore
+ component_cls = utils.component_or_layout_class(name)
+ component_obj = component_cls(**comp, render=render) # type: ignore
+ elif isinstance(comp, Component):
+ component_obj = comp
+ else:
+ raise ValueError(
+ f"Component must be provided as a `str` or `dict` or `Component` but is {comp}"
+ )
+
+ if render and not component_obj.is_rendered:
+ component_obj.render()
+ elif unrender and component_obj.is_rendered:
+ component_obj.unrender()
+ if not isinstance(component_obj, Component):
+ raise TypeError(
+ f"Expected a Component instance, but got {component_obj.__class__}"
+ )
+ return component_obj
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/gradio/components/browser_state.py b/lib/python3.11/site-packages/gradio/components/browser_state.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ee26f006ce21eca27b819c6aa9146822dc49a49
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/browser_state.py
@@ -0,0 +1,92 @@
+"""gr.BrowserState() component."""
+
+from __future__ import annotations
+
+import secrets
+import string
+from typing import Any
+
+from gradio_client.documentation import document
+from pydantic import BaseModel as PydanticBaseModel
+
+from gradio.components.base import Component
+from gradio.events import Events
+
+
+def _to_json_serializable(value: Any) -> Any:
+ """Convert a value to a JSON-serializable form.
+
+ Pydantic BaseModel instances are converted to dicts via model_dump(),
+ since they cannot be directly serialized by orjson and would otherwise
+ fall back to str() representation.
+ """
+ if isinstance(value, PydanticBaseModel):
+ return value.model_dump()
+ return value
+
+
+@document()
+class BrowserState(Component):
+ EVENTS = [Events.change]
+ """
+ Special component that stores state in the browser's localStorage in an encrypted format.
+ """
+
+ def __init__(
+ self,
+ default_value: Any = None,
+ *,
+ storage_key: str | None = None,
+ secret: str | None = None,
+ render: bool = True,
+ ):
+ """
+ Parameters:
+ default_value: the default value that will be used if no value is found in localStorage. Should be a json-serializable value.
+ storage_key: the key to use in localStorage. If None, a random key will be generated.
+ secret: the secret key to use for encryption. If None, a random key will be generated (recommended).
+ render: should always be True, is included for consistency with other components.
+ """
+ self.default_value = _to_json_serializable(default_value)
+ self.secret = secret or "".join(
+ secrets.choice(string.ascii_letters + string.digits) for _ in range(16)
+ )
+ self.storage_key = storage_key or "".join(
+ secrets.choice(string.ascii_letters + string.digits) for _ in range(16)
+ )
+ self._value_description = "any json-serializable value"
+
+ super().__init__(render=render)
+
+ def preprocess(self, payload: Any) -> Any:
+ """
+ Parameters:
+ payload: Value from local storage
+ Returns:
+ Passes value through unchanged
+ """
+ if payload is None:
+ return self.default_value
+ return payload
+
+ def postprocess(self, value: Any) -> Any:
+ """
+ Parameters:
+ value: Value to store in local storage
+ Returns:
+ Passes value through unchanged, converting Pydantic models to dicts
+ """
+ return _to_json_serializable(value)
+
+ def api_info(self) -> dict[str, Any]:
+ return {"type": {}, "description": "any json-serializable value"}
+
+ def example_payload(self) -> Any:
+ return "test"
+
+ def example_value(self) -> Any:
+ return "test"
+
+ def breaks_grouping(self) -> bool:
+ """BrowserState components should not break wrapper grouping chains."""
+ return False
diff --git a/lib/python3.11/site-packages/gradio/components/browser_state.pyi b/lib/python3.11/site-packages/gradio/components/browser_state.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..8866202e76b8bd73abb01ed05dd66e835ea9e522
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/browser_state.pyi
@@ -0,0 +1,152 @@
+"""gr.BrowserState() component."""
+
+from __future__ import annotations
+
+import secrets
+import string
+from typing import Any
+
+from gradio_client.documentation import document
+from pydantic import BaseModel as PydanticBaseModel
+
+from gradio.components.base import Component
+from gradio.events import Events
+
+
+def _to_json_serializable(value: Any) -> Any:
+ """Convert a value to a JSON-serializable form.
+
+ Pydantic BaseModel instances are converted to dicts via model_dump(),
+ since they cannot be directly serialized by orjson and would otherwise
+ fall back to str() representation.
+ """
+ if isinstance(value, PydanticBaseModel):
+ return value.model_dump()
+ return value
+
+from gradio.events import Dependency
+
+@document()
+class BrowserState(Component):
+ EVENTS = [Events.change]
+ """
+ Special component that stores state in the browser's localStorage in an encrypted format.
+ """
+
+ def __init__(
+ self,
+ default_value: Any = None,
+ *,
+ storage_key: str | None = None,
+ secret: str | None = None,
+ render: bool = True,
+ ):
+ """
+ Parameters:
+ default_value: the default value that will be used if no value is found in localStorage. Should be a json-serializable value.
+ storage_key: the key to use in localStorage. If None, a random key will be generated.
+ secret: the secret key to use for encryption. If None, a random key will be generated (recommended).
+ render: should always be True, is included for consistency with other components.
+ """
+ self.default_value = _to_json_serializable(default_value)
+ self.secret = secret or "".join(
+ secrets.choice(string.ascii_letters + string.digits) for _ in range(16)
+ )
+ self.storage_key = storage_key or "".join(
+ secrets.choice(string.ascii_letters + string.digits) for _ in range(16)
+ )
+ self._value_description = "any json-serializable value"
+
+ super().__init__(render=render)
+
+ def preprocess(self, payload: Any) -> Any:
+ """
+ Parameters:
+ payload: Value from local storage
+ Returns:
+ Passes value through unchanged
+ """
+ if payload is None:
+ return self.default_value
+ return payload
+
+ def postprocess(self, value: Any) -> Any:
+ """
+ Parameters:
+ value: Value to store in local storage
+ Returns:
+ Passes value through unchanged, converting Pydantic models to dicts
+ """
+ return _to_json_serializable(value)
+
+ def api_info(self) -> dict[str, Any]:
+ return {"type": {}, "description": "any json-serializable value"}
+
+ def example_payload(self) -> Any:
+ return "test"
+
+ def example_value(self) -> Any:
+ return "test"
+
+ def breaks_grouping(self) -> bool:
+ """BrowserState components should not break wrapper grouping chains."""
+ return False
+ from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+ from gradio.blocks import Block
+ if TYPE_CHECKING:
+ from gradio.components import Timer
+ from gradio.components.base import Component
+
+
+ def change(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/gradio/components/button.py b/lib/python3.11/site-packages/gradio/components/button.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4f43f0de735d1d836f2a49f32040e24a80095c1
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/button.py
@@ -0,0 +1,114 @@
+"""gr.Button() component."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+from gradio_client.documentation import document
+
+from gradio.components.base import Component
+from gradio.events import Events
+from gradio.i18n import I18nData
+
+if TYPE_CHECKING:
+ from gradio.components import Timer
+
+
+@document()
+class Button(Component):
+ """
+ Creates a button that can be assigned arbitrary .click() events. The value (label) of the button can be used as an input to the function (rarely used) or set via the output of a function.
+ """
+
+ EVENTS = [Events.click]
+
+ def __init__(
+ self,
+ value: str | I18nData | Callable = "Run",
+ *,
+ every: Timer | float | None = None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ variant: Literal["primary", "secondary", "stop", "huggingface"] = "secondary",
+ size: Literal["sm", "md", "lg"] = "lg",
+ icon: str | Path | None = None,
+ link: str | None = None,
+ link_target: Literal["_self", "_blank", "_parent", "_top"] = "_self",
+ visible: bool | Literal["hidden"] = True,
+ interactive: bool = True,
+ elem_id: str | None = None,
+ elem_classes: list[str] | str | None = None,
+ render: bool = True,
+ key: int | str | tuple[int | str, ...] | None = None,
+ preserved_by_key: list[str] | str | None = "value",
+ scale: int | None = None,
+ min_width: int | None = None,
+ ):
+ """
+ Parameters:
+ value: default text for the button to display. If a function is provided, the function will be called each time the app loads to set the initial value of this component.
+ every: continuously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ inputs: components that are used as inputs to calculate `value` if `value` is a function (has no effect otherwise). `value` is recalculated any time the inputs change.
+ variant: sets the background and text color of the button. Use 'primary' for main call-to-action buttons, 'secondary' for a more subdued style, 'stop' for a stop button, 'huggingface' for a black background with white text, consistent with Hugging Face's button styles.
+ size: size of the button. Can be "sm", "md", or "lg".
+ icon: URL or path to the icon file to display within the button. If None, no icon will be displayed.
+ link: URL to open when the button is clicked. If None, no link will be used.
+ link_target: determines where to open the linked URL. "_self" (default, same tab), "_blank" (new tab), "_parent" (parent frame), "_top" (top frame).
+ visible: If False, component will be hidden. If "hidden", component will be visually hidden and not take up space in the layout but still exist in the DOM
+ interactive: if False, the Button will be in a disabled state.
+ elem_id: an optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+ elem_classes: an optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
+ render: if False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+ key: in a gr.render, Components with the same key across re-renders are treated as the same component, not a new component. Properties set in 'preserved_by_key' are not reset across a re-render.
+ preserved_by_key: A list of parameters from this component's constructor. Inside a gr.render() function, if a component is re-rendered with the same key, these (and only these) parameters will be preserved in the UI (if they have been changed by the user or an event listener) instead of re-rendered based on the values provided during constructor.
+ scale: relative size compared to adjacent Components. For example if Components A and B are in a Row, and A has scale=2, and B has scale=1, A will be twice as wide as B. Should be an integer. scale applies in Rows, and to top-level Components in Blocks where fill_height=True.
+ min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
+ """
+ super().__init__(
+ every=every,
+ inputs=inputs,
+ visible=visible,
+ elem_id=elem_id,
+ elem_classes=elem_classes,
+ render=render,
+ key=key,
+ preserved_by_key=preserved_by_key,
+ value=value,
+ interactive=interactive,
+ scale=scale,
+ min_width=min_width,
+ )
+ self.icon = self.serve_static_file(icon)
+ self.variant = variant
+ self.size = size
+ self.link = link
+ self.link_target = link_target
+
+ @property
+ def skip_api(self):
+ return True
+
+ def preprocess(self, payload: str | None) -> str | None:
+ """
+ Parameters:
+ payload: string corresponding to the button label
+ Returns:
+ (Rarely used) the `str` corresponding to the button label when the button is clicked
+ """
+ return payload
+
+ def postprocess(self, value: str | None) -> str | None:
+ """
+ Parameters:
+ value: string corresponding to the button label
+ Returns:
+ Expects a `str` value that is set as the button label
+ """
+ return str(value)
+
+ def example_payload(self) -> Any:
+ return "Run"
+
+ def example_value(self) -> Any:
+ return "Run"
diff --git a/lib/python3.11/site-packages/gradio/components/button.pyi b/lib/python3.11/site-packages/gradio/components/button.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..67ed46ba427613868ee5e9d9e015b5e034db6051
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/button.pyi
@@ -0,0 +1,174 @@
+"""gr.Button() component."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+from gradio_client.documentation import document
+
+from gradio.components.base import Component
+from gradio.events import Events
+from gradio.i18n import I18nData
+
+if TYPE_CHECKING:
+ from gradio.components import Timer
+
+from gradio.events import Dependency
+
+@document()
+class Button(Component):
+ """
+ Creates a button that can be assigned arbitrary .click() events. The value (label) of the button can be used as an input to the function (rarely used) or set via the output of a function.
+ """
+
+ EVENTS = [Events.click]
+
+ def __init__(
+ self,
+ value: str | I18nData | Callable = "Run",
+ *,
+ every: Timer | float | None = None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ variant: Literal["primary", "secondary", "stop", "huggingface"] = "secondary",
+ size: Literal["sm", "md", "lg"] = "lg",
+ icon: str | Path | None = None,
+ link: str | None = None,
+ link_target: Literal["_self", "_blank", "_parent", "_top"] = "_self",
+ visible: bool | Literal["hidden"] = True,
+ interactive: bool = True,
+ elem_id: str | None = None,
+ elem_classes: list[str] | str | None = None,
+ render: bool = True,
+ key: int | str | tuple[int | str, ...] | None = None,
+ preserved_by_key: list[str] | str | None = "value",
+ scale: int | None = None,
+ min_width: int | None = None,
+ ):
+ """
+ Parameters:
+ value: default text for the button to display. If a function is provided, the function will be called each time the app loads to set the initial value of this component.
+ every: continuously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ inputs: components that are used as inputs to calculate `value` if `value` is a function (has no effect otherwise). `value` is recalculated any time the inputs change.
+ variant: sets the background and text color of the button. Use 'primary' for main call-to-action buttons, 'secondary' for a more subdued style, 'stop' for a stop button, 'huggingface' for a black background with white text, consistent with Hugging Face's button styles.
+ size: size of the button. Can be "sm", "md", or "lg".
+ icon: URL or path to the icon file to display within the button. If None, no icon will be displayed.
+ link: URL to open when the button is clicked. If None, no link will be used.
+ link_target: determines where to open the linked URL. "_self" (default, same tab), "_blank" (new tab), "_parent" (parent frame), "_top" (top frame).
+ visible: If False, component will be hidden. If "hidden", component will be visually hidden and not take up space in the layout but still exist in the DOM
+ interactive: if False, the Button will be in a disabled state.
+ elem_id: an optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+ elem_classes: an optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
+ render: if False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+ key: in a gr.render, Components with the same key across re-renders are treated as the same component, not a new component. Properties set in 'preserved_by_key' are not reset across a re-render.
+ preserved_by_key: A list of parameters from this component's constructor. Inside a gr.render() function, if a component is re-rendered with the same key, these (and only these) parameters will be preserved in the UI (if they have been changed by the user or an event listener) instead of re-rendered based on the values provided during constructor.
+ scale: relative size compared to adjacent Components. For example if Components A and B are in a Row, and A has scale=2, and B has scale=1, A will be twice as wide as B. Should be an integer. scale applies in Rows, and to top-level Components in Blocks where fill_height=True.
+ min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
+ """
+ super().__init__(
+ every=every,
+ inputs=inputs,
+ visible=visible,
+ elem_id=elem_id,
+ elem_classes=elem_classes,
+ render=render,
+ key=key,
+ preserved_by_key=preserved_by_key,
+ value=value,
+ interactive=interactive,
+ scale=scale,
+ min_width=min_width,
+ )
+ self.icon = self.serve_static_file(icon)
+ self.variant = variant
+ self.size = size
+ self.link = link
+ self.link_target = link_target
+
+ @property
+ def skip_api(self):
+ return True
+
+ def preprocess(self, payload: str | None) -> str | None:
+ """
+ Parameters:
+ payload: string corresponding to the button label
+ Returns:
+ (Rarely used) the `str` corresponding to the button label when the button is clicked
+ """
+ return payload
+
+ def postprocess(self, value: str | None) -> str | None:
+ """
+ Parameters:
+ value: string corresponding to the button label
+ Returns:
+ Expects a `str` value that is set as the button label
+ """
+ return str(value)
+
+ def example_payload(self) -> Any:
+ return "Run"
+
+ def example_value(self) -> Any:
+ return "Run"
+ from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+ from gradio.blocks import Block
+ if TYPE_CHECKING:
+ from gradio.components import Timer
+ from gradio.components.base import Component
+
+
+ def click(self,
+ fn: Callable[..., Any] | None = None,
+ inputs: Block | Sequence[Block] | set[Block] | None = None,
+ outputs: Block | Sequence[Block] | None = None,
+ api_name: str | None = None,
+ scroll_to_output: bool = False,
+ show_progress: Literal["full", "minimal", "hidden"] = "full",
+ show_progress_on: Component | Sequence[Component] | None = None,
+ queue: bool | None = None,
+ batch: bool = False,
+ max_batch_size: int = 4,
+ preprocess: bool = True,
+ postprocess: bool = True,
+ cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+ every: Timer | float | None = None,
+ trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+ js: str | Literal[True] | None = None,
+ concurrency_limit: int | None | Literal["default"] = "default",
+ concurrency_id: str | None = None,
+ api_visibility: Literal["public", "private", "undocumented"] = "public",
+ key: int | str | tuple[int | str, ...] | None = None,
+ api_description: str | None | Literal[False] = None,
+ validator: Callable[..., Any] | None = None,
+
+ ) -> Dependency:
+ """
+ Parameters:
+ fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+ inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+ outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+ api_name: defines how the endpoint appears in the API docs. Can be a string or None. If set to a string, the endpoint will be exposed in the API docs with the given name. If None (default), the name of the function will be used as the API endpoint.
+ scroll_to_output: if True, will scroll to output component on completion
+ show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+ show_progress_on: Component or list of components to show the progress animation on. If None, will show the progress animation on all of the output components.
+ queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+ batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+ max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+ preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+ postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+ cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+ every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+ js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+ concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+ concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+ api_visibility: controls the visibility and accessibility of this endpoint. Can be "public" (shown in API docs and callable by clients), "private" (hidden from API docs and not callable by the Gradio client libraries), or "undocumented" (hidden from API docs but callable by clients and via gr.load). If fn is None, api_visibility will automatically be set to "private".
+ key: A unique key for this event listener to be used in @gr.render(). If set, this value identifies an event as identical across re-renders when the key is identical.
+ api_description: Description of the API endpoint. Can be a string, None, or False. If set to a string, the endpoint will be exposed in the API docs with the given description. If None, the function's docstring will be used as the API endpoint description. If False, then no description will be displayed in the API docs.
+ validator: Optional validation function to run before the main function. If provided, this function will be executed first with queue=False, and only if it completes successfully will the main function be called. The validator receives the same inputs as the main function.
+
+ """
+ ...
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/gradio/components/chatbot.py b/lib/python3.11/site-packages/gradio/components/chatbot.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb8b0e1647285df247608e0c2c1e4ba35782982c
--- /dev/null
+++ b/lib/python3.11/site-packages/gradio/components/chatbot.py
@@ -0,0 +1,727 @@
+"""gr.Chatbot() component."""
+
+from __future__ import annotations
+
+import copy
+import inspect
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import (
+ TYPE_CHECKING,
+ Any,
+ Literal,
+ Union,
+ cast,
+)
+
+from gradio_client import utils as client_utils
+from gradio_client.documentation import document
+from typing_extensions import NotRequired, TypedDict
+
+from gradio import utils
+from gradio.component_meta import ComponentMeta
+from gradio.components import (
+ Component as GradioComponent,
+)
+from gradio.components.base import Component
+from gradio.components.button import Button
+from gradio.data_classes import FileData, GradioModel, GradioRootModel
+from gradio.events import Events
+from gradio.exceptions import Error
+from gradio.i18n import I18nData
+from gradio.utils import set_default_buttons
+
+
+@document()
+class MetadataDict(TypedDict):
+ """
+ A typed dictionary to represent metadata for a message in the Chatbot component. An
+ instance of this dictionary is used for the `metadata` field in a ChatMessage when
+ the chat message should be displayed as a thought.
+ Parameters:
+ title: The title of the "thought" message. Required if the message is to be displayed as a thought.
+ id: The ID of the message. Only used for nested thoughts. Nested thoughts can be nested by setting the parent_id to the id of the parent thought.
+ parent_id: The ID of the parent message. Only used for nested thoughts.
+ log: A string message to display next to the thought title in a subdued font.
+ duration: The duration of the message in seconds. Appears next to the thought title in a subdued font inside a parentheses.
+ status: if set to `"pending"`, a spinner appears next to the thought title and the accordion is initialized open. If `status` is `"done"`, the thought accordion is initialized closed. If `status` is not provided, the thought accordion is initialized open and no spinner is displayed.
+ """
+
+ title: NotRequired[str]
+ id: NotRequired[int | str]
+ parent_id: NotRequired[int | str]
+ log: NotRequired[str]
+ duration: NotRequired[float]
+ status: NotRequired[Literal["pending", "done"]]
+
+
+@document()
+class OptionDict(TypedDict):
+ """
+ A typed dictionary to represent an option in a ChatMessage. A list of these
+ dictionaries is used for the `options` field in a ChatMessage.
+ Parameters:
+ value: The value to return when the option is selected.
+ label: The text to display in the option, if different from the value.
+ """
+
+ value: str
+ label: NotRequired[str]
+
+
+class FileDataDict(TypedDict):
+ path: str # server filepath
+ url: NotRequired[str | None] # normalised server url
+ size: NotRequired[int | None] # size in bytes
+ orig_name: NotRequired[str | None] # original filename
+ mime_type: NotRequired[str | None]
+ is_stream: NotRequired[bool]
+ meta: dict[Literal["_type"], Literal["gradio.FileData"]]
+
+
+class TextMessage(GradioModel):
+ text: str
+ type: Literal["text"] = "text"
+
+
+class TextMessageDict(TypedDict):
+ text: str
+ type: Literal["text"]
+
+
+class ComponentMessage(GradioModel):
+ component: str
+ value: Any
+ constructor_args: dict[str, Any]
+ props: dict[str, Any]
+ type: Literal["component"] = "component"
+
+
+class ComponentMessageDict(TypedDict):
+ component: str
+ value: Any
+ constructor_args: dict[str, Any]
+ props: dict[str, Any]
+ type: Literal["component"]
+ instance: NotRequired[GradioComponent]
+
+
+MessageContent = Union[str, FileDataDict, FileData, Component]
+
+
+class MessageDict(TypedDict):
+ content: MessageContent | list[MessageContent]
+ role: Literal["user", "assistant", "system"]
+ metadata: NotRequired[MetadataDict]
+ options: NotRequired[list[OptionDict]]
+
+
+class FileMessage(GradioModel):
+ file: FileData
+ alt_text: str | None = None
+ type: Literal["file"] = "file"
+
+
+class FileMessageDict(TypedDict):
+ file: FileDataDict
+ alt_text: NotRequired[str | None]
+ type: Literal["file"]
+
+
+NormalizedMessageContent = Union[TextMessageDict, FileMessageDict, ComponentMessageDict]
+
+
+class NormalizedMessageDict(TypedDict):
+ content: list[NormalizedMessageContent]
+ role: Literal["user", "assistant", "system"]
+ metadata: NotRequired[MetadataDict]
+ options: NotRequired[list[OptionDict]]
+
+
+class Message(GradioModel):
+ role: str
+ metadata: MetadataDict | None = None
+ content: list[Union[TextMessage, FileMessage, ComponentMessage]]
+ options: list[OptionDict] | None = None
+
+
+class ExampleMessage(TypedDict):
+ icon: NotRequired[
+ str | FileDataDict
+ ] # filepath or url to an image to be shown in example box
+ display_text: NotRequired[
+ str
+ ] # text to be shown in example box. If not provided, main_text will be shown
+ text: NotRequired[str] # text to be added to chatbot when example is clicked
+ files: NotRequired[
+ Sequence[str | FileDataDict]
+ ] # list of file paths or URLs to be added to chatbot when example is clicked
+
+
+@document()
+@dataclass
+class ChatMessage:
+ """
+ A dataclass that represents a message in the Chatbot component (with type="messages"). The only required field is `content`. The value of `gr.Chatbot` is a list of these dataclasses.
+ Parameters:
+ content: The content of the message. Can be a string, a file dict, a gradio component, or a list of these types to group these messages together.
+ role: The role of the message, which determines the alignment of the message in the chatbot. Can be "user", "assistant", or "system". Defaults to "assistant".
+ metadata: The metadata of the message, which is used to display intermediate thoughts / tool usage. Should be a dictionary with the following keys: "title" (required to display the thought), and optionally: "id" and "parent_id" (to nest thoughts), "duration" (to display the duration of the thought), "status" (to display the status of the thought).
+ options: The options of the message. A list of Option objects, which are dictionaries with the following keys: "label" (the text to display in the option), and optionally "value" (the value to return when the option is selected if different from the label).
+ """
+
+ content: MessageContent | list[MessageContent]
+ role: Literal["user", "assistant", "system"] = "assistant"
+ metadata: MetadataDict = field(default_factory=MetadataDict)
+ options: list[OptionDict] = field(default_factory=list)
+
+
+class ChatbotDataMessages(GradioRootModel):
+ root: list[Message]
+
+
+if TYPE_CHECKING:
+ from gradio.components import Timer
+
+
+def import_component_and_data(
+ component_name: str,
+) -> type[Component] | None:
+ try:
+ for component in utils.get_all_components():
+ if component_name == component.__name__ and isinstance(
+ component, ComponentMeta
+ ):
+ return component # ty: ignore[invalid-return-type]
+ except ModuleNotFoundError as e:
+ raise ValueError(f"Error importing {component_name}: {e}") from e
+ except AttributeError:
+ pass
+
+
+@document()
+class Chatbot(Component):
+ """
+ Creates a chatbot that displays user-submitted messages and responses. Supports a subset of Markdown including bold, italics, code, tables.
+ Also supports audio/video/image files, which are displayed in the Chatbot, and other kinds of files which are displayed as links. This
+ component is usually used as an output component.
+
+ Demos: chatbot_simple, chatbot_streaming, chatbot_with_tools, chatbot_core_components
+ Guides: chatbot-specific-events, conversational-chatbot, creating-a-chatbot-fast, creating-a-custom-chatbot-with-blocks, agents-and-tool-usage
+ """
+
+ data_model = ChatbotDataMessages
+
+ EVENTS = [
+ Events.change,
+ Events.select,
+ Events.like,
+ Events.retry,
+ Events.undo,
+ Events.example_select,
+ Events.option_select,
+ Events.clear,
+ Events.copy,
+ Events.edit,
+ ]
+
+ def __init__(
+ self,
+ value: (list[MessageDict | Message] | Callable | None) = None,
+ *,
+ label: str | I18nData | None = None,
+ every: Timer | float | None = None,
+ inputs: Component | Sequence[Component] | set[Component] | None = None,
+ show_label: bool | None = None,
+ container: bool = True,
+ scale: int | None = None,
+ min_width: int = 160,
+ visible: bool | Literal["hidden"] = True,
+ elem_id: str | None = None,
+ elem_classes: list[str] | str | None = None,
+ autoscroll: bool = True,
+ render: bool = True,
+ key: int | str | tuple[int | str, ...] | None = None,
+ preserved_by_key: list[str] | str | None = "value",
+ height: int | str | None = 400,
+ resizable: bool = False,
+ max_height: int | str | None = None,
+ min_height: int | str | None = None,
+ editable: Literal["user", "all"] | None = None,
+ latex_delimiters: list[dict[str, str | bool]] | None = None,
+ rtl: bool = False,
+ buttons: list[Literal["share", "copy", "copy_all"] | Button] | None = None,
+ watermark: str | None = None,
+ avatar_images: tuple[str | Path | None, str | Path | None] | None = None,
+ sanitize_html: bool = True,
+ render_markdown: bool = True,
+ feedback_options: list[str] | tuple[str, ...] | None = ("Like", "Dislike"),
+ feedback_value: Sequence[str | None] | None = None,
+ line_breaks: bool = True,
+ layout: Literal["panel", "bubble"] | None = None,
+ placeholder: str | None = None,
+ examples: list[ExampleMessage] | None = None,
+ allow_file_downloads: bool = True,
+ group_consecutive_messages: bool = True,
+ allow_tags: list[str] | bool = True,
+ reasoning_tags: list[tuple[str, str]] | None = None,
+ like_user_message: bool = False,
+ ):
+ """
+ Parameters:
+ value: Default list of messages to show in chatbot, where each message is of the format {"role": "user", "content": "Help me."}. Role can be one of "user", "assistant", or "system". Content should be either text, or media passed as a Gradio component, e.g. {"content": gr.Image("lion.jpg")}. If a function is provided, the function will be called each time the app loads to set the initial value of this component.
+ label: the label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.
+ every: Continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+ inputs: Components that are used as inputs to calculate `value` if `value` is a function (has no effect otherwise). `value` is recalculated any time the inputs change.
+ show_label: if True, will display label.
+ container: If True, will place the component in a container - providing some extra padding around the border.
+ scale: relative size compared to adjacent Components. For example if Components A and B are in a Row, and A has scale=2, and B has scale=1, A will be twice as wide as B. Should be an integer. scale applies in Rows, and to top-level Components in Blocks where fill_height=True.
+ min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
+ visible: If False, component will be hidden. If "hidden", component will be visually hidden and not take up space in the layout but still exist in the DOM
+ elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+ elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
+ autoscroll: If True, will automatically scroll to the bottom of the textbox when the value changes, unless the user scrolls up. If False, will not scroll to the bottom of the textbox when the value changes.
+ render: If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+ key: in a gr.render, Components with the same key across re-renders are treated as the same component, not a new component. Properties set in 'preserved_by_key' are not reset across a re-render.
+ preserved_by_key: A list of parameters from this component's constructor. Inside a gr.render() function, if a component is re-rendered with the same key, these (and only these) parameters will be preserved in the UI (if they have been changed by the user or an event listener) instead of re-rendered based on the values provided during constructor.
+ height: The height of the component, specified in pixels if a number is passed, or in CSS units if a string is passed. If messages exceed the height, the component will scroll.
+ resizable: If True, the user of the Gradio app can resize the chatbot by dragging the bottom right corner.
+ max_height: The maximum height of the component, specified in pixels if a number is passed, or in CSS units if a string is passed. If messages exceed the height, the component will scroll. If messages are shorter than the height, the component will shrink to fit the content. Will not have any effect if `height` is set and is smaller than `max_height`.
+ min_height: The minimum height of the component, specified in pixels if a number is passed, or in CSS units if a string is passed. If messages exceed the height, the component will expand to fit the content. Will not have any effect if `height` is set and is larger than `min_height`.
+ editable: Allows user to edit messages in the chatbot. If set to "user", allows editing of user messages. If set to "all", allows editing of assistant messages as well.
+ latex_delimiters: A list of dicts of the form {"left": open delimiter (str), "right": close delimiter (str), "display": whether to display in newline (bool)} that will be used to render LaTeX expressions. If not provided, `latex_delimiters` is set to `[{ "left": "$$", "right": "$$", "display": True }]`, so only expressions enclosed in $$ delimiters will be rendered as LaTeX, and in a new line. Pass in an empty list to disable LaTeX rendering. For more information, see the [KaTeX documentation](https://katex.org/docs/autorender.html).
+ rtl: If True, sets the direction of the rendered text to right-to-left. Default is False, which renders text left-to-right.
+ buttons: A list of buttons to show in the top right corner of the component. Valid options are "share", "copy", "copy_all", or a gr.Button() instance. The "share" button allows the user to share outputs to Hugging Face Spaces Discussions. The "copy" button makes a copy button appear next to each individual chatbot message. The "copy_all" button appears at the component level and allows the user to copy all chatbot messages. Custom gr.Button() instances will appear in the toolbar with their configured icon and/or label, and clicking them will trigger any .click() events registered on the button. By default, "share" and "copy_all" buttons are shown.
+ watermark: If provided, this text will be appended to the end of messages copied from the chatbot, after a blank line. Useful for indicating that the message is generated by an AI model.
+ avatar_images: Tuple of two avatar image paths or URLs for user and bot (in that order). Pass None for either the user or bot image to skip. Must be within the working directory of the Gradio app or an external URL.
+ sanitize_html: If False, will disable HTML sanitization for chatbot messages. This is not recommended, as it can lead to security vulnerabilities.
+ render_markdown: If False, will disable Markdown rendering for chatbot messages.
+ feedback_options: A list of strings representing the feedback options that will be displayed to the user. The exact case-sensitive strings "Like" and "Dislike" will render as thumb icons, but any other choices will appear under a separate flag icon.
+ feedback_value: A list of strings representing the feedback state for entire chat. Only works when type="messages". Each entry in the list corresponds to that assistant message, in order, and the value is the feedback given (e.g. "Like", "Dislike", or any custom feedback option) or None if no feedback was given for that message.
+ line_breaks: If True (default), will enable Github-flavored Markdown line breaks in chatbot messages. If False, single new lines will be ignored. Only applies if `render_markdown` is True.
+ layout: If "panel", will display the chatbot in a llm style layout. If "bubble", will display the chatbot with message bubbles, with the user and bot messages on alterating sides. Will default to "bubble".
+ placeholder: a placeholder message to display in the chatbot when it is empty. Centered vertically and horizontally in the Chatbot. Supports Markdown and HTML. If None, no placeholder is displayed.
+ examples: A list of example messages to display in the chatbot before any user/assistant messages are shown. Each example should be a dictionary with an optional "text" key representing the message that should be populated in the Chatbot when clicked, an optional "files" key, whose value should be a list of files to populate in the Chatbot, an optional "icon" key, whose value should be a filepath or URL to an image to display in the example box, and an optional "display_text" key, whose value should be the text to display in the example box. If "display_text" is not provided, the value of "text" will be displayed.
+ allow_file_downloads: If True, will show a download button for chatbot messages that contain media. Defaults to True.
+ group_consecutive_messages: If True, will display consecutive messages from the same role in the same bubble. If False, will display each message in a separate bubble. Defaults to True.
+ allow_tags: If a list of tags is provided, these tags will be preserved in the output chatbot messages, even if `sanitize_html` is `True`. For example, if this list is ["thinking"], the tags `<thinking>` and `</thinking>` will not be removed. If True, all custom tags (non-standard HTML tags) will be preserved. If False, no tags will be preserved. Default value is 'True'.
+ reasoning_tags: If provided, a list of tuples of (open_tag, close_tag) strings. Any text between these tags will be extracted and displayed in a separate collapsible message with metadata={"title": "Reasoning"}. For example, [("<thinking>", "</thinking>")] will extract content between <thinking> and </thinking> tags. Each thinking block will be displayed as a separate collapsible message before the main response. If None (default), no automatic extraction is performed.
+ like_user_message: If True, will show like/dislike buttons for user messages as well. Defaults to False.
+ """
+ self.autoscroll = autoscroll
+ self.height = height
+ self.resizable = resizable
+ self.max_height = max_height
+ self.min_height = min_height
+ self.editable = editable
+ self.rtl = rtl
+ self.group_consecutive_messages = group_consecutive_messages
+ if latex_delimiters is None:
+ latex_delimiters = [{"left": "$$", "right": "$$", "display": True}]
+ self.latex_delimiters = latex_delimiters
+ self.buttons = set_default_buttons(buttons, ["share", "copy", "copy_all"])
+ self.render_markdown = render_markdown
+ self.watermark = watermark
+ self.sanitize_html = sanitize_html
+ self.line_breaks = line_breaks
+ self.layout = layout
+ self.allow_file_downloads = allow_file_downloads
+ self.feedback_options = feedback_options
+ self.feedback_value = feedback_value
+ self.allow_tags = allow_tags if allow_tags else False
+ self.reasoning_tags = reasoning_tags
+ self.like_user_message = like_user_message
+ super().__init__(
+ label=label,
+ every=every,
+ inputs=inputs,
+ show_label=show_label,
+ container=container,
+ scale=scale,
+ min_width=min_width,
+ visible=visible,
+ elem_id=elem_id,
+ elem_classes=elem_classes,
+ render=render,
+ key=key,
+ preserved_by_key=preserved_by_key,
+ value=value,
+ )
+ self.avatar_images: list[dict | None] = [None, None]
+ if avatar_images is None:
+ pass
+ else:
+ self.avatar_images = [
+ self.serve_static_file(avatar_images[0]),
+ self.serve_static_file(avatar_images[1]),
+ ]
+ self.placeholder = placeholder
+
+ self.examples = examples
+ self._setup_examples()
+ self._value_description = "a list of chat message dictionaries in openai format, e.g. {'role': 'user', 'content': 'Hello'}"
+
+ def _setup_examples(self):
+ if self.examples is not None:
+ for i, example in enumerate(self.examples):
+ if "icon" in example and isinstance(example["icon"], str):
+ example["icon"] = cast(
+ FileDataDict, self.serve_static_file(example["icon"])
+ )
+ file_info = example.get("files")
+ if file_info is not None and not isinstance(file_info, list):
+ raise Error(
+ "Data incompatible with files format. The 'files' passed should be a list of file paths or URLs."
+ )
+ if file_info is not None:
+ for i, file in enumerate(file_info):
+ if isinstance(file, str):
+ orig_name = Path(file).name
+ file_data = self.serve_static_file(file)
+ if file_data is not None:
+ file_data["orig_name"] = orig_name
+ file_data["mime_type"] = client_utils.get_mimetype(
+ orig_name
+ )
+ file_data = FileDataDict(**file_data) # type: ignore
+ file_info[i] = file_data
+
+ @staticmethod
+ def _check_format(
+ messages: list[MessageDict | Message | ChatMessage | NormalizedMessageDict],
+ ):
+ all_valid = all(
+ isinstance(message, dict)
+ and "role" in message
+ and "content" in message
+ or isinstance(message, ChatMessage | Message)
+ for message in messages
+ )
+ if not all_valid:
+ raise Error(
+ "Data incompatible with messages format. Each message should be a dictionary with 'role' and 'content' keys or a ChatMessage object."
+ )
+
+ def _preprocess_content(
+ self,
+ chat_message: Union[TextMessage, FileMessage, ComponentMessage],
+ ) -> NormalizedMessageContent:
+ if isinstance(chat_message, FileMessage):
+ return cast(FileMessageDict, chat_message.model_dump())
+ elif isinstance(chat_message, TextMessage):
+ return cast(TextMessageDict, chat_message.model_dump())
+ elif isinstance(chat_message, ComponentMessage):
+ component_message = cast(ComponentMessageDict, chat_message.model_dump())
+ capitalized_component = (
+ chat_message.component.upper()
+ if chat_message.component in ("json", "html")
+ else "Model3D"
+ if chat_message.component == "model3d"
+ else chat_message.component.capitalize()
+ )
+ component = import_component_and_data(capitalized_component)
+ if component is not None:
+ instance = component() # type: ignore
+ if not instance.data_model:
+ payload = chat_message.value
+ elif issubclass(instance.data_model, GradioModel):
+ payload = instance.data_model(**chat_message.value)
+ elif issubclass(instance.data_model, GradioRootModel):
+ payload = instance.data_model(root=chat_message.value)
+ else:
+ payload = chat_message.value
+ value = instance.preprocess(payload)
+ component_message["instance"] = component(
+ value=value, **chat_message.constructor_args
+ )
+ return component_message
+ else:
+ raise ValueError(f"Invalid message for Chatbot component: {chat_message}")
+
+ def preprocess(
+ self,
+ payload: ChatbotDataMessages | None,
+ ) -> list[NormalizedMessageDict]:
+ """
+ Parameters:
+ payload: data as a ChatbotData object
+ Returns:
+ Passes the value as a list of dictionaries with 'role' and 'content' keys.
+ """
+ if payload is None:
+ return []
+
+ if not isinstance(payload, ChatbotDataMessages):
+ raise Error("Data incompatible with the messages format")
+ message_dicts = []
+ for message in payload.root:
+ message_dict = cast(NormalizedMessageDict, message.model_dump())
+ message_dict["content"] = [
+ self._preprocess_content(content) for content in message.content
+ ]
+ message_dicts.append(message_dict)
+ return message_dicts
+
+ @staticmethod
+ def _get_alt_text(chat_message: dict | list | tuple | GradioComponent):
+ if isinstance(chat_message, dict):
+ return chat_message.get("alt_text") # type: ignore
+ elif not isinstance(chat_message, GradioComponent) and len(chat_message) > 1:
+ return chat_message[1]
+
+ @staticmethod
+ def _create_file_message(chat_message, filepath):
+ mime_type = client_utils.get_mimetype(filepath)
+
+ return FileMessage(
+ file=FileData(path=filepath, mime_type=mime_type),
+ alt_text=Chatbot._get_alt_text(chat_message),
+ )
+
+ def _postprocess_content(
+ self,
+ chat_message: str
+ | FileDataDict
+ | GradioComponent
+ | ComponentMessage
+ | FileData
+ | FileMessage
+ | ComponentMessage
+ | FileMessageDict
+ | ComponentMessageDict
+ | TextMessageDict,
+ ) -> Union[TextMessage, FileMessage, ComponentMessage, None]:
+ if isinstance(chat_message, str):
+ return TextMessage(text=inspect.cleandoc(chat_message))
+ elif isinstance(chat_message, (FileMessage, ComponentMessage)):
+ return chat_message
+ elif isinstance(chat_message, FileData):
+ return FileMessage(file=chat_message)
+ elif isinstance(chat_message, GradioComponent):
+ chat_message.unrender()
+ component = import_component_and_data(type(chat_message).__name__)
+ if component:
+ chat_message.constructor_args["render"] = False
+ component = chat_message.__class__(**chat_message.constructor_args)
+ chat_message.constructor_args.pop("value", None)
+ config = component.get_config()
+ component_name = type(chat_message).__name__.lower()
+ value = config.get("value", None)
+ # Ensure that file components have value as a list
+ if (
+ component_name == "file"
+ and value is not None
+ and not isinstance(value, list)
+ ):
+ value = [value]
+ return ComponentMessage(
+ component=component_name,
+ value=value,
+ constructor_args=chat_message.constructor_args,
+ props=config,
+ )
+ elif isinstance(chat_message, dict) and "path" in chat_message:
+ filepath = chat_message["path"]
+ return self._create_file_message(chat_message, filepath)
+ elif isinstance(chat_message, dict) and "file" in chat_message:
+ return FileMessage(
+ file=FileData(**chat_message["file"]), # type: ignore
+ alt_text=chat_message.get("alt_text"),
+ )
+ elif isinstance(chat_message, dict) and chat_message.get("type") == "text":
+ return TextMessage(**chat_message) # type: ignore
+ elif isinstance(chat_message, dict) and chat_message.get("type") == "component":
+ return ComponentMessage(**chat_message) # type: ignore
+ elif isinstance(chat_message, dict) and chat_message.get("type") == "file":
+ return FileMessage(
+ file=FileData(**chat_message["file"]), # type: ignore
+ alt_text=chat_message.get("alt_text"),
+ )
+ else:
+ raise ValueError(f"Invalid message for Chatbot component: {chat_message}")
+
+ def _postprocess(
+ self, message: MessageDict | Message | ChatMessage | NormalizedMessageDict
+ ) -> list[Message] | None:
+ message = copy.deepcopy(message)
+ role = message["role"] if isinstance(message, dict) else message.role # type: ignore[possibly-unbound-attribute]
+ metadata = (
+ message.get("metadata") if isinstance(message, dict) else message.metadata # type: ignore[possibly-unbound-attribute]
+ )
+ options = (
+ message.get("options") if isinstance(message, dict) else message.options # type: ignore[possibly-unbound-attribute]
+ )
+ if isinstance(message, dict) and not isinstance(message["content"], list):
+ content_ = self._postprocess_content(
+ cast(MessageContent, message["content"])
+ )
+ if not content_:
+ return None
+ content_postprocessed = [content_]
+ elif isinstance(message, dict) and isinstance(message["content"], list):
+ content_postprocessed: list[
+ Union[TextMessage, FileMessage, ComponentMessage]
+ ] = []
+ for content_item in cast(list, message["content"]):
+ item = self._postprocess_content(content_item)
+ if item:
+ content_postprocessed.append(item)
+ if not content_postprocessed:
+ return None
+ elif isinstance(message, ChatMessage):
+ if not isinstance(message.content, list):
+ content_postprocessed = [self._postprocess_content(message.content)] # type: ignore
+ else:
+ content_postprocessed = []
+ for content_item in message.content:
+ item = self._postprocess_content(content_item) # type: ignore
+ if item:
+ content_postprocessed.append(item)
+ if not content_postprocessed:
+ return None
+ elif isinstance(message, Message):
+ return [message]
+ else:
+ raise Error(
+ f"Invalid message for Chatbot component: {message}", visible=False
+ )
+ messages: list[Message] = []
+ if self.reasoning_tags:
+ non_text_content = [
+ item
+ for item in content_postprocessed
+ if item.type != "text" # type: ignore
+ ]
+ for content_item in content_postprocessed:
+ if content_item.type == "text": # type: ignore
+ segments = self._extract_thinking_blocks(
+ content_item.text, # type: ignore
+ self.reasoning_tags, # type: ignore
+ )
+ for text, is_thinking, status in segments:
+ if is_thinking:
+ thinking_message = Message(
+ role=role,
+ content=[TextMessage(text=text)],
+ metadata=cast(
+ MetadataDict,
+ {"title": "Reasoning", "status": status},
+ ),
+ )
+ messages.append(thinking_message)
+ else:
+ prose_message = Message(
+ role=role,
+ content=[TextMessage(text=text)],
+ metadata=metadata,
+ options=options,
+ )
+ messages.append(prose_message)
+ if non_text_content:
+ messages.append(
+ Message(
+ role=role,
+ content=non_text_content, # type: ignore
+ metadata=metadata,
+ options=options,
+ )
+ )
+ else:
+ messages = [
+ Message(
+ role=role,
+ content=content_postprocessed, # type: ignore
+ metadata=metadata,
+ options=options,
+ )
+ ]
+ return messages
+
+ def _extract_thinking_blocks(
+ self, content: str, tags: list[tuple[str, str]]
+ ) -> list[tuple[str, bool, str]]:
+ """
+ Extract thinking blocks from content based on provided tags, preserving order.
+
+ Parameters:
+ content: The message content to process
+ tags: List of (open_tag, close_tag) tuples
+
+ Returns:
+ A list of tuples (text, is_thinking, status) in order of appearance
+ """
+ import re
+
+ patterns = []
+ for open_tag, close_tag in tags:
+ escaped_open = re.escape(open_tag)
+ escaped_close = re.escape(close_tag)
+ # match opening tag, and either the closing tag or the end of the string
+ patterns.append(f"({escaped_open})(.*?)(?:{escaped_close}|$)")
+
+ combined_pattern = "|".join(patterns)
+
+ segments = []
+ last_end = 0
+ for match in re.finditer(combined_pattern, content, re.DOTALL):
+ if match.start() > last_end:
+ prose = content[last_end : match.start()].strip()
+ if prose:
+ segments.append([prose, False, "done"])
+
+ thinking = None
+ for i in range(1, len(match.groups()), 2):
+ if match.group(i + 1) is not None:
+ thinking = match.group(i + 1).strip()
+ break
+
+ if thinking:
+ pending = not any(match.group(0).endswith(tag[1]) for tag in tags)
+ segments.append([thinking, True, "done" if not pending else "pending"])
+
+ last_end = match.end()
+
+ if last_end < len(content):
+ prose = content[last_end:].strip()
+ if prose:
+ segments.append([prose, False, "done"])
+
+ return segments
+
+ def postprocess(
+ self,
+ value: list[MessageDict | Message | ChatMessage | NormalizedMessageDict] | None,
+ ) -> ChatbotDataMessages:
+ """
+ Parameters:
+ value: Passes the value as a list of dictionaries with 'role' and 'content' keys. The `content` key's value supports everything the `tuples` format supports.
+ Returns:
+ an object of type ChatbotData
+ """
+ if value is None:
+ return ChatbotDataMessages(root=[])
+ self._check_format(value)
+
+ processed_messages = []
+ for message in value:
+ processed_message = self._postprocess(message)
+ if processed_message is not None:
+ processed_messages.extend(processed_message)
+ return ChatbotDataMessages(root=processed_messages)
+
+ def example_payload(self) -> Any:
+ return [
+ Message(role="user", content=[TextMessage(text="Hello!")]).model_dump(),
+ Message(
+ role="assistant", content=[TextMessage(text="How can I help you?")]
+ ).model_dump(),
+ ]
+
+ def example_value(self) -> Any:
+ return [
+ Message(role="user", content=[TextMessage(text="Hello!")]).model_dump(),
+ Message(
+ role="assistant", content=[TextMessage(text="How can I help you?")]
+ ).model_dump(),
+ ]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..19c4f36492c76212e1662972b7dec088eebd99c3
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/configuration_siglip.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/configuration_siglip.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6aab9185eb34775454586eedd8a5c7c0ee2ea1a8
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/configuration_siglip.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/image_processing_pil_siglip.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/image_processing_pil_siglip.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..33a51d146bef4e8a48c41304f2e247f534ecb34e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/image_processing_pil_siglip.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/image_processing_siglip.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/image_processing_siglip.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2969ada0032f10731c71e68dbe7540bb58837ff7
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/image_processing_siglip.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/modeling_siglip.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/modeling_siglip.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74c0160e7ca3309d6101acd16e4924dbf7c753ad
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/modeling_siglip.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/processing_siglip.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/processing_siglip.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a4eed2e4cf6d400d4035e93f02cfee17a0953a85
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/processing_siglip.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/tokenization_siglip.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/tokenization_siglip.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1f55ae1939543473e57d95b08eb0fcb34e1a14e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip/__pycache__/tokenization_siglip.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/image_processing_pil_siglip.py b/lib/python3.11/site-packages/transformers/models/siglip/image_processing_pil_siglip.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7bedc2c7e18b93ca123894d1e2fc94e7337ac2b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip/image_processing_pil_siglip.py
@@ -0,0 +1,38 @@
+# Copyright 2024 The HuggingFace Inc. 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.
+"""Image processor class for SigLIP."""
+
+from ...image_processing_backends import PilBackend
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ PILImageResampling,
+)
+from ...utils import auto_docstring
+
+
+@auto_docstring(custom_intro="Constructs a SigLIP image processor.")
+class SiglipImageProcessorPil(PilBackend):
+ resample = PILImageResampling.BICUBIC
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"height": 224, "width": 224}
+ default_to_square = False
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ do_convert_rgb = True
+
+
+__all__ = ["SiglipImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/image_processing_siglip.py b/lib/python3.11/site-packages/transformers/models/siglip/image_processing_siglip.py
new file mode 100644
index 0000000000000000000000000000000000000000..81a712f557a342194d58ffdace611c18c768dfe4
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip/image_processing_siglip.py
@@ -0,0 +1,38 @@
+# Copyright 2024 The HuggingFace Inc. 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.
+"""Image processor class for SigLIP."""
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ PILImageResampling,
+)
+from ...utils import auto_docstring
+
+
+@auto_docstring(custom_intro="Constructs a SigLIP image processor.")
+class SiglipImageProcessor(TorchvisionBackend):
+ resample = PILImageResampling.BICUBIC
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"height": 224, "width": 224}
+ default_to_square = False
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ do_convert_rgb = True
+
+
+__all__ = ["SiglipImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/modeling_siglip.py b/lib/python3.11/site-packages/transformers/models/siglip/modeling_siglip.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d29a4fb08cbb426b299db2f8f6c7e96c4b7d236
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip/modeling_siglip.py
@@ -0,0 +1,936 @@
+# Copyright 2024 Google AI and 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.
+"""PyTorch Siglip model."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+import torch
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...masking_utils import create_bidirectional_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling, ImageClassifierOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import (
+ ModelOutput,
+ TransformersKwargs,
+ auto_docstring,
+ can_return_tuple,
+ torch_int,
+)
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_siglip import SiglipConfig, SiglipTextConfig, SiglipVisionConfig
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for vision model's outputs that also contains image embeddings of the pooling of the last hidden states.
+ """
+)
+@dataclass
+# Copied from transformers.models.clip.modeling_clip.CLIPVisionModelOutput with CLIP->Siglip
+class SiglipVisionModelOutput(ModelOutput):
+ r"""
+ image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
+ The image embeddings obtained by applying the projection layer to the pooler_output.
+ """
+
+ image_embeds: torch.FloatTensor | None = None
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for text model's outputs that also contains a pooling of the last hidden states.
+ """
+)
+@dataclass
+# Copied from transformers.models.clip.modeling_clip.CLIPTextModelOutput with CLIP->Siglip
+class SiglipTextModelOutput(ModelOutput):
+ r"""
+ text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
+ The text embeddings obtained by applying the projection layer to the pooler_output.
+ """
+
+ text_embeds: torch.FloatTensor | None = None
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring
+@dataclass
+# Copied from transformers.models.clip.modeling_clip.CLIPOutput with CLIP->Siglip
+class SiglipOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `return_loss` is `True`):
+ Contrastive loss for image-text similarity.
+ logits_per_image (`torch.FloatTensor` of shape `(image_batch_size, text_batch_size)`):
+ The scaled dot product scores between `image_embeds` and `text_embeds`. This represents the image-text
+ similarity scores.
+ logits_per_text (`torch.FloatTensor` of shape `(text_batch_size, image_batch_size)`):
+ The scaled dot product scores between `text_embeds` and `image_embeds`. This represents the text-image
+ similarity scores.
+ text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`):
+ The text embeddings obtained by applying the projection layer to the pooled output of [`SiglipTextModel`].
+ image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`):
+ The image embeddings obtained by applying the projection layer to the pooled output of [`SiglipVisionModel`].
+ text_model_output (`BaseModelOutputWithPooling`):
+ The output of the [`SiglipTextModel`].
+ vision_model_output (`BaseModelOutputWithPooling`):
+ The output of the [`SiglipVisionModel`].
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits_per_image: torch.FloatTensor | None = None
+ logits_per_text: torch.FloatTensor | None = None
+ text_embeds: torch.FloatTensor | None = None
+ image_embeds: torch.FloatTensor | None = None
+ text_model_output: BaseModelOutputWithPooling = None
+ vision_model_output: BaseModelOutputWithPooling = None
+
+ def to_tuple(self) -> tuple[Any]:
+ return tuple(v.to_tuple() if isinstance(v, ModelOutput) else v for v in self.values())
+
+
+class SiglipVisionEmbeddings(nn.Module):
+ def __init__(self, config: SiglipVisionConfig):
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.image_size = config.image_size
+ self.patch_size = config.patch_size
+
+ self.patch_embedding = nn.Conv2d(
+ in_channels=config.num_channels,
+ out_channels=self.embed_dim,
+ kernel_size=self.patch_size,
+ stride=self.patch_size,
+ padding="valid",
+ )
+
+ self.num_patches = (self.image_size // self.patch_size) ** 2
+ self.num_positions = self.num_patches
+ self.position_embedding = nn.Embedding(self.num_positions, self.embed_dim)
+ self.register_buffer("position_ids", torch.arange(self.num_positions).expand((1, -1)), persistent=False)
+
+ def interpolate_pos_encoding(self, embeddings: torch.Tensor, height: int, width: int) -> torch.Tensor:
+ """
+ This method allows to interpolate the pre-trained position encodings, to be able to use the model on higher resolution
+ images. This method is also adapted to support torch.jit tracing and no class embeddings.
+
+ Adapted from:
+ - https://github.com/facebookresearch/dino/blob/de9ee3df6cf39fac952ab558447af1fa1365362a/vision_transformer.py#L174-L194, and
+ - https://github.com/facebookresearch/dinov2/blob/e1277af2ba9496fbadf7aec6eba56e8d882d1e35/dinov2/models/vision_transformer.py#L179-L211
+ """
+
+ num_patches = embeddings.shape[1]
+ num_positions = self.position_embedding.weight.shape[0]
+
+ # always interpolate when tracing to ensure the exported model works for dynamic input shapes
+ if not torch.jit.is_tracing() and num_patches == num_positions and height == width:
+ return self.position_embedding(self.position_ids)
+
+ patch_pos_embed = self.position_embedding.weight.unsqueeze(0)
+
+ dim = embeddings.shape[-1]
+
+ new_height = height // self.patch_size
+ new_width = width // self.patch_size
+
+ sqrt_num_positions = torch_int(num_positions**0.5)
+ patch_pos_embed = patch_pos_embed.reshape(1, sqrt_num_positions, sqrt_num_positions, dim)
+ patch_pos_embed = patch_pos_embed.permute(0, 3, 1, 2)
+
+ patch_pos_embed = nn.functional.interpolate(
+ patch_pos_embed,
+ size=(new_height, new_width),
+ mode="bicubic",
+ align_corners=False,
+ )
+
+ patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+ return patch_pos_embed
+
+ def forward(self, pixel_values: torch.FloatTensor, interpolate_pos_encoding=False) -> torch.Tensor:
+ _, _, height, width = pixel_values.shape
+ target_dtype = self.patch_embedding.weight.dtype
+ patch_embeds = self.patch_embedding(pixel_values.to(dtype=target_dtype)) # shape = [*, width, grid, grid]
+ embeddings = patch_embeds.flatten(2).transpose(1, 2)
+
+ if interpolate_pos_encoding:
+ embeddings = embeddings + self.interpolate_pos_encoding(embeddings, height, width)
+ else:
+ embeddings = embeddings + self.position_embedding(self.position_ids)
+ return embeddings
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPTextEmbeddings with CLIP->Siglip
+class SiglipTextEmbeddings(nn.Module):
+ def __init__(self, config: SiglipTextConfig):
+ super().__init__()
+ embed_dim = config.hidden_size
+
+ self.token_embedding = nn.Embedding(config.vocab_size, embed_dim)
+ self.position_embedding = nn.Embedding(config.max_position_embeddings, embed_dim)
+
+ # position_ids (1, len position emb) is contiguous in memory and exported when serialized
+ self.register_buffer(
+ "position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)), persistent=False
+ )
+
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ ) -> torch.Tensor:
+ seq_length = input_ids.shape[-1] if input_ids is not None else inputs_embeds.shape[-2]
+ max_position_embedding = self.position_embedding.weight.shape[0]
+
+ if seq_length > max_position_embedding:
+ raise ValueError(
+ f"Sequence length must be less than max_position_embeddings (got `sequence length`: "
+ f"{seq_length} and max_position_embeddings: {max_position_embedding}"
+ )
+
+ if position_ids is None:
+ position_ids = self.position_ids[:, :seq_length]
+
+ if inputs_embeds is None:
+ inputs_embeds = self.token_embedding(input_ids)
+
+ position_embeddings = self.position_embedding(position_ids)
+ embeddings = inputs_embeds + position_embeddings
+
+ return embeddings
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float,
+ dropout: float = 0.0,
+ **kwargs,
+):
+ attn_weights = torch.matmul(query, key.transpose(-1, -2)) * scaling
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+class SiglipAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.num_heads = config.num_attention_heads
+ self.head_dim = self.embed_dim // self.num_heads
+ if self.head_dim * self.num_heads != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+ f" {self.num_heads})."
+ )
+ self.scale = self.head_dim**-0.5
+ self.dropout = config.attention_dropout
+ self.is_causal = False
+
+ self.k_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.v_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.q_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.out_proj = nn.Linear(self.embed_dim, self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ """Input shape: Batch x Time x Channel"""
+
+ input_shape = hidden_states.shape[:-1]
+
+ hidden_shape = (*input_shape, -1, self.head_dim)
+ queries = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ keys = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ values = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ queries,
+ keys,
+ values,
+ attention_mask,
+ is_causal=self.is_causal,
+ scaling=self.scale,
+ dropout=0.0 if not self.training else self.dropout,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPMLP with CLIP->Siglip
+class SiglipMLP(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.activation_fn = ACT2FN[config.hidden_act]
+ self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size)
+ self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.fc1(hidden_states)
+ hidden_states = self.activation_fn(hidden_states)
+ hidden_states = self.fc2(hidden_states)
+ return hidden_states
+
+
+class SiglipEncoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: SiglipVisionConfig | SiglipTextConfig):
+ super().__init__()
+ self.embed_dim = config.hidden_size
+ self.layer_norm1 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+ self.self_attn = SiglipAttention(config)
+ self.layer_norm2 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+ self.mlp = SiglipMLP(config)
+
+ @auto_docstring
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.FloatTensor:
+ residual = hidden_states
+
+ hidden_states = self.layer_norm1(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.layer_norm2(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = residual + hidden_states
+
+ return hidden_states
+
+
+@auto_docstring
+class SiglipPreTrainedModel(PreTrainedModel):
+ config: SiglipConfig
+ base_model_prefix = "siglip"
+ input_modalities = ("image", "text")
+ supports_gradient_checkpointing = True
+
+ _no_split_modules = [
+ "SiglipTextEmbeddings",
+ "SiglipVisionEmbeddings",
+ "SiglipEncoderLayer",
+ "SiglipMultiheadAttentionPoolingHead",
+ ]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+ _supports_attention_backend = True
+
+ _can_record_outputs = {
+ "hidden_states": SiglipEncoderLayer,
+ "attentions": SiglipAttention,
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ if isinstance(module, SiglipVisionEmbeddings):
+ width = (
+ self.config.vision_config.hidden_size
+ if isinstance(self.config, SiglipConfig)
+ else self.config.hidden_size
+ )
+ init.normal_(module.position_embedding.weight, std=1 / np.sqrt(width))
+ if hasattr(module, "position_ids"):
+ init.copy_(module.position_ids, torch.arange(module.position_ids.shape[-1]).expand((1, -1)))
+ elif isinstance(module, nn.Embedding):
+ init.default_flax_embed_init_(module.weight)
+ elif isinstance(module, SiglipAttention):
+ init.xavier_uniform_(module.q_proj.weight)
+ init.xavier_uniform_(module.k_proj.weight)
+ init.xavier_uniform_(module.v_proj.weight)
+ init.xavier_uniform_(module.out_proj.weight)
+ init.zeros_(module.q_proj.bias)
+ init.zeros_(module.k_proj.bias)
+ init.zeros_(module.v_proj.bias)
+ init.zeros_(module.out_proj.bias)
+ elif isinstance(module, SiglipMLP):
+ init.xavier_uniform_(module.fc1.weight)
+ init.xavier_uniform_(module.fc2.weight)
+ init.normal_(module.fc1.bias, std=1e-6)
+ init.normal_(module.fc2.bias, std=1e-6)
+ elif isinstance(module, SiglipMultiheadAttentionPoolingHead):
+ init.xavier_uniform_(module.probe)
+ init.xavier_uniform_(module.attention.in_proj_weight)
+ init.zeros_(module.attention.in_proj_bias)
+ elif isinstance(module, SiglipModel):
+ init.zeros_(module.logit_scale)
+ init.zeros_(module.logit_bias)
+ elif isinstance(module, SiglipForImageClassification):
+ init.normal_(
+ module.classifier.weight,
+ std=self.config.vision_config.hidden_size**-0.5 * self.config.initializer_factor,
+ )
+ elif isinstance(module, (nn.Linear, nn.Conv2d)):
+ init.lecun_normal_(module.weight)
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, nn.LayerNorm):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ elif isinstance(module, SiglipTextEmbeddings):
+ init.copy_(module.position_ids, torch.arange(module.position_ids.shape[-1]).expand((1, -1)))
+
+
+# Copied from transformers.models.altclip.modeling_altclip.AltCLIPEncoder with AltCLIP->Siglip
+class SiglipEncoder(nn.Module):
+ """
+ Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
+ [`SiglipEncoderLayer`].
+
+ Args:
+ config: SiglipConfig
+ """
+
+ def __init__(self, config: SiglipConfig):
+ super().__init__()
+ self.config = config
+ self.layers = nn.ModuleList([SiglipEncoderLayer(config) for _ in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ # Ignore copy
+ @auto_docstring
+ def forward(
+ self,
+ inputs_embeds,
+ attention_mask: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ hidden_states = inputs_embeds
+ for encoder_layer in self.layers:
+ hidden_states = encoder_layer(
+ hidden_states,
+ attention_mask,
+ **kwargs,
+ )
+
+ return BaseModelOutput(last_hidden_state=hidden_states)
+
+
+@auto_docstring(
+ custom_intro="""
+ The text model from SigLIP without any head or projection on top.
+ """
+)
+class SiglipTextModel(SiglipPreTrainedModel):
+ config: SiglipTextConfig
+ input_modalities = ("text",)
+ base_model_prefix = "text_model"
+ _input_embed_layer = "token_embedding"
+
+ def __init__(self, config: SiglipTextConfig):
+ super().__init__(config)
+ self.config = config
+ embed_dim = config.hidden_size
+ self.embeddings = SiglipTextEmbeddings(config)
+ self.encoder = SiglipEncoder(config)
+ self.final_layer_norm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
+
+ self.head = nn.Linear(embed_dim, config.projection_size)
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.Tensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPooling:
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, SiglipTextModel
+
+ >>> model = SiglipTextModel.from_pretrained("google/siglip-base-patch16-224")
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/siglip-base-patch16-224")
+
+ >>> # important: make sure to set padding="max_length" as that's how the model was trained
+ >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")
+
+ >>> outputs = model(**inputs)
+ >>> last_hidden_state = outputs.last_hidden_state
+ >>> pooled_output = outputs.pooler_output # pooled (EOS token) states
+ ```"""
+ if input_ids is None:
+ raise ValueError("You have to specify input_ids")
+
+ input_shape = input_ids.size()
+ input_ids = input_ids.view(-1, input_shape[-1])
+
+ hidden_states = self.embeddings(input_ids=input_ids, position_ids=position_ids)
+
+ # note: SigLIP's text model does not use a causal mask, unlike the original CLIP model.
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ )
+
+ encoder_outputs: BaseModelOutput = self.encoder(
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+
+ last_hidden_state = encoder_outputs.last_hidden_state
+ last_hidden_state = self.final_layer_norm(last_hidden_state)
+
+ # The model uses the last token's hidden state, which may be padding.
+ pooled_output = last_hidden_state[:, -1, :]
+ pooled_output = self.head(pooled_output)
+
+ return BaseModelOutputWithPooling(
+ last_hidden_state=last_hidden_state,
+ pooler_output=pooled_output,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ The vision model from SigLIP without any head or projection on top.
+ """
+)
+class SiglipVisionModel(SiglipPreTrainedModel):
+ config: SiglipVisionConfig
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ base_model_prefix = "vision_model"
+ _input_embed_layer = "patch_embedding"
+
+ def __init__(self, config: SiglipVisionConfig):
+ super().__init__(config)
+ self.config = config
+ embed_dim = config.hidden_size
+
+ self.embeddings = SiglipVisionEmbeddings(config)
+ self.encoder = SiglipEncoder(config)
+ self.post_layernorm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
+ self.use_head = True if not hasattr(config, "vision_use_head") else config.vision_use_head
+ if self.use_head:
+ self.head = SiglipMultiheadAttentionPoolingHead(config)
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values,
+ interpolate_pos_encoding: bool | None = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPooling:
+ r"""
+ Examples:
+
+ ```python
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> from PIL import Image
+ >>> from transformers import AutoProcessor, SiglipVisionModel
+
+ >>> model = SiglipVisionModel.from_pretrained("google/siglip-base-patch16-224")
+ >>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> inputs = processor(images=image, return_tensors="pt")
+
+ >>> outputs = model(**inputs)
+ >>> last_hidden_state = outputs.last_hidden_state
+ >>> pooled_output = outputs.pooler_output # pooled features
+ ```"""
+ hidden_states = self.embeddings(pixel_values, interpolate_pos_encoding=interpolate_pos_encoding)
+
+ encoder_outputs: BaseModelOutput = self.encoder(
+ inputs_embeds=hidden_states,
+ **kwargs,
+ )
+
+ last_hidden_state = encoder_outputs.last_hidden_state
+ last_hidden_state = self.post_layernorm(last_hidden_state)
+
+ pooler_output = self.head(last_hidden_state) if self.use_head else None
+
+ return BaseModelOutputWithPooling(
+ last_hidden_state=last_hidden_state,
+ pooler_output=pooler_output,
+ )
+
+
+class SiglipMultiheadAttentionPoolingHead(nn.Module):
+ """Multihead Attention Pooling."""
+
+ def __init__(self, config: SiglipVisionConfig):
+ super().__init__()
+
+ self.probe = nn.Parameter(torch.randn(1, 1, config.hidden_size))
+ self.attention = torch.nn.MultiheadAttention(config.hidden_size, config.num_attention_heads, batch_first=True)
+ self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.mlp = SiglipMLP(config)
+
+ def forward(self, hidden_state):
+ batch_size = hidden_state.shape[0]
+ probe = self.probe.repeat(batch_size, 1, 1)
+
+ hidden_state = self.attention(probe, hidden_state, hidden_state)[0]
+
+ residual = hidden_state
+ hidden_state = self.layernorm(hidden_state)
+ hidden_state = residual + self.mlp(hidden_state)
+
+ return hidden_state[:, 0]
+
+
+@auto_docstring
+class SiglipModel(SiglipPreTrainedModel):
+ config: SiglipConfig
+
+ def __init__(self, config: SiglipConfig):
+ super().__init__(config)
+
+ text_config = config.text_config
+ vision_config = config.vision_config
+
+ # First, initialize the text and vision models with proper attention implementation
+ self.text_model = SiglipTextModel._from_config(text_config)
+ self.vision_model = SiglipVisionModel._from_config(vision_config)
+
+ self.logit_scale = nn.Parameter(torch.randn(1))
+ self.logit_bias = nn.Parameter(torch.randn(1))
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self) -> nn.Module:
+ return self.text_model.embeddings.token_embedding
+
+ def set_input_embeddings(self, value: nn.Module):
+ self.text_model.embeddings.token_embedding = value
+
+ @can_return_tuple
+ @auto_docstring
+ def get_text_features(
+ self,
+ input_ids: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, AutoModel
+ >>> import torch
+
+ >>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/siglip-base-patch16-224")
+
+ >>> # important: make sure to set padding="max_length" as that's how the model was trained
+ >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")
+ >>> with torch.no_grad():
+ ... text_features = model.get_text_features(**inputs)
+ ```"""
+ return self.text_model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self,
+ pixel_values: torch.FloatTensor,
+ interpolate_pos_encoding: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ Examples:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoProcessor, AutoModel
+ >>> from transformers.image_utils import load_image
+
+ >>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
+ >>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> image = load_image(url)
+
+ >>> inputs = processor(images=image, return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... image_features = model.get_image_features(**inputs)
+ ```"""
+ return self.vision_model(
+ pixel_values=pixel_values,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ **kwargs,
+ )
+
+ # NOTE: SiglipModel uses Pretrained backbones, so we don't need to add `capture_outputs` here
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ return_loss: bool | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SiglipOutput:
+ r"""
+ return_loss (`bool`, *optional*):
+ Whether or not to return the contrastive loss.
+
+ Examples:
+
+ ```python
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> from transformers import AutoProcessor, AutoModel
+ >>> import torch
+
+ >>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
+ >>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> texts = ["a photo of 2 cats", "a photo of 2 dogs"]
+ >>> # important: we pass `padding=max_length` since the model was trained with this
+ >>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> logits_per_image = outputs.logits_per_image
+ >>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
+ >>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
+ 31.9% that image 0 is 'a photo of 2 cats'
+ ```"""
+ vision_outputs: BaseModelOutputWithPooling = self.vision_model(
+ pixel_values=pixel_values,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ **kwargs,
+ )
+
+ text_outputs: BaseModelOutputWithPooling = self.text_model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+
+ image_embeds = vision_outputs.pooler_output
+ text_embeds = text_outputs.pooler_output
+
+ # normalized features
+ image_embeds = image_embeds / image_embeds.norm(p=2, dim=-1, keepdim=True)
+ text_embeds = text_embeds / text_embeds.norm(p=2, dim=-1, keepdim=True)
+
+ # cosine similarity as logits
+ logits_per_text = torch.matmul(text_embeds, image_embeds.t().to(text_embeds.device))
+
+ logit_scale, logit_bias = self.logit_scale.to(text_embeds.device), self.logit_bias.to(text_embeds.device)
+ logits_per_text = logits_per_text * logit_scale.exp() + logit_bias
+
+ logits_per_image = logits_per_text.t()
+
+ loss = None
+ if return_loss:
+ # Adapted from https://github.com/google-research/big_vision/blob/01edb81a4716f93a48be43b3a4af14e29cdb3a7f/big_vision/trainers/proj/image_text/siglip.py#L287
+ eye = torch.eye(logits_per_text.size(0), device=logits_per_text.device)
+ m1_diag1 = -torch.ones_like(logits_per_text) + 2 * eye
+ loglik = torch.nn.functional.logsigmoid(m1_diag1 * logits_per_text)
+ nll = -torch.sum(loglik, dim=-1)
+ loss = nll.mean()
+
+ return SiglipOutput(
+ loss=loss,
+ logits_per_image=logits_per_image,
+ logits_per_text=logits_per_text,
+ text_embeds=text_embeds,
+ image_embeds=image_embeds,
+ text_model_output=text_outputs,
+ vision_model_output=vision_outputs,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ SigLIP vision encoder with an image classification head on top (a linear layer on top of the pooled final hidden states of
+ the patch tokens) e.g. for ImageNet.
+ """
+)
+class SiglipForImageClassification(SiglipPreTrainedModel):
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+
+ def __init__(self, config: SiglipConfig) -> None:
+ super().__init__(config)
+
+ self.num_labels = config.num_labels
+ self.vision_model = SiglipVisionModel._from_config(config.vision_config)
+
+ # Classifier head
+ self.classifier = (
+ nn.Linear(config.vision_config.hidden_size, config.num_labels) if config.num_labels > 0 else nn.Identity()
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self) -> nn.Module:
+ return self.vision_model.embeddings.patch_embedding
+
+ def set_input_embeddings(self, value: nn.Module):
+ self.vision_model.embeddings.patch_embedding = value
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor | None = None,
+ labels: torch.Tensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> ImageClassifierOutput:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, SiglipForImageClassification
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> torch.manual_seed(3) # doctest: +IGNORE_RESULT
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> # note: we are loading a `SiglipModel` from the hub here,
+ >>> # so the head will be randomly initialized, hence the predictions will be random if seed is not set above.
+ >>> image_processor = AutoImageProcessor.from_pretrained("google/siglip-base-patch16-224")
+ >>> model = SiglipForImageClassification.from_pretrained("google/siglip-base-patch16-224")
+
+ >>> inputs = image_processor(images=image, return_tensors="pt")
+ >>> outputs = model(**inputs)
+ >>> logits = outputs.logits
+ >>> # model predicts one of the two classes
+ >>> predicted_class_idx = logits.argmax(-1).item()
+ >>> print("Predicted class:", model.config.id2label[predicted_class_idx])
+ Predicted class: LABEL_1
+ ```"""
+ outputs: BaseModelOutputWithPooling = self.vision_model(
+ pixel_values,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ **kwargs,
+ )
+
+ sequence_output = outputs.last_hidden_state
+
+ # average pool the patch tokens
+ sequence_output = torch.mean(sequence_output, dim=1)
+ # apply classifier
+ logits = self.classifier(sequence_output)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config)
+
+ return ImageClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "SiglipModel",
+ "SiglipPreTrainedModel",
+ "SiglipTextModel",
+ "SiglipVisionModel",
+ "SiglipForImageClassification",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/processing_siglip.py b/lib/python3.11/site-packages/transformers/models/siglip/processing_siglip.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e554b22ce3241a056880faece92515460b63c81
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip/processing_siglip.py
@@ -0,0 +1,28 @@
+# Copyright 2024 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.
+"""
+Image/Text processor class for SigLIP.
+"""
+
+from ...processing_utils import ProcessorMixin
+from ...utils import auto_docstring
+
+
+@auto_docstring
+class SiglipProcessor(ProcessorMixin):
+ def __init__(self, image_processor, tokenizer):
+ super().__init__(image_processor, tokenizer)
+
+
+__all__ = ["SiglipProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip/tokenization_siglip.py b/lib/python3.11/site-packages/transformers/models/siglip/tokenization_siglip.py
new file mode 100644
index 0000000000000000000000000000000000000000..001da7cbb6175b7183e9c2284db02f3c9cbc7bb0
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip/tokenization_siglip.py
@@ -0,0 +1,352 @@
+# Copyright 2024 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.
+"""Tokenization class for SigLIP model."""
+
+import os
+import re
+import string
+import warnings
+from shutil import copyfile
+from typing import TYPE_CHECKING, Any
+
+import sentencepiece as spm
+
+from ...tokenization_utils_base import AddedToken
+from ...tokenization_utils_sentencepiece import SentencePieceBackend
+
+
+if TYPE_CHECKING:
+ from ...tokenization_utils_base import TextInput
+from ...utils import logging, requires_backends
+from ...utils.import_utils import requires
+
+
+logger = logging.get_logger(__name__)
+
+VOCAB_FILES_NAMES = {"vocab_file": "spiece.model"}
+
+
+SPIECE_UNDERLINE = "▁"
+
+
+@requires(backends=("sentencepiece",))
+class SiglipTokenizer(SentencePieceBackend):
+ """
+ Construct a Siglip tokenizer. Based on [SentencePiece](https://github.com/google/sentencepiece).
+
+ This tokenizer inherits from [`PreTrainedTokenizer`] which contains most of the main methods. Users should refer to
+ this superclass for more information regarding those methods.
+
+ Args:
+ vocab_file (`str`):
+ [SentencePiece](https://github.com/google/sentencepiece) file (generally has a *.spm* extension) that
+ contains the vocabulary necessary to instantiate a tokenizer.
+ eos_token (`str`, *optional*, defaults to `"</s>"`):
+ The end of sequence token.
+ unk_token (`str`, *optional*, defaults to `"<unk>"`):
+ The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
+ token instead.
+ pad_token (`str`, *optional*, defaults to `"</s>"`):
+ The token used for padding, for example when batching sequences of different lengths.
+ additional_special_tokens (`list[str]`, *optional*):
+ Additional special tokens used by the tokenizer.
+ sp_model_kwargs (`dict`, *optional*):
+ Will be passed to the `SentencePieceProcessor.__init__()` method. The [Python wrapper for
+ SentencePiece](https://github.com/google/sentencepiece/tree/master/python) can be used, among other things,
+ to set:
+
+ - `enable_sampling`: Enable subword regularization.
+ - `nbest_size`: Sampling parameters for unigram. Invalid for BPE-Dropout.
+
+ - `nbest_size = {0,1}`: No sampling is performed.
+ - `nbest_size > 1`: samples from the nbest_size results.
+ - `nbest_size < 0`: assuming that nbest_size is infinite and samples from the all hypothesis (lattice)
+ using forward-filtering-and-backward-sampling algorithm.
+
+ - `alpha`: Smoothing parameter for unigram sampling, and dropout probability of merge operations for
+ BPE-dropout.
+ model_max_length (`int`, *optional*, defaults to 64):
+ The maximum length (in number of tokens) for model inputs.
+ do_lower_case (`bool`, *optional*, defaults to `True`):
+ Whether or not to lowercase the input when tokenizing.
+ """
+
+ vocab_files_names = VOCAB_FILES_NAMES
+ model_input_names = ["input_ids", "attention_mask"]
+
+ def __init__(
+ self,
+ vocab_file,
+ eos_token="</s>",
+ unk_token="<unk>",
+ pad_token="</s>",
+ additional_special_tokens=None,
+ sp_model_kwargs: dict[str, Any] | None = None,
+ model_max_length=64,
+ do_lower_case=True,
+ **kwargs,
+ ) -> None:
+ requires_backends(self, "protobuf")
+
+ pad_token = (
+ AddedToken(pad_token, rstrip=True, lstrip=True, normalized=False, special=True)
+ if isinstance(pad_token, str)
+ else pad_token
+ )
+ unk_token = (
+ AddedToken(unk_token, rstrip=True, lstrip=True, normalized=False, special=True)
+ if isinstance(unk_token, str)
+ else unk_token
+ )
+ eos_token = (
+ AddedToken(eos_token, rstrip=True, lstrip=True, normalized=False, special=True)
+ if isinstance(eos_token, str)
+ else eos_token
+ )
+
+ self.sp_model_kwargs = {} if sp_model_kwargs is None else sp_model_kwargs
+ self.do_lower_case = do_lower_case
+
+ super().__init__(
+ vocab_file=vocab_file,
+ eos_token=eos_token,
+ unk_token=unk_token,
+ pad_token=pad_token,
+ additional_special_tokens=additional_special_tokens,
+ sp_model_kwargs=self.sp_model_kwargs,
+ model_max_length=model_max_length,
+ do_lower_case=do_lower_case,
+ **kwargs,
+ )
+
+ @property
+ def vocab_size(self):
+ return self.sp_model.get_piece_size()
+
+ def get_vocab(self):
+ vocab = {self.convert_ids_to_tokens(i): i for i in range(self.vocab_size)}
+ vocab.update(self.added_tokens_encoder)
+ return vocab
+
+ def get_special_tokens_mask(
+ self, token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False
+ ) -> list[int]:
+ """
+ Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
+ special tokens using the tokenizer `prepare_for_model` method.
+
+ Args:
+ token_ids_0 (`list[int]`):
+ List of IDs.
+ token_ids_1 (`list[int]`, *optional*):
+ Optional second list of IDs for sequence pairs.
+ already_has_special_tokens (`bool`, *optional*, defaults to `False`):
+ Whether or not the token list is already formatted with special tokens for the model.
+
+ Returns:
+ `list[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
+ """
+ if already_has_special_tokens:
+ return super().get_special_tokens_mask(
+ token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
+ )
+
+ # normal case: some special tokens
+ if token_ids_1 is None:
+ return ([0] * len(token_ids_0)) + [1]
+ return ([0] * len(token_ids_0)) + [1] + ([0] * len(token_ids_1)) + [1]
+
+ def _add_eos_if_not_present(self, token_ids: list[int]) -> list[int]:
+ """Do not add eos again if user already added it."""
+ if len(token_ids) > 0 and token_ids[-1] == self.eos_token_id:
+ warnings.warn(
+ f"This sequence already has {self.eos_token}. In future versions this behavior may lead to duplicated"
+ " eos tokens being added."
+ )
+ return token_ids
+ else:
+ return token_ids + [self.eos_token_id]
+
+ def create_token_type_ids_from_sequences(
+ self, token_ids_0: list[int], token_ids_1: list[int] | None = None
+ ) -> list[int]:
+ """
+ Create a mask from the two sequences passed to be used in a sequence-pair classification task. T5 does not make
+ use of token type ids, therefore a list of zeros is returned.
+
+ Args:
+ token_ids_0 (`list[int]`):
+ List of IDs.
+ token_ids_1 (`list[int]`, *optional*):
+ Optional second list of IDs for sequence pairs.
+
+ Returns:
+ `list[int]`: List of zeros.
+ """
+ eos = [self.eos_token_id]
+
+ if token_ids_1 is None:
+ return len(token_ids_0 + eos) * [0]
+ return len(token_ids_0 + eos + token_ids_1 + eos) * [0]
+
+ def build_inputs_with_special_tokens(
+ self, token_ids_0: list[int], token_ids_1: list[int] | None = None
+ ) -> list[int]:
+ """
+ Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
+ adding special tokens. A sequence has the following format:
+
+ - single sequence: `X </s>`
+ - pair of sequences: `A </s> B </s>`
+
+ Args:
+ token_ids_0 (`list[int]`):
+ List of IDs to which the special tokens will be added.
+ token_ids_1 (`list[int]`, *optional*):
+ Optional second list of IDs for sequence pairs.
+
+ Returns:
+ `list[int]`: List of [input IDs](../glossary#input-ids) with the appropriate special tokens.
+ """
+ token_ids_0 = self._add_eos_if_not_present(token_ids_0)
+ if token_ids_1 is None:
+ return token_ids_0
+ else:
+ token_ids_1 = self._add_eos_if_not_present(token_ids_1)
+ return token_ids_0 + token_ids_1
+
+ def __getstate__(self):
+ state = self.__dict__.copy()
+ state["sp_model"] = None
+ return state
+
+ def __setstate__(self, d):
+ self.__dict__ = d
+
+ # for backward compatibility
+ if not hasattr(self, "sp_model_kwargs"):
+ self.sp_model_kwargs = {}
+
+ self.sp_model = spm.SentencePieceProcessor(**self.sp_model_kwargs)
+ self.sp_model.Load(self.vocab_file)
+
+ def remove_punctuation(self, text: str) -> str:
+ return text.translate(str.maketrans("", "", string.punctuation))
+
+ # source: https://github.com/google-research/big_vision/blob/3b8e5ab6ad4f96e32b32826f9e1b8fd277914f9c/big_vision/evaluators/proj/image_text/prompt_engineering.py#L94
+ def canonicalize_text(self, text, *, keep_punctuation_exact_string=None):
+ """Returns canonicalized `text` (puncuation removed).
+
+ Args:
+ text (`str`):
+ String to be canonicalized.
+ keep_punctuation_exact_string (`str`, *optional*):
+ If provided, then this exact string is kept. For example providing '{}' will keep any occurrences of '{}'
+ (but will still remove '{' and '}' that appear separately).
+ """
+ if self.do_lower_case:
+ text = text.lower()
+
+ if keep_punctuation_exact_string:
+ text = keep_punctuation_exact_string.join(
+ self.remove_punctuation(part) for part in text.split(keep_punctuation_exact_string)
+ )
+ else:
+ text = self.remove_punctuation(text)
+ text = re.sub(r"\s+", " ", text)
+ text = text.strip()
+
+ return text
+
+ def tokenize(self, text: "TextInput", add_special_tokens=False, **kwargs) -> list[str]:
+ """
+ Converts a string to a list of tokens.
+ """
+ tokens = super().tokenize(SPIECE_UNDERLINE + text.replace(SPIECE_UNDERLINE, " "), **kwargs)
+
+ if len(tokens) > 1 and tokens[0] == SPIECE_UNDERLINE and tokens[1] in self.all_special_tokens:
+ tokens = tokens[1:]
+ return tokens
+
+ @property
+ def unk_token_length(self):
+ return len(self.sp_model.encode(str(self.unk_token)))
+
+ def _tokenize(self, text, **kwargs):
+ """
+ Returns a tokenized string.
+
+ We de-activated the `add_dummy_prefix` option, thus the sentencepiece internals will always strip any
+ SPIECE_UNDERLINE.
+
+ For example: `self.sp_model.encode(f"{SPIECE_UNDERLINE}Hey", out_type = str)` will give `['H', 'e', 'y']` instead of `['▁He', 'y']`.
+
+ Thus we always encode `f"{unk_token}text"` and strip the `unk_token`. Here is an example with `unk_token = "<unk>"` and `unk_token_length = 4`.
+ `self.tokenizer.sp_model.encode("<unk> Hey", out_type = str)[4:]`.
+ """
+ text = self.canonicalize_text(text, keep_punctuation_exact_string=None)
+ tokens = self.sp_model.encode(text, out_type=str)
+
+ # 1. Encode string + prefix ex: "<unk> Hey"
+ tokens = self.sp_model.encode(self.unk_token + text, out_type=str)
+ # 2. Remove self.unk_token from ['<','unk','>', '▁Hey']
+ return tokens[self.unk_token_length :] if len(tokens) >= self.unk_token_length else tokens
+
+ def _convert_token_to_id(self, token):
+ """Converts a token (str) in an id using the vocab."""
+ return self.sp_model.piece_to_id(token)
+
+ def _convert_id_to_token(self, index):
+ """Converts an index (integer) in a token (str) using the vocab."""
+ token = self.sp_model.IdToPiece(index)
+ return token
+
+ def convert_tokens_to_string(self, tokens):
+ """Converts a sequence of tokens (string) in a single string."""
+ current_sub_tokens = []
+ out_string = ""
+ prev_is_special = False
+ for token in tokens:
+ # make sure that special tokens are not decoded using sentencepiece model
+ if token in self.all_special_tokens:
+ if not prev_is_special:
+ out_string += " "
+ out_string += self.sp_model.decode(current_sub_tokens) + token
+ prev_is_special = True
+ current_sub_tokens = []
+ else:
+ current_sub_tokens.append(token)
+ prev_is_special = False
+ out_string += self.sp_model.decode(current_sub_tokens)
+ return out_string.strip()
+
+ def save_vocabulary(self, save_directory: str, filename_prefix: str | None = None) -> tuple[str]:
+ if not os.path.isdir(save_directory):
+ logger.error(f"Vocabulary path ({save_directory}) should be a directory")
+ return
+ out_vocab_file = os.path.join(
+ save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]
+ )
+
+ if os.path.abspath(self.vocab_file) != os.path.abspath(out_vocab_file) and os.path.isfile(self.vocab_file):
+ copyfile(self.vocab_file, out_vocab_file)
+ elif not os.path.isfile(self.vocab_file):
+ with open(out_vocab_file, "wb") as fi:
+ content_spiece_model = self.sp_model.serialized_model_proto()
+ fi.write(content_spiece_model)
+
+ return (out_vocab_file,)
+
+
+__all__ = ["SiglipTokenizer"]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/__init__.py b/lib/python3.11/site-packages/transformers/models/siglip2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c1267a05125b92eecff931d6f415c15a043bdb9
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip2/__init__.py
@@ -0,0 +1,31 @@
+# Copyright 2025 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_siglip2 import *
+ from .image_processing_pil_siglip2 import *
+ from .image_processing_siglip2 import *
+ from .modeling_siglip2 import *
+ from .processing_siglip2 import *
+ from .tokenization_siglip2 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c1ef5ad65456c5989bbc1b1bd4e131afcbbe5de3
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/configuration_siglip2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/configuration_siglip2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0fdbc7b9a89d61a0311acef97bd46d05c7f91872
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/configuration_siglip2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/image_processing_pil_siglip2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/image_processing_pil_siglip2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8cbc818b65e8d4b05426d453d6938b891daad5ce
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/image_processing_pil_siglip2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/image_processing_siglip2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/image_processing_siglip2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9934bb69682f3dba1be358ba5da5b8e5320274eb
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/image_processing_siglip2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/modeling_siglip2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/modeling_siglip2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..936d3e8574b5a574141948887de37904f396ffe9
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/modeling_siglip2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/modular_siglip2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/modular_siglip2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..32df71bfc6a432a145a00681cec24d71e7875afd
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/modular_siglip2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/processing_siglip2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/processing_siglip2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6833fa4565d676fb9e04c7ca852b6efc4fcbfe4b
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/processing_siglip2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/tokenization_siglip2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/tokenization_siglip2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..39cc4d81fe7d653db71f49fed8503839d8d457f2
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/siglip2/__pycache__/tokenization_siglip2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/configuration_siglip2.py b/lib/python3.11/site-packages/transformers/models/siglip2/configuration_siglip2.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb00f285c42219b535e45667156d52734e4d5c9c
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip2/configuration_siglip2.py
@@ -0,0 +1,166 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/siglip2/modular_siglip2.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_siglip2.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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.
+
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="google/siglip2-base-patch16-naflex")
+@strict
+class Siglip2TextConfig(PreTrainedConfig):
+ r"""
+ Example:
+
+ ```python
+ >>> from transformers import Siglip2TextConfig, Siglip2TextModel
+
+ >>> # Initializing a Siglip2TextConfig with google/siglip2-base-patch16-224 style configuration
+ >>> configuration = Siglip2TextConfig()
+
+ >>> # Initializing a Siglip2TextModel (with random weights) from the google/siglip2-base-patch16-224 style configuration
+ >>> model = Siglip2TextModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "siglip2_text_model"
+ base_config_key = "text_config"
+
+ vocab_size: int = 32000
+ hidden_size: int = 768
+ intermediate_size: int = 3072
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ max_position_embeddings: int = 64
+ hidden_act: str = "gelu_pytorch_tanh"
+ layer_norm_eps: float = 1e-6
+ attention_dropout: float | int = 0.0
+ # This differs from `CLIPTokenizer`'s default and from openai/siglip2
+ # See https://github.com/huggingface/transformers/pull/24773#issuecomment-1632287538
+ pad_token_id: int | None = 1
+ bos_token_id: int | None = 49406
+ eos_token_id: int | list[int] | None = 49407
+ projection_size: int | None = None
+
+ def __post_init__(self, **kwargs):
+ self.projection_size = self.projection_size if self.projection_size is not None else self.hidden_size
+ super().__post_init__(**kwargs)
+
+
+@auto_docstring(checkpoint="google/siglip2-base-patch16-naflex")
+@strict
+class Siglip2VisionConfig(PreTrainedConfig):
+ r"""
+ num_patches (`int`, *optional*, defaults to 256):
+ The number of patches in the image with the size of (`patch_size`, `patch_size`).
+ The image is resized to fill maximum of this number of patches, and to preserve
+ the aspect ratio. In case the resulted number of patches is lower, the image is
+ padded in "patch" dimension.
+
+ Example:
+
+ ```python
+ >>> from transformers import Siglip2VisionConfig, Siglip2VisionModel
+
+ >>> # Initializing a Siglip2VisionConfig with google/siglip2-base-patch16-naflex style configuration
+ >>> configuration = Siglip2VisionConfig()
+
+ >>> # Initializing a Siglip2VisionModel (with random weights) from the google/siglip2-base-patch16-naflex style configuration
+ >>> model = Siglip2VisionModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "siglip2_vision_model"
+ base_config_key = "vision_config"
+
+ hidden_size: int = 768
+ intermediate_size: int = 3072
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ num_channels: int = 3
+ patch_size: int | list[int] | tuple[int, int] = 16
+ hidden_act: str = "gelu_pytorch_tanh"
+ layer_norm_eps: float = 1e-6
+ attention_dropout: float | int = 0.0
+
+ num_patches: int = 256
+
+
+@auto_docstring(checkpoint="google/siglip2-base-patch16-naflex")
+@strict
+class Siglip2Config(PreTrainedConfig):
+ r"""
+ Example:
+
+ ```python
+ >>> from transformers import Siglip2Config, Siglip2Model
+
+ >>> # Initializing a Siglip2Config with google/siglip2-base-patch16-224 style configuration
+ >>> configuration = Siglip2Config()
+
+ >>> # Initializing a Siglip2Model (with random weights) from the google/siglip2-base-patch16-224 style configuration
+ >>> model = Siglip2Model(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+
+ >>> # We can also initialize a Siglip2Config from a Siglip2TextConfig and a Siglip2VisionConfig
+ >>> from transformers import Siglip2TextConfig, Siglip2VisionConfig
+
+ >>> # Initializing a Siglip2Text and Siglip2Vision configuration
+ >>> config_text = Siglip2TextConfig()
+ >>> config_vision = Siglip2VisionConfig()
+
+ >>> config = Siglip2Config(text_config=config_text, vision_config=config_vision)
+ ```"""
+
+ model_type = "siglip2"
+ sub_configs = {"text_config": Siglip2TextConfig, "vision_config": Siglip2VisionConfig}
+
+ text_config: dict | PreTrainedConfig | None = None
+ vision_config: dict | PreTrainedConfig | None = None
+ initializer_factor: float = 1.0
+
+ def __post_init__(self, **kwargs):
+ if self.text_config is None:
+ self.text_config = Siglip2TextConfig()
+ logger.info("`text_config` is `None`. Initializing the `Siglip2TextConfig` with default values.")
+ elif isinstance(self.text_config, dict):
+ self.text_config = Siglip2TextConfig(**self.text_config)
+
+ if self.vision_config is None:
+ self.vision_config = Siglip2VisionConfig()
+ logger.info("`vision_config` is `None`. initializing the `Siglip2VisionConfig` with default values.")
+ elif isinstance(self.vision_config, dict):
+ self.vision_config = Siglip2VisionConfig(**self.vision_config)
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["Siglip2Config", "Siglip2TextConfig", "Siglip2VisionConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/image_processing_pil_siglip2.py b/lib/python3.11/site-packages/transformers/models/siglip2/image_processing_pil_siglip2.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ae926dbe04d0a206bed361a648fea34c2314280
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip2/image_processing_pil_siglip2.py
@@ -0,0 +1,201 @@
+# Copyright 2025 The HuggingFace Inc. 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.
+"""Image processor class for SigLIP2."""
+
+import numpy as np
+
+from ...image_processing_backends import PilBackend
+from ...image_processing_utils import BatchFeature
+from ...image_utils import ImageInput, PILImageResampling, SizeDict
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import (
+ TensorType,
+ auto_docstring,
+)
+
+
+def convert_image_to_patches(image: np.ndarray, patch_size: int) -> np.ndarray:
+ """
+ Convert 3D array image of shape (num_channels, image_height, image_width) into 2D array of patches of shape
+ (num_patches_height * num_patches_width, patch_size * patch_size * num_channels).
+ """
+ num_channels, image_height, image_width = image.shape
+ num_patches_height = image_height // patch_size
+ num_patches_width = image_width // patch_size
+ patched_image = image.reshape(num_channels, num_patches_height, patch_size, num_patches_width, patch_size)
+ patched_image = patched_image.transpose(1, 3, 2, 4, 0)
+ patched_image = patched_image.reshape(num_patches_height * num_patches_width, -1)
+ return patched_image
+
+
+def pad_along_first_dim(array: np.ndarray, target_length: int, pad_value: int = 0) -> tuple[np.ndarray, np.ndarray]:
+ """
+ Pad the array along the first dimension.
+ """
+ current_length = array.shape[0]
+ padding_length = target_length - current_length
+ mask = np.ones((target_length,), dtype=np.int32)
+ if padding_length > 0:
+ paddings = [(0, padding_length)] + [(0, 0)] * (array.ndim - 1)
+ array = np.pad(array, paddings, mode="constant", constant_values=pad_value)
+ mask[-padding_length:] = 0
+ return array, mask
+
+
+# Adapted from transformers.models.siglip2.image_processing_siglip2.Siglip2ImageProcessorKwargs
+class Siglip2ImageProcessorKwargs(ImagesKwargs, total=False):
+ r"""
+ patch_size (`int`, *optional*, defaults to `self.patch_size`):
+ The size (resolution) of each patch the image will be split to.
+ max_num_patches (`int`, *optional*, defaults to `self.max_num_patches`):
+ The image will be resized to have at most this number of patches,
+ and then padded in "patch" dimension to match this number exactly.
+ """
+
+ patch_size: int
+ max_num_patches: int
+
+
+# Adapted from transformers.models.siglip2.image_processing_siglip2.get_image_size_for_max_num_patches
+def get_image_size_for_max_num_patches(
+ image_height: int, image_width: int, patch_size: int, max_num_patches: int, eps: float = 1e-5
+) -> tuple[int, int]:
+ """
+ Determine image size based on max number of patches, ensure dimensions are divisible by patch size and image is at least 1 patch.
+
+ Args:
+ image_height (`int`):
+ Original image height.
+ image_width (`int`):
+ Original image width.
+ patch_size (`int`):
+ Patch size for processing.
+ max_num_patches (`int`):
+ Maximum number of patches.
+ eps (`float`):
+ Small threshold for binary search.
+
+ Returns:
+ Tuple: (target_height, target_width)
+ """
+ import math
+
+ def get_scaled_image_size(scale: float, size: int, patch_size: int) -> int:
+ scaled_size = size * scale
+ scaled_size = math.ceil(scaled_size / patch_size) * patch_size # make divisible by patch_size
+ scaled_size = max(patch_size, scaled_size) # ensure at least 1 patch
+ return int(scaled_size)
+
+ # Binary search for optimal scale
+ scale_min, scale_max = eps / 10, 100.0
+ while (scale_max - scale_min) >= eps:
+ scale = (scale_min + scale_max) / 2
+ target_height = get_scaled_image_size(scale, image_height, patch_size)
+ target_width = get_scaled_image_size(scale, image_width, patch_size)
+ num_patches = (target_height / patch_size) * (target_width / patch_size)
+
+ if num_patches <= max_num_patches:
+ scale_min = scale
+ else:
+ scale_max = scale
+
+ scale = scale_min
+ target_height = get_scaled_image_size(scale, image_height, patch_size)
+ target_width = get_scaled_image_size(scale, image_width, patch_size)
+ return target_height, target_width
+
+
+@auto_docstring
+class Siglip2ImageProcessorPil(PilBackend):
+ valid_kwargs = Siglip2ImageProcessorKwargs
+ resample = PILImageResampling.BILINEAR
+ image_mean = [0.5, 0.5, 0.5]
+ image_std = [0.5, 0.5, 0.5]
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ patch_size = 16
+ max_num_patches = 256
+ model_input_names = ["pixel_values", "pixel_attention_mask", "spatial_shapes"]
+
+ def __init__(self, **kwargs: Unpack[Siglip2ImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(self, images: ImageInput, **kwargs: Unpack[Siglip2ImageProcessorKwargs]) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def _validate_preprocess_kwargs(self, **kwargs) -> tuple:
+ # Remove do_resize from kwargs to not raise an error as size is None (computed dynamically)
+ kwargs.pop("do_resize", None)
+ return super()._validate_preprocess_kwargs(**kwargs)
+
+ def _preprocess(
+ self,
+ images: list[np.ndarray],
+ do_resize: bool,
+ patch_size: int,
+ max_num_patches: int,
+ resample: "PILImageResampling | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ pixel_masks = []
+ pixel_values = []
+ spatial_shapes = []
+
+ for image in images:
+ if do_resize:
+ height, width = get_image_size_for_max_num_patches(
+ image_height=image.shape[-2],
+ image_width=image.shape[-1],
+ patch_size=patch_size,
+ max_num_patches=max_num_patches,
+ )
+ size_dict = SizeDict(height=height, width=width)
+ image = self.resize(image=image, size=size_dict, resample=resample)
+
+ if do_rescale:
+ image = self.rescale(image, rescale_factor)
+ if do_normalize:
+ image = self.normalize(image, image_mean, image_std)
+
+ # (num_channels, height, width) -> (num_patches, patch_size * patch_size * num_channels)
+ patches = convert_image_to_patches(image, patch_size)
+ patches, mask = pad_along_first_dim(patches, max_num_patches)
+
+ num_patches_height = image.shape[-2] // patch_size
+ num_patches_width = image.shape[-1] // patch_size
+
+ spatial_shapes.append((num_patches_height, num_patches_width))
+ pixel_values.append(patches)
+ pixel_masks.append(mask)
+
+ batch_feature = BatchFeature(
+ data={
+ "pixel_values": pixel_values,
+ "pixel_attention_mask": pixel_masks,
+ "spatial_shapes": spatial_shapes,
+ },
+ tensor_type=return_tensors,
+ )
+ return batch_feature
+
+
+__all__ = ["Siglip2ImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/image_processing_siglip2.py b/lib/python3.11/site-packages/transformers/models/siglip2/image_processing_siglip2.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e21a6e34ad71742e0319668345d68eb9413fc2b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip2/image_processing_siglip2.py
@@ -0,0 +1,199 @@
+# Copyright 2025 The HuggingFace Inc. 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.
+"""Image processor class for SigLIP2."""
+
+import torch
+from torchvision.transforms.v2 import functional as tvF
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_utils import ImageInput, PILImageResampling, SizeDict
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import (
+ TensorType,
+ auto_docstring,
+)
+
+
+class Siglip2ImageProcessorKwargs(ImagesKwargs, total=False):
+ r"""
+ patch_size (`int`, *optional*, defaults to `self.patch_size`):
+ The size (resolution) of each patch the image will be split to.
+ max_num_patches (`int`, *optional*, defaults to `self.max_num_patches`):
+ The image will be resized to have at most this number of patches,
+ and then padded in "patch" dimension to match this number exactly.
+ """
+
+ patch_size: int
+ max_num_patches: int
+
+
+def get_image_size_for_max_num_patches(
+ image_height: int, image_width: int, patch_size: int, max_num_patches: int, eps: float = 1e-5
+) -> tuple[int, int]:
+ """
+ Determine image size based on max number of patches, ensure dimensions are divisible by patch size and image is at least 1 patch.
+
+ Args:
+ image_height (`int`):
+ Original image height.
+ image_width (`int`):
+ Original image width.
+ patch_size (`int`):
+ Patch size for processing.
+ max_num_patches (`int`):
+ Maximum number of patches.
+ eps (`float`):
+ Small threshold for binary search.
+
+ Returns:
+ Tuple: (target_height, target_width)
+ """
+ import math
+
+ def get_scaled_image_size(scale: float, size: int, patch_size: int) -> int:
+ scaled_size = size * scale
+ scaled_size = math.ceil(scaled_size / patch_size) * patch_size # make divisible by patch_size
+ scaled_size = max(patch_size, scaled_size) # ensure at least 1 patch
+ return int(scaled_size)
+
+ # Binary search for optimal scale
+ scale_min, scale_max = eps / 10, 100.0
+ while (scale_max - scale_min) >= eps:
+ scale = (scale_min + scale_max) / 2
+ target_height = get_scaled_image_size(scale, image_height, patch_size)
+ target_width = get_scaled_image_size(scale, image_width, patch_size)
+ num_patches = (target_height / patch_size) * (target_width / patch_size)
+
+ if num_patches <= max_num_patches:
+ scale_min = scale
+ else:
+ scale_max = scale
+
+ scale = scale_min
+ target_height = get_scaled_image_size(scale, image_height, patch_size)
+ target_width = get_scaled_image_size(scale, image_width, patch_size)
+ return target_height, target_width
+
+
+def convert_image_to_patches(image: "torch.Tensor", patch_size: int) -> "torch.Tensor":
+ """
+ Convert 3D tensor image of shape (num_channels, image_height, image_width) into 2D tensor of patches of shape
+ (num_patches_height * num_patches_width, patch_size * patch_size * num_channels).
+ """
+ num_channels, image_height, image_width = image.shape
+ num_patches_height = image_height // patch_size
+ num_patches_width = image_width // patch_size
+ patched_image = image.reshape(num_channels, num_patches_height, patch_size, num_patches_width, patch_size)
+ patched_image = patched_image.permute(1, 3, 2, 4, 0)
+ patched_image = patched_image.reshape(num_patches_height * num_patches_width, -1)
+ return patched_image
+
+
+def pad_along_first_dim(
+ tensor: "torch.Tensor", target_length: int, pad_value: int = 0
+) -> tuple["torch.Tensor", "torch.Tensor"]:
+ """
+ Pad the tensor along the first dimension.
+ """
+ current_length = tensor.shape[0]
+ padding_length = target_length - current_length
+ mask = torch.ones((target_length,), dtype=torch.int32)
+ if padding_length > 0:
+ padding = [0, 0] * (tensor.ndim - 1) + [0, padding_length]
+ tensor = torch.nn.functional.pad(tensor, padding, mode="constant", value=pad_value)
+ mask[-padding_length:] = 0
+ return tensor, mask
+
+
+@auto_docstring
+class Siglip2ImageProcessor(TorchvisionBackend):
+ valid_kwargs = Siglip2ImageProcessorKwargs
+ resample = PILImageResampling.BILINEAR
+ image_mean = [0.5, 0.5, 0.5]
+ image_std = [0.5, 0.5, 0.5]
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ patch_size = 16
+ max_num_patches = 256
+ model_input_names = ["pixel_values", "pixel_attention_mask", "spatial_shapes"]
+
+ def __init__(self, **kwargs: Unpack[Siglip2ImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(self, images: ImageInput, **kwargs: Unpack[Siglip2ImageProcessorKwargs]) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def _validate_preprocess_kwargs(self, **kwargs) -> tuple:
+ # Remove do_resize from kwargs to not raise an error as size is None (computed dynamically)
+ kwargs.pop("do_resize", None)
+ return super()._validate_preprocess_kwargs(**kwargs)
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ patch_size: int,
+ max_num_patches: int,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ pixel_masks = []
+ pixel_values = []
+ spatial_shapes = []
+
+ for image in images:
+ if do_resize:
+ height, width = get_image_size_for_max_num_patches(
+ image_height=image.shape[-2],
+ image_width=image.shape[-1],
+ patch_size=patch_size,
+ max_num_patches=max_num_patches,
+ )
+ size_dict = SizeDict(height=height, width=width)
+ image = self.resize(image=image, size=size_dict, resample=resample)
+
+ image = self.rescale_and_normalize(image, do_rescale, rescale_factor, do_normalize, image_mean, image_std)
+
+ # (num_channels, height, width) -> (num_patches, patch_size * patch_size * num_channels)
+ patches = convert_image_to_patches(image, patch_size)
+ patches, mask = pad_along_first_dim(patches, max_num_patches)
+
+ num_patches_height = image.shape[-2] // patch_size
+ num_patches_width = image.shape[-1] // patch_size
+
+ spatial_shapes.append((num_patches_height, num_patches_width))
+ pixel_values.append(patches)
+ pixel_masks.append(mask)
+
+ batch_feature = BatchFeature(
+ data={
+ "pixel_values": pixel_values,
+ "pixel_attention_mask": pixel_masks,
+ "spatial_shapes": spatial_shapes,
+ },
+ tensor_type=return_tensors,
+ )
+ return batch_feature
+
+
+__all__ = ["Siglip2ImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/modeling_siglip2.py b/lib/python3.11/site-packages/transformers/models/siglip2/modeling_siglip2.py
new file mode 100644
index 0000000000000000000000000000000000000000..51e83dce2a9949ed5e6b897379ec478af0910128
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip2/modeling_siglip2.py
@@ -0,0 +1,1028 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/siglip2/modular_siglip2.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_siglip2.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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.
+
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...masking_utils import create_bidirectional_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling, ImageClassifierOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import ModelOutput, TransformersKwargs, auto_docstring, torch_compilable_check
+from ...utils.generic import can_return_tuple, merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_siglip2 import Siglip2Config, Siglip2TextConfig, Siglip2VisionConfig
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for vision model's outputs that also contains image embeddings of the pooling of the last hidden states.
+ """
+)
+@dataclass
+class Siglip2VisionOutput(ModelOutput):
+ r"""
+ image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
+ The image embeddings obtained by applying the projection layer to the pooler_output.
+ """
+
+ image_embeds: torch.FloatTensor | None = None
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for text model's outputs that also contains a pooling of the last hidden states.
+ """
+)
+@dataclass
+class Siglip2TextOutput(ModelOutput):
+ r"""
+ text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
+ The text embeddings obtained by applying the projection layer to the pooler_output.
+ """
+
+ text_embeds: torch.FloatTensor | None = None
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring
+@dataclass
+class Siglip2Output(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `return_loss` is `True`):
+ Contrastive loss for image-text similarity.
+ logits_per_image (`torch.FloatTensor` of shape `(image_batch_size, text_batch_size)`):
+ The scaled dot product scores between `image_embeds` and `text_embeds`. This represents the image-text
+ similarity scores.
+ logits_per_text (`torch.FloatTensor` of shape `(text_batch_size, image_batch_size)`):
+ The scaled dot product scores between `text_embeds` and `image_embeds`. This represents the text-image
+ similarity scores.
+ text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`):
+ The text embeddings obtained by applying the projection layer to the pooled output of [`Siglip2TextModel`].
+ image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`):
+ The image embeddings obtained by applying the projection layer to the pooled output of [`Siglip2VisionModel`].
+ text_model_output (`BaseModelOutputWithPooling`):
+ The output of the [`Siglip2TextModel`].
+ vision_model_output (`BaseModelOutputWithPooling`):
+ The output of the [`Siglip2VisionModel`].
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits_per_image: torch.FloatTensor | None = None
+ logits_per_text: torch.FloatTensor | None = None
+ text_embeds: torch.FloatTensor | None = None
+ image_embeds: torch.FloatTensor | None = None
+ text_model_output: BaseModelOutputWithPooling = None
+ vision_model_output: BaseModelOutputWithPooling = None
+
+ def to_tuple(self) -> tuple[Any]:
+ return tuple(v.to_tuple() if isinstance(v, ModelOutput) else v for v in self.values())
+
+
+class Siglip2VisionEmbeddings(nn.Module):
+ def __init__(self, config: Siglip2VisionConfig):
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.patch_size = config.patch_size
+
+ self.patch_embedding = nn.Linear(
+ in_features=config.num_channels * self.patch_size * self.patch_size,
+ out_features=self.embed_dim,
+ )
+
+ self.num_patches = config.num_patches
+ self.position_embedding_size = int(self.num_patches**0.5)
+ self.position_embedding = nn.Embedding(self.num_patches, self.embed_dim)
+
+ @staticmethod
+ def resize_positional_embeddings(
+ positional_embeddings: torch.Tensor,
+ spatial_shapes: torch.LongTensor,
+ max_length: int,
+ ) -> torch.Tensor:
+ """
+ Resize positional embeddings to image-specific size and pad to a fixed size.
+
+ Args:
+ positional_embeddings (`torch.Tensor`):
+ Position embeddings of shape (height, width, embed_dim)
+ spatial_shapes (`torch.LongTensor`):
+ Spatial shapes of shape (batch_size, 2) to resize the positional embeddings to
+ max_length (`int`):
+ Maximum length of the positional embeddings to pad resized positional embeddings to
+
+ Returns:
+ `torch.Tensor`: Embeddings of shape (batch_size, max_length, embed_dim)
+ """
+ batch_size = spatial_shapes.shape[0]
+ embed_dim = positional_embeddings.shape[-1]
+ source_dtype = positional_embeddings.dtype
+
+ resulted_positional_embeddings = torch.empty(
+ (batch_size, max_length, embed_dim),
+ device=positional_embeddings.device,
+ dtype=source_dtype,
+ )
+
+ # (height, width, embed_dim) -> (1, embed_dim, height, width) for interpolation
+ positional_embeddings = positional_embeddings.permute(2, 0, 1).unsqueeze(0)
+
+ # Upcast to float32 on CPU because antialias is not supported for bfloat16/float16 on CPU
+ if positional_embeddings.device.type == "cpu":
+ positional_embeddings = positional_embeddings.to(torch.float32)
+
+ for i in range(batch_size):
+ # (1, dim, height, width) -> (1, dim, target_height, target_width)
+ height, width = spatial_shapes[i].tolist() # will be itemized in F.interpolate either way
+ torch_compilable_check((width > 0), "Width of resized positional embeddings must be positive.")
+ torch_compilable_check((height > 0), "Height of resized positional embeddings must be positive.")
+ torch_compilable_check((height * width) <= max_length, "Resized positional embeddings exceed max_length.")
+ resized_embeddings = F.interpolate(
+ positional_embeddings,
+ size=(height, width),
+ mode="bilinear",
+ align_corners=False,
+ antialias=True,
+ )
+
+ # (1, dim, target_height, target_width) -> (target_height * target_width, dim)
+ resized_embeddings = resized_embeddings.reshape(embed_dim, height * width).transpose(0, 1)
+
+ # Cast to original dtype
+ resized_embeddings = resized_embeddings.to(source_dtype)
+
+ resulted_positional_embeddings[i, : height * width] = resized_embeddings
+ resulted_positional_embeddings[i, height * width :] = resized_embeddings[0]
+
+ return resulted_positional_embeddings
+
+ def forward(self, pixel_values: torch.FloatTensor, spatial_shapes: torch.LongTensor) -> torch.Tensor:
+ """
+ Args:
+ pixel_values (`torch.FloatTensor`):
+ Pixel values of shape (batch_size, max_num_patches, num_channels * patch_size * patch_size)
+ spatial_shapes (`list[tuple[int, int]]`):
+ Spatial shapes of shape (batch_size, 2) to resize the positional embeddings to
+ """
+
+ # Apply patch embeddings to already patchified pixel values
+ target_dtype = self.patch_embedding.weight.dtype
+ patch_embeds = self.patch_embedding(pixel_values.to(dtype=target_dtype))
+
+ # Get positional resized and padded positional embeddings
+ positional_embeddings = self.position_embedding.weight.reshape(
+ self.position_embedding_size, self.position_embedding_size, -1
+ )
+ resized_positional_embeddings = self.resize_positional_embeddings(
+ positional_embeddings, spatial_shapes, max_length=pixel_values.shape[1]
+ )
+
+ # Add positional embeddings to patch embeddings
+ embeddings = patch_embeds + resized_positional_embeddings
+ return embeddings
+
+
+class Siglip2TextEmbeddings(nn.Module):
+ def __init__(self, config: Siglip2TextConfig):
+ super().__init__()
+ embed_dim = config.hidden_size
+
+ self.token_embedding = nn.Embedding(config.vocab_size, embed_dim)
+ self.position_embedding = nn.Embedding(config.max_position_embeddings, embed_dim)
+
+ # position_ids (1, len position emb) is contiguous in memory and exported when serialized
+ self.register_buffer(
+ "position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)), persistent=False
+ )
+
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ ) -> torch.Tensor:
+ seq_length = input_ids.shape[-1] if input_ids is not None else inputs_embeds.shape[-2]
+ max_position_embedding = self.position_embedding.weight.shape[0]
+
+ if seq_length > max_position_embedding:
+ raise ValueError(
+ f"Sequence length must be less than max_position_embeddings (got `sequence length`: "
+ f"{seq_length} and max_position_embeddings: {max_position_embedding}"
+ )
+
+ if position_ids is None:
+ position_ids = self.position_ids[:, :seq_length]
+
+ if inputs_embeds is None:
+ inputs_embeds = self.token_embedding(input_ids)
+
+ position_embeddings = self.position_embedding(position_ids)
+ embeddings = inputs_embeds + position_embeddings
+
+ return embeddings
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float,
+ dropout: float = 0.0,
+ **kwargs,
+):
+ attn_weights = torch.matmul(query, key.transpose(-1, -2)) * scaling
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+class Siglip2Attention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.num_heads = config.num_attention_heads
+ self.head_dim = self.embed_dim // self.num_heads
+ if self.head_dim * self.num_heads != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+ f" {self.num_heads})."
+ )
+ self.scale = self.head_dim**-0.5
+ self.dropout = config.attention_dropout
+ self.is_causal = False
+
+ self.k_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.v_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.q_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.out_proj = nn.Linear(self.embed_dim, self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ """Input shape: Batch x Time x Channel"""
+
+ input_shape = hidden_states.shape[:-1]
+
+ hidden_shape = (*input_shape, -1, self.head_dim)
+ queries = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ keys = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ values = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ queries,
+ keys,
+ values,
+ attention_mask,
+ is_causal=self.is_causal,
+ scaling=self.scale,
+ dropout=0.0 if not self.training else self.dropout,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+class Siglip2MLP(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.activation_fn = ACT2FN[config.hidden_act]
+ self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size)
+ self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.fc1(hidden_states)
+ hidden_states = self.activation_fn(hidden_states)
+ hidden_states = self.fc2(hidden_states)
+ return hidden_states
+
+
+class Siglip2EncoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: Siglip2VisionConfig | Siglip2TextConfig):
+ super().__init__()
+ self.embed_dim = config.hidden_size
+ self.layer_norm1 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+ self.self_attn = Siglip2Attention(config)
+ self.layer_norm2 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+ self.mlp = Siglip2MLP(config)
+
+ @auto_docstring
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.FloatTensor:
+ residual = hidden_states
+
+ hidden_states = self.layer_norm1(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.layer_norm2(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = residual + hidden_states
+
+ return hidden_states
+
+
+@auto_docstring
+class Siglip2PreTrainedModel(PreTrainedModel):
+ config: Siglip2Config
+ base_model_prefix = "siglip2"
+ input_modalities = ("image", "text")
+ supports_gradient_checkpointing = True
+
+ _no_split_modules = [
+ "Siglip2TextEmbeddings",
+ "Siglip2VisionEmbeddings",
+ "Siglip2EncoderLayer",
+ "Siglip2MultiheadAttentionPoolingHead",
+ ]
+ _supports_flash_attn = False
+ _supports_sdpa = True
+ # nn.MultiHeadAttention mask doesn't allow for non 4d mask
+ _supports_flex_attn = False
+ _supports_attention_backend = True
+
+ _can_record_outputs = {
+ "hidden_states": Siglip2EncoderLayer,
+ "attentions": Siglip2Attention,
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ if isinstance(module, Siglip2VisionEmbeddings):
+ width = (
+ self.config.vision_config.hidden_size
+ if isinstance(self.config, Siglip2Config)
+ else self.config.hidden_size
+ )
+ init.normal_(module.position_embedding.weight, std=1 / np.sqrt(width))
+ if hasattr(module, "position_ids"):
+ init.copy_(module.position_ids, torch.arange(module.position_ids.shape[-1]).expand((1, -1)))
+ elif isinstance(module, nn.Embedding):
+ init.default_flax_embed_init_(module.weight)
+ elif isinstance(module, Siglip2Attention):
+ init.xavier_uniform_(module.q_proj.weight)
+ init.xavier_uniform_(module.k_proj.weight)
+ init.xavier_uniform_(module.v_proj.weight)
+ init.xavier_uniform_(module.out_proj.weight)
+ init.zeros_(module.q_proj.bias)
+ init.zeros_(module.k_proj.bias)
+ init.zeros_(module.v_proj.bias)
+ init.zeros_(module.out_proj.bias)
+ elif isinstance(module, Siglip2MLP):
+ init.xavier_uniform_(module.fc1.weight)
+ init.xavier_uniform_(module.fc2.weight)
+ init.normal_(module.fc1.bias, std=1e-6)
+ init.normal_(module.fc2.bias, std=1e-6)
+ elif isinstance(module, Siglip2MultiheadAttentionPoolingHead):
+ init.xavier_uniform_(module.probe)
+ init.xavier_uniform_(module.attention.in_proj_weight)
+ init.zeros_(module.attention.in_proj_bias)
+ elif isinstance(module, Siglip2Model):
+ init.zeros_(module.logit_scale)
+ init.zeros_(module.logit_bias)
+ elif isinstance(module, Siglip2ForImageClassification):
+ init.normal_(
+ module.classifier.weight,
+ std=self.config.vision_config.hidden_size**-0.5 * self.config.initializer_factor,
+ )
+ elif isinstance(module, (nn.Linear, nn.Conv2d)):
+ init.lecun_normal_(module.weight)
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, nn.LayerNorm):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ elif isinstance(module, Siglip2TextEmbeddings):
+ init.copy_(module.position_ids, torch.arange(module.position_ids.shape[-1]).expand((1, -1)))
+
+
+class Siglip2Encoder(nn.Module):
+ """
+ Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
+ [`Siglip2EncoderLayer`].
+
+ Args:
+ config: Siglip2Config
+ """
+
+ def __init__(self, config: Siglip2Config):
+ super().__init__()
+ self.config = config
+ self.layers = nn.ModuleList([Siglip2EncoderLayer(config) for _ in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ # Ignore copy
+ @auto_docstring
+ def forward(
+ self,
+ inputs_embeds,
+ attention_mask: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ hidden_states = inputs_embeds
+ for encoder_layer in self.layers:
+ hidden_states = encoder_layer(
+ hidden_states,
+ attention_mask,
+ **kwargs,
+ )
+
+ return BaseModelOutput(last_hidden_state=hidden_states)
+
+
+@auto_docstring(
+ custom_intro="""
+ The vision model from Siglip2 without any head or projection on top.
+ """
+)
+class Siglip2VisionModel(Siglip2PreTrainedModel):
+ config: Siglip2VisionConfig
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ base_model_prefix = "vision_model"
+ _input_embed_layer = "patch_embedding"
+
+ def __init__(self, config: Siglip2VisionConfig):
+ super().__init__(config)
+ self.config = config
+ embed_dim = config.hidden_size
+
+ self.embeddings = Siglip2VisionEmbeddings(config)
+ self.encoder = Siglip2Encoder(config)
+ self.post_layernorm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
+ self.use_head = True if not hasattr(config, "vision_use_head") else config.vision_use_head
+ if self.use_head:
+ self.head = Siglip2MultiheadAttentionPoolingHead(config)
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ pixel_attention_mask: torch.Tensor,
+ spatial_shapes: torch.LongTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPooling:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
+ Tensor containing the spatial dimensions (height, width) of the input images.
+
+ Examples:
+
+ ```python
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> from PIL import Image
+ >>> from transformers import AutoProcessor, Siglip2VisionModel
+
+ >>> model = Siglip2VisionModel.from_pretrained("google/siglip2-base-patch16-224")
+ >>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> inputs = processor(images=image, return_tensors="pt")
+
+ >>> outputs = model(**inputs)
+ >>> last_hidden_state = outputs.last_hidden_state
+ >>> pooled_output = outputs.pooler_output # pooled features
+ ```
+ """
+ hidden_states = self.embeddings(pixel_values, spatial_shapes)
+
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=pixel_attention_mask,
+ )
+
+ encoder_outputs: BaseModelOutput = self.encoder(
+ inputs_embeds=hidden_states,
+ attention_mask=encoder_attention_mask,
+ **kwargs,
+ )
+
+ last_hidden_state = encoder_outputs.last_hidden_state
+ last_hidden_state = self.post_layernorm(last_hidden_state)
+
+ pooler_output = self.head(last_hidden_state, pixel_attention_mask) if self.use_head else None
+
+ return BaseModelOutputWithPooling(
+ last_hidden_state=last_hidden_state,
+ pooler_output=pooler_output,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ The text model from Siglip2 without any head or projection on top.
+ """
+)
+class Siglip2TextModel(Siglip2PreTrainedModel):
+ config: Siglip2TextConfig
+ input_modalities = ("text",)
+ base_model_prefix = "text_model"
+ _input_embed_layer = "token_embedding"
+
+ def __init__(self, config: Siglip2TextConfig):
+ super().__init__(config)
+ self.config = config
+ embed_dim = config.hidden_size
+ self.embeddings = Siglip2TextEmbeddings(config)
+ self.encoder = Siglip2Encoder(config)
+ self.final_layer_norm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
+
+ self.head = nn.Linear(embed_dim, config.projection_size)
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.Tensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPooling:
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, Siglip2TextModel
+
+ >>> model = Siglip2TextModel.from_pretrained("google/siglip2-base-patch16-224")
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> # important: make sure to set padding="max_length" as that's how the model was trained
+ >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")
+
+ >>> outputs = model(**inputs)
+ >>> last_hidden_state = outputs.last_hidden_state
+ >>> pooled_output = outputs.pooler_output # pooled (EOS token) states
+ ```"""
+ if input_ids is None:
+ raise ValueError("You have to specify input_ids")
+
+ input_shape = input_ids.size()
+ input_ids = input_ids.view(-1, input_shape[-1])
+
+ hidden_states = self.embeddings(input_ids=input_ids, position_ids=position_ids)
+
+ # note: Siglip2's text model does not use a causal mask, unlike the original CLIP model.
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ )
+
+ encoder_outputs: BaseModelOutput = self.encoder(
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+
+ last_hidden_state = encoder_outputs.last_hidden_state
+ last_hidden_state = self.final_layer_norm(last_hidden_state)
+
+ # The model uses the last token's hidden state, which may be padding.
+ pooled_output = last_hidden_state[:, -1, :]
+ pooled_output = self.head(pooled_output)
+
+ return BaseModelOutputWithPooling(
+ last_hidden_state=last_hidden_state,
+ pooler_output=pooled_output,
+ )
+
+
+class Siglip2MultiheadAttentionPoolingHead(nn.Module):
+ """Multihead Attention Pooling."""
+
+ def __init__(self, config: Siglip2VisionConfig):
+ super().__init__()
+
+ self.probe = nn.Parameter(torch.randn(1, 1, config.hidden_size))
+ self.attention = torch.nn.MultiheadAttention(config.hidden_size, config.num_attention_heads, batch_first=True)
+ self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.mlp = Siglip2MLP(config)
+
+ self.config = config
+ self.num_heads = config.num_attention_heads
+
+ def forward(self, hidden_state: torch.Tensor, attention_mask: torch.Tensor | None = None) -> torch.Tensor:
+ batch_size = hidden_state.shape[0]
+ probe = self.probe.repeat(batch_size, 1, 1)
+
+ if attention_mask is not None:
+ target_len, source_len = probe.shape[1], hidden_state.shape[1]
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=probe,
+ attention_mask=attention_mask,
+ encoder_hidden_states=hidden_state,
+ )
+ if attention_mask is not None:
+ attention_mask = attention_mask.repeat(1, self.num_heads, target_len, 1)
+ attention_mask = attention_mask.reshape(-1, target_len, source_len)
+
+ # `nn.MultiheadAttention` cannot handle boolean masks (which SDPA can)
+ if attention_mask.dtype == torch.bool:
+ attention_mask = torch.where(
+ attention_mask,
+ torch.tensor(0.0, device=attention_mask.device, dtype=probe.dtype),
+ torch.finfo(probe.dtype).min,
+ )
+
+ hidden_state = self.attention(probe, hidden_state, hidden_state, attn_mask=attention_mask)[0]
+
+ residual = hidden_state
+ hidden_state = self.layernorm(hidden_state)
+ hidden_state = residual + self.mlp(hidden_state)
+
+ return hidden_state[:, 0]
+
+
+@auto_docstring
+class Siglip2Model(Siglip2PreTrainedModel):
+ config: Siglip2Config
+
+ def __init__(self, config: Siglip2Config):
+ super().__init__(config)
+
+ text_config = config.text_config
+ vision_config = config.vision_config
+
+ # First, initialize the text and vision models with proper attention implementation
+ self.text_model = Siglip2TextModel._from_config(text_config)
+ self.vision_model = Siglip2VisionModel._from_config(vision_config)
+
+ self.logit_scale = nn.Parameter(torch.randn(1))
+ self.logit_bias = nn.Parameter(torch.randn(1))
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self) -> nn.Module:
+ return self.text_model.embeddings.token_embedding
+
+ def set_input_embeddings(self, value: nn.Module):
+ self.text_model.embeddings.token_embedding = value
+
+ @can_return_tuple
+ @auto_docstring
+ def get_text_features(
+ self,
+ input_ids: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, AutoModel
+ >>> import torch
+
+ >>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> # important: make sure to set padding="max_length" as that's how the model was trained
+ >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")
+ >>> with torch.no_grad():
+ ... text_features = model.get_text_features(**inputs)
+ ```"""
+ return self.text_model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ pixel_attention_mask: torch.Tensor | None = None,
+ spatial_shapes: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
+ Tensor containing the spatial dimensions (height, width) of the input images.
+
+ Examples:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoProcessor, AutoModel
+ >>> from transformers.image_utils import load_image
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> image = load_image(url)
+
+ >>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
+ >>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> inputs = processor(images=image, return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... image_features = model.get_image_features(**inputs)
+ ```
+ """
+ return self.vision_model(
+ pixel_values=pixel_values,
+ pixel_attention_mask=pixel_attention_mask,
+ spatial_shapes=spatial_shapes,
+ **kwargs,
+ )
+
+ # NOTE: Siglip2Model uses Pretrained backbones, so we don't need to add `capture_outputs` here
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ pixel_attention_mask: torch.Tensor | None = None,
+ spatial_shapes: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ return_loss: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> Siglip2Output:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
+ Tensor containing the spatial dimensions (height, width) of the input images.
+ return_loss (`bool`, *optional*):
+ Whether or not to return the contrastive loss.
+
+ Examples:
+
+ ```python
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> from transformers import AutoProcessor, AutoModel
+ >>> import torch
+
+ >>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
+ >>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> texts = ["a photo of 2 cats", "a photo of 2 dogs"]
+ >>> # important: we pass `padding=max_length` since the model was trained with this
+ >>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> logits_per_image = outputs.logits_per_image
+ >>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
+ >>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
+ 31.9% that image 0 is 'a photo of 2 cats'
+ ```
+ """
+ vision_outputs: BaseModelOutputWithPooling = self.vision_model(
+ pixel_values=pixel_values,
+ pixel_attention_mask=pixel_attention_mask,
+ spatial_shapes=spatial_shapes,
+ **kwargs,
+ )
+
+ text_outputs: BaseModelOutputWithPooling = self.text_model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+
+ image_embeds = vision_outputs.pooler_output
+ text_embeds = text_outputs.pooler_output
+
+ # normalized features
+ image_embeds = image_embeds / image_embeds.norm(p=2, dim=-1, keepdim=True)
+ text_embeds = text_embeds / text_embeds.norm(p=2, dim=-1, keepdim=True)
+
+ # cosine similarity as logits
+ logits_per_text = torch.matmul(text_embeds, image_embeds.t().to(text_embeds.device))
+
+ logit_scale, logit_bias = self.logit_scale.to(text_embeds.device), self.logit_bias.to(text_embeds.device)
+ logits_per_text = logits_per_text * logit_scale.exp() + logit_bias
+
+ logits_per_image = logits_per_text.t()
+
+ loss = None
+ if return_loss:
+ # Adapted from https://github.com/google-research/big_vision/blob/01edb81a4716f93a48be43b3a4af14e29cdb3a7f/big_vision/trainers/proj/image_text/siglip2.py#L287
+ eye = torch.eye(logits_per_text.size(0), device=logits_per_text.device)
+ m1_diag1 = -torch.ones_like(logits_per_text) + 2 * eye
+ loglik = torch.nn.functional.logsigmoid(m1_diag1 * logits_per_text)
+ nll = -torch.sum(loglik, dim=-1)
+ loss = nll.mean()
+
+ return Siglip2Output(
+ loss=loss,
+ logits_per_image=logits_per_image,
+ logits_per_text=logits_per_text,
+ text_embeds=text_embeds,
+ image_embeds=image_embeds,
+ text_model_output=text_outputs,
+ vision_model_output=vision_outputs,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Siglip2 vision encoder with an image classification head on top (a linear layer on top of the pooled final hidden states of
+ the patch tokens) e.g. for ImageNet.
+ """
+)
+class Siglip2ForImageClassification(Siglip2PreTrainedModel):
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+
+ def __init__(self, config: Siglip2Config) -> None:
+ super().__init__(config)
+
+ self.num_labels = config.num_labels
+ self.vision_model = Siglip2VisionModel._from_config(config.vision_config)
+
+ # Classifier head
+ self.classifier = (
+ nn.Linear(config.vision_config.hidden_size, config.num_labels) if config.num_labels > 0 else nn.Identity()
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self) -> nn.Module:
+ return self.vision_model.embeddings.patch_embedding
+
+ def set_input_embeddings(self, value: nn.Module):
+ self.vision_model.embeddings.patch_embedding = value
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor | None = None,
+ pixel_attention_mask: torch.Tensor | None = None,
+ spatial_shapes: torch.LongTensor | None = None,
+ labels: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> ImageClassifierOutput:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
+ Tensor containing the spatial dimensions (height, width) of the input images.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, Siglip2ForImageClassification
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> torch.manual_seed(3) # doctest: +IGNORE_RESULT
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> # note: we are loading a `Siglip2Model` from the hub here,
+ >>> # so the head will be randomly initialized, hence the predictions will be random if seed is not set above.
+ >>> image_processor = AutoImageProcessor.from_pretrained("google/siglip2-base-patch16-224")
+ >>> model = Siglip2ForImageClassification.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> inputs = image_processor(images=image, return_tensors="pt")
+ >>> outputs = model(**inputs)
+ >>> logits = outputs.logits
+ >>> # model predicts one of the two classes
+ >>> predicted_class_idx = logits.argmax(-1).item()
+ >>> print("Predicted class:", model.config.id2label[predicted_class_idx])
+ Predicted class: LABEL_1
+ ```
+ """
+ outputs: BaseModelOutputWithPooling = self.vision_model(
+ pixel_values,
+ pixel_attention_mask=pixel_attention_mask,
+ spatial_shapes=spatial_shapes,
+ **kwargs,
+ )
+
+ sequence_output = outputs.last_hidden_state
+
+ # average pool the patch tokens
+ if pixel_attention_mask is not None:
+ pool_mask = pixel_attention_mask[..., None].to(sequence_output.device)
+ sequence_output = torch.sum(sequence_output * pool_mask, dim=1) / torch.sum(pool_mask, dim=1)
+ else:
+ sequence_output = torch.mean(sequence_output, dim=1)
+
+ # apply classifier
+ logits = self.classifier(sequence_output)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config)
+
+ return ImageClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "Siglip2Model",
+ "Siglip2PreTrainedModel",
+ "Siglip2TextModel",
+ "Siglip2VisionModel",
+ "Siglip2ForImageClassification",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/modular_siglip2.py b/lib/python3.11/site-packages/transformers/models/siglip2/modular_siglip2.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc69c28f99ba3836bbbcec9f8c07910124f806ca
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip2/modular_siglip2.py
@@ -0,0 +1,594 @@
+# Copyright 2025 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.
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from huggingface_hub.dataclasses import strict
+from tokenizers import normalizers
+
+from transformers.models.gemma.tokenization_gemma import GemmaTokenizer
+from transformers.models.siglip.configuration_siglip import SiglipConfig, SiglipTextConfig, SiglipVisionConfig
+from transformers.models.siglip.modeling_siglip import (
+ BaseModelOutput,
+ BaseModelOutputWithPooling,
+ ImageClassifierOutput,
+ SiglipForImageClassification,
+ SiglipModel,
+ SiglipMultiheadAttentionPoolingHead,
+ SiglipOutput,
+ SiglipPreTrainedModel,
+ SiglipTextModel,
+ SiglipTextModelOutput,
+ SiglipVisionModel,
+ SiglipVisionModelOutput,
+)
+
+from ...masking_utils import create_bidirectional_mask
+from ...processing_utils import Unpack
+from ...utils import (
+ TransformersKwargs,
+ auto_docstring,
+ torch_compilable_check,
+)
+from ...utils.generic import can_return_tuple, merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+
+
+class Siglip2Tokenizer(GemmaTokenizer):
+ """
+ Gemma tokenizer + SigLIP2 training default: lowercase normalization.
+ """
+
+ def __init__(
+ self,
+ vocab: str | dict[str, int] | None = None,
+ merges: str | list[str] | None = None,
+ unk_token: str = "<unk>",
+ bos_token: str = "<bos>",
+ eos_token: str = "<eos>",
+ pad_token: str = "<pad>",
+ mask_token: str = "<mask>",
+ **kwargs,
+ ):
+ super().__init__(
+ vocab=vocab,
+ merges=merges,
+ unk_token=unk_token,
+ bos_token=bos_token,
+ eos_token=eos_token,
+ pad_token=pad_token,
+ mask_token=mask_token,
+ **kwargs,
+ )
+
+ # Persist for save/load + push_to_hub dynamic tokenizer test
+ if hasattr(self, "init_kwargs") and isinstance(self.init_kwargs, dict):
+ self.init_kwargs.setdefault("tokenizer_class", self.__class__.__name__)
+
+ backend = getattr(self, "_tokenizer", None)
+ if backend is not None and backend.normalizer is not None:
+ backend.normalizer = normalizers.Sequence([normalizers.Lowercase(), backend.normalizer])
+
+
+@auto_docstring(checkpoint="google/siglip2-base-patch16-naflex")
+@strict
+class Siglip2TextConfig(SiglipTextConfig):
+ pass
+
+
+@auto_docstring(checkpoint="google/siglip2-base-patch16-naflex")
+@strict
+class Siglip2VisionConfig(SiglipVisionConfig):
+ r"""
+ num_patches (`int`, *optional*, defaults to 256):
+ The number of patches in the image with the size of (`patch_size`, `patch_size`).
+ The image is resized to fill maximum of this number of patches, and to preserve
+ the aspect ratio. In case the resulted number of patches is lower, the image is
+ padded in "patch" dimension.
+
+ Example:
+
+ ```python
+ >>> from transformers import Siglip2VisionConfig, Siglip2VisionModel
+
+ >>> # Initializing a Siglip2VisionConfig with google/siglip2-base-patch16-naflex style configuration
+ >>> configuration = Siglip2VisionConfig()
+
+ >>> # Initializing a Siglip2VisionModel (with random weights) from the google/siglip2-base-patch16-naflex style configuration
+ >>> model = Siglip2VisionModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ num_patches: int = 256
+ image_size = AttributeError()
+
+
+@auto_docstring(checkpoint="google/siglip2-base-patch16-naflex")
+@strict
+class Siglip2Config(SiglipConfig):
+ pass
+
+
+class Siglip2VisionOutput(SiglipVisionModelOutput):
+ pass
+
+
+class Siglip2TextOutput(SiglipTextModelOutput):
+ pass
+
+
+class Siglip2Output(SiglipOutput):
+ pass
+
+
+class Siglip2VisionEmbeddings(nn.Module):
+ def __init__(self, config: Siglip2VisionConfig):
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.patch_size = config.patch_size
+
+ self.patch_embedding = nn.Linear(
+ in_features=config.num_channels * self.patch_size * self.patch_size,
+ out_features=self.embed_dim,
+ )
+
+ self.num_patches = config.num_patches
+ self.position_embedding_size = int(self.num_patches**0.5)
+ self.position_embedding = nn.Embedding(self.num_patches, self.embed_dim)
+
+ @staticmethod
+ def resize_positional_embeddings(
+ positional_embeddings: torch.Tensor,
+ spatial_shapes: torch.LongTensor,
+ max_length: int,
+ ) -> torch.Tensor:
+ """
+ Resize positional embeddings to image-specific size and pad to a fixed size.
+
+ Args:
+ positional_embeddings (`torch.Tensor`):
+ Position embeddings of shape (height, width, embed_dim)
+ spatial_shapes (`torch.LongTensor`):
+ Spatial shapes of shape (batch_size, 2) to resize the positional embeddings to
+ max_length (`int`):
+ Maximum length of the positional embeddings to pad resized positional embeddings to
+
+ Returns:
+ `torch.Tensor`: Embeddings of shape (batch_size, max_length, embed_dim)
+ """
+ batch_size = spatial_shapes.shape[0]
+ embed_dim = positional_embeddings.shape[-1]
+ source_dtype = positional_embeddings.dtype
+
+ resulted_positional_embeddings = torch.empty(
+ (batch_size, max_length, embed_dim),
+ device=positional_embeddings.device,
+ dtype=source_dtype,
+ )
+
+ # (height, width, embed_dim) -> (1, embed_dim, height, width) for interpolation
+ positional_embeddings = positional_embeddings.permute(2, 0, 1).unsqueeze(0)
+
+ # Upcast to float32 on CPU because antialias is not supported for bfloat16/float16 on CPU
+ if positional_embeddings.device.type == "cpu":
+ positional_embeddings = positional_embeddings.to(torch.float32)
+
+ for i in range(batch_size):
+ # (1, dim, height, width) -> (1, dim, target_height, target_width)
+ height, width = spatial_shapes[i].tolist() # will be itemized in F.interpolate either way
+ torch_compilable_check((width > 0), "Width of resized positional embeddings must be positive.")
+ torch_compilable_check((height > 0), "Height of resized positional embeddings must be positive.")
+ torch_compilable_check((height * width) <= max_length, "Resized positional embeddings exceed max_length.")
+ resized_embeddings = F.interpolate(
+ positional_embeddings,
+ size=(height, width),
+ mode="bilinear",
+ align_corners=False,
+ antialias=True,
+ )
+
+ # (1, dim, target_height, target_width) -> (target_height * target_width, dim)
+ resized_embeddings = resized_embeddings.reshape(embed_dim, height * width).transpose(0, 1)
+
+ # Cast to original dtype
+ resized_embeddings = resized_embeddings.to(source_dtype)
+
+ resulted_positional_embeddings[i, : height * width] = resized_embeddings
+ resulted_positional_embeddings[i, height * width :] = resized_embeddings[0]
+
+ return resulted_positional_embeddings
+
+ def forward(self, pixel_values: torch.FloatTensor, spatial_shapes: torch.LongTensor) -> torch.Tensor:
+ """
+ Args:
+ pixel_values (`torch.FloatTensor`):
+ Pixel values of shape (batch_size, max_num_patches, num_channels * patch_size * patch_size)
+ spatial_shapes (`list[tuple[int, int]]`):
+ Spatial shapes of shape (batch_size, 2) to resize the positional embeddings to
+ """
+
+ # Apply patch embeddings to already patchified pixel values
+ target_dtype = self.patch_embedding.weight.dtype
+ patch_embeds = self.patch_embedding(pixel_values.to(dtype=target_dtype))
+
+ # Get positional resized and padded positional embeddings
+ positional_embeddings = self.position_embedding.weight.reshape(
+ self.position_embedding_size, self.position_embedding_size, -1
+ )
+ resized_positional_embeddings = self.resize_positional_embeddings(
+ positional_embeddings, spatial_shapes, max_length=pixel_values.shape[1]
+ )
+
+ # Add positional embeddings to patch embeddings
+ embeddings = patch_embeds + resized_positional_embeddings
+ return embeddings
+
+
+class Siglip2PreTrainedModel(SiglipPreTrainedModel):
+ # nn.MultiHeadAttention mask doesn't allow for non 4d mask
+ _supports_flex_attn = False
+ _supports_flash_attn = False
+
+
+class Siglip2VisionModel(SiglipVisionModel):
+ def __init__(self, config: Siglip2VisionConfig):
+ super().__init__(config)
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ pixel_attention_mask: torch.Tensor,
+ spatial_shapes: torch.LongTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPooling:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
+ Tensor containing the spatial dimensions (height, width) of the input images.
+
+ Examples:
+
+ ```python
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> from PIL import Image
+ >>> from transformers import AutoProcessor, Siglip2VisionModel
+
+ >>> model = Siglip2VisionModel.from_pretrained("google/siglip2-base-patch16-224")
+ >>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> inputs = processor(images=image, return_tensors="pt")
+
+ >>> outputs = model(**inputs)
+ >>> last_hidden_state = outputs.last_hidden_state
+ >>> pooled_output = outputs.pooler_output # pooled features
+ ```
+ """
+ hidden_states = self.embeddings(pixel_values, spatial_shapes)
+
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=pixel_attention_mask,
+ )
+
+ encoder_outputs: BaseModelOutput = self.encoder(
+ inputs_embeds=hidden_states,
+ attention_mask=encoder_attention_mask,
+ **kwargs,
+ )
+
+ last_hidden_state = encoder_outputs.last_hidden_state
+ last_hidden_state = self.post_layernorm(last_hidden_state)
+
+ pooler_output = self.head(last_hidden_state, pixel_attention_mask) if self.use_head else None
+
+ return BaseModelOutputWithPooling(
+ last_hidden_state=last_hidden_state,
+ pooler_output=pooler_output,
+ )
+
+
+class Siglip2TextModel(SiglipTextModel):
+ pass
+
+
+class Siglip2MultiheadAttentionPoolingHead(SiglipMultiheadAttentionPoolingHead):
+ def __init__(self, config: Siglip2VisionConfig):
+ super().__init__(config)
+
+ self.config = config
+ self.num_heads = config.num_attention_heads
+
+ def forward(self, hidden_state: torch.Tensor, attention_mask: torch.Tensor | None = None) -> torch.Tensor:
+ batch_size = hidden_state.shape[0]
+ probe = self.probe.repeat(batch_size, 1, 1)
+
+ if attention_mask is not None:
+ target_len, source_len = probe.shape[1], hidden_state.shape[1]
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=probe,
+ attention_mask=attention_mask,
+ encoder_hidden_states=hidden_state,
+ )
+ if attention_mask is not None:
+ attention_mask = attention_mask.repeat(1, self.num_heads, target_len, 1)
+ attention_mask = attention_mask.reshape(-1, target_len, source_len)
+
+ # `nn.MultiheadAttention` cannot handle boolean masks (which SDPA can)
+ if attention_mask.dtype == torch.bool:
+ attention_mask = torch.where(
+ attention_mask,
+ torch.tensor(0.0, device=attention_mask.device, dtype=probe.dtype),
+ torch.finfo(probe.dtype).min,
+ )
+
+ hidden_state = self.attention(probe, hidden_state, hidden_state, attn_mask=attention_mask)[0]
+
+ residual = hidden_state
+ hidden_state = self.layernorm(hidden_state)
+ hidden_state = residual + self.mlp(hidden_state)
+
+ return hidden_state[:, 0]
+
+
+class Siglip2Model(SiglipModel):
+ # Update: add `spatial_shapes` and `pixel_attention_mask`
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ pixel_attention_mask: torch.Tensor | None = None,
+ spatial_shapes: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
+ Tensor containing the spatial dimensions (height, width) of the input images.
+
+ Examples:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoProcessor, AutoModel
+ >>> from transformers.image_utils import load_image
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> image = load_image(url)
+
+ >>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
+ >>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> inputs = processor(images=image, return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... image_features = model.get_image_features(**inputs)
+ ```
+ """
+ return self.vision_model(
+ pixel_values=pixel_values,
+ pixel_attention_mask=pixel_attention_mask,
+ spatial_shapes=spatial_shapes,
+ **kwargs,
+ )
+
+ # Update: add `spatial_shapes` and `pixel_attention_mask`
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ pixel_attention_mask: torch.Tensor | None = None,
+ spatial_shapes: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ return_loss: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> Siglip2Output:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
+ Tensor containing the spatial dimensions (height, width) of the input images.
+ return_loss (`bool`, *optional*):
+ Whether or not to return the contrastive loss.
+
+ Examples:
+
+ ```python
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> from transformers import AutoProcessor, AutoModel
+ >>> import torch
+
+ >>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
+ >>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> texts = ["a photo of 2 cats", "a photo of 2 dogs"]
+ >>> # important: we pass `padding=max_length` since the model was trained with this
+ >>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> logits_per_image = outputs.logits_per_image
+ >>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
+ >>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
+ 31.9% that image 0 is 'a photo of 2 cats'
+ ```
+ """
+ vision_outputs: BaseModelOutputWithPooling = self.vision_model(
+ pixel_values=pixel_values,
+ pixel_attention_mask=pixel_attention_mask,
+ spatial_shapes=spatial_shapes,
+ **kwargs,
+ )
+
+ text_outputs: BaseModelOutputWithPooling = self.text_model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+
+ image_embeds = vision_outputs.pooler_output
+ text_embeds = text_outputs.pooler_output
+
+ # normalized features
+ image_embeds = image_embeds / image_embeds.norm(p=2, dim=-1, keepdim=True)
+ text_embeds = text_embeds / text_embeds.norm(p=2, dim=-1, keepdim=True)
+
+ # cosine similarity as logits
+ logits_per_text = torch.matmul(text_embeds, image_embeds.t().to(text_embeds.device))
+
+ logit_scale, logit_bias = self.logit_scale.to(text_embeds.device), self.logit_bias.to(text_embeds.device)
+ logits_per_text = logits_per_text * logit_scale.exp() + logit_bias
+
+ logits_per_image = logits_per_text.t()
+
+ loss = None
+ if return_loss:
+ # Adapted from https://github.com/google-research/big_vision/blob/01edb81a4716f93a48be43b3a4af14e29cdb3a7f/big_vision/trainers/proj/image_text/siglip2.py#L287
+ eye = torch.eye(logits_per_text.size(0), device=logits_per_text.device)
+ m1_diag1 = -torch.ones_like(logits_per_text) + 2 * eye
+ loglik = torch.nn.functional.logsigmoid(m1_diag1 * logits_per_text)
+ nll = -torch.sum(loglik, dim=-1)
+ loss = nll.mean()
+
+ return Siglip2Output(
+ loss=loss,
+ logits_per_image=logits_per_image,
+ logits_per_text=logits_per_text,
+ text_embeds=text_embeds,
+ image_embeds=image_embeds,
+ text_model_output=text_outputs,
+ vision_model_output=vision_outputs,
+ )
+
+
+class Siglip2ForImageClassification(SiglipForImageClassification):
+ # Update: add `spatial_shapes` and `pixel_attention_mask`
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor | None = None,
+ pixel_attention_mask: torch.Tensor | None = None,
+ spatial_shapes: torch.LongTensor | None = None,
+ labels: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> ImageClassifierOutput:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
+ Tensor containing the spatial dimensions (height, width) of the input images.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, Siglip2ForImageClassification
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> torch.manual_seed(3) # doctest: +IGNORE_RESULT
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> # note: we are loading a `Siglip2Model` from the hub here,
+ >>> # so the head will be randomly initialized, hence the predictions will be random if seed is not set above.
+ >>> image_processor = AutoImageProcessor.from_pretrained("google/siglip2-base-patch16-224")
+ >>> model = Siglip2ForImageClassification.from_pretrained("google/siglip2-base-patch16-224")
+
+ >>> inputs = image_processor(images=image, return_tensors="pt")
+ >>> outputs = model(**inputs)
+ >>> logits = outputs.logits
+ >>> # model predicts one of the two classes
+ >>> predicted_class_idx = logits.argmax(-1).item()
+ >>> print("Predicted class:", model.config.id2label[predicted_class_idx])
+ Predicted class: LABEL_1
+ ```
+ """
+ outputs: BaseModelOutputWithPooling = self.vision_model(
+ pixel_values,
+ pixel_attention_mask=pixel_attention_mask,
+ spatial_shapes=spatial_shapes,
+ **kwargs,
+ )
+
+ sequence_output = outputs.last_hidden_state
+
+ # average pool the patch tokens
+ if pixel_attention_mask is not None:
+ pool_mask = pixel_attention_mask[..., None].to(sequence_output.device)
+ sequence_output = torch.sum(sequence_output * pool_mask, dim=1) / torch.sum(pool_mask, dim=1)
+ else:
+ sequence_output = torch.mean(sequence_output, dim=1)
+
+ # apply classifier
+ logits = self.classifier(sequence_output)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config)
+
+ return ImageClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "Siglip2Config",
+ "Siglip2TextConfig",
+ "Siglip2VisionConfig",
+ "Siglip2Model",
+ "Siglip2PreTrainedModel",
+ "Siglip2TextModel",
+ "Siglip2VisionModel",
+ "Siglip2ForImageClassification",
+ "Siglip2Tokenizer",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/processing_siglip2.py b/lib/python3.11/site-packages/transformers/models/siglip2/processing_siglip2.py
new file mode 100644
index 0000000000000000000000000000000000000000..2315eef2d016d7b233f032c341b0f6e6d80ff691
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip2/processing_siglip2.py
@@ -0,0 +1,44 @@
+# Copyright 2025 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.
+"""
+Image/Text processor class for SigLIP2.
+"""
+
+from ...processing_utils import ProcessingKwargs, ProcessorMixin
+from ...utils import auto_docstring
+
+
+class Siglip2ProcessorKwargs(ProcessingKwargs, total=False):
+ _defaults = {
+ "text_kwargs": {
+ "padding": "max_length",
+ "truncation": True,
+ "max_length": 64,
+ },
+ "images_kwargs": {
+ "max_num_patches": 256,
+ "patch_size": 16,
+ },
+ }
+
+
+@auto_docstring
+class Siglip2Processor(ProcessorMixin):
+ valid_processor_kwargs = Siglip2ProcessorKwargs
+
+ def __init__(self, image_processor, tokenizer):
+ super().__init__(image_processor, tokenizer)
+
+
+__all__ = ["Siglip2Processor"]
diff --git a/lib/python3.11/site-packages/transformers/models/siglip2/tokenization_siglip2.py b/lib/python3.11/site-packages/transformers/models/siglip2/tokenization_siglip2.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a68d80965d861755ab6de4c321796a5ec18f87d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/siglip2/tokenization_siglip2.py
@@ -0,0 +1,99 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/siglip2/modular_siglip2.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_siglip2.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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.
+
+
+from tokenizers import Tokenizer, decoders, normalizers, pre_tokenizers
+from tokenizers.models import BPE
+
+from ...tokenization_utils_tokenizers import TokenizersBackend
+
+
+VOCAB_FILES_NAMES = {"tokenizer_file": "tokenizer.json"}
+
+
+class Siglip2Tokenizer(TokenizersBackend):
+ """
+ Gemma tokenizer + SigLIP2 training default: lowercase normalization.
+ """
+
+ vocab_files_names = VOCAB_FILES_NAMES
+ padding_side = "left"
+ model_input_names = ["input_ids", "attention_mask"]
+ model = BPE
+
+ def __init__(
+ self,
+ vocab: str | dict[str, int] | None = None,
+ merges: str | list[str] | None = None,
+ unk_token: str = "<unk>",
+ bos_token: str = "<bos>",
+ eos_token: str = "<eos>",
+ pad_token: str = "<pad>",
+ mask_token: str = "<mask>",
+ **kwargs,
+ ):
+ if vocab is None:
+ vocab = {
+ str(pad_token): 0,
+ str(eos_token): 1,
+ str(bos_token): 2,
+ str(unk_token): 3,
+ str(mask_token): 4,
+ }
+ self._vocab = vocab
+ self._merges = merges or []
+
+ self._tokenizer = Tokenizer(
+ BPE(
+ vocab=self._vocab,
+ merges=self._merges,
+ fuse_unk=True,
+ unk_token=str(unk_token),
+ dropout=None,
+ byte_fallback=True,
+ )
+ )
+ self._tokenizer.pre_tokenizer = pre_tokenizers.Split(
+ pattern=" ", behavior="merged_with_previous", invert=False
+ )
+
+ self._tokenizer.decoder = decoders.Sequence(
+ [decoders.Replace("▁", " "), decoders.ByteFallback(), decoders.Fuse()]
+ )
+ self._tokenizer.normalizer = normalizers.Replace(" ", "▁")
+ super().__init__(
+ unk_token=unk_token,
+ bos_token=bos_token,
+ eos_token=eos_token,
+ pad_token=pad_token,
+ mask_token=mask_token,
+ **kwargs,
+ )
+
+ # Persist for save/load + push_to_hub dynamic tokenizer test
+ if hasattr(self, "init_kwargs") and isinstance(self.init_kwargs, dict):
+ self.init_kwargs.setdefault("tokenizer_class", self.__class__.__name__)
+
+ backend = getattr(self, "_tokenizer", None)
+ if backend is not None and backend.normalizer is not None:
+ backend.normalizer = normalizers.Sequence([normalizers.Lowercase(), backend.normalizer])
+
+
+__all__ = ["Siglip2Tokenizer"]
diff --git a/lib/python3.11/site-packages/transformers/models/slanet/__init__.py b/lib/python3.11/site-packages/transformers/models/slanet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..96d521f4972f899685c4df0590c5cd61e53dba7d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/slanet/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2026 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_slanet import *
+ from .modeling_slanet import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f855b9bea4825d9c4240896d7249c96ce4e9812
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/configuration_slanet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/configuration_slanet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e9e643d044a940b74318223d6115c267b4770b4f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/configuration_slanet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/modeling_slanet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/modeling_slanet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ecd266445219e27370c69589c8bd99e6e1dcf5a
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/modeling_slanet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/modular_slanet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/modular_slanet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05d8f855672dcd6e8708e27aa66d1268ee680f18
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/slanet/__pycache__/modular_slanet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/slanet/configuration_slanet.py b/lib/python3.11/site-packages/transformers/models/slanet/configuration_slanet.py
new file mode 100644
index 0000000000000000000000000000000000000000..74e27df7fbc2da8438f082e18db5e67c22ea2552
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/slanet/configuration_slanet.py
@@ -0,0 +1,77 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/slanet/modular_slanet.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_slanet.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import consolidate_backbone_kwargs_to_config
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import AutoConfig
+
+
+@auto_docstring(checkpoint="PaddlePaddle/SLANet_plus_safetensors")
+@strict
+class SLANetConfig(PreTrainedConfig):
+ r"""
+ post_conv_out_channels (`int`, *optional*, defaults to 96):
+ Number of output channels for the post-encoder convolution layer.
+ out_channels (`int`, *optional*, defaults to 50):
+ Vocabulary size for the table structure token prediction head, i.e., the number of distinct structure
+ tokens the model can predict.
+ hidden_size (`int`, *optional*, defaults to 256):
+ Dimensionality of the hidden states in the attention GRU cell and the structure/location prediction heads.
+ max_text_length (`int`, *optional*, defaults to 500):
+ Maximum number of autoregressive decoding steps (tokens) for the structure and location decoder.
+ csp_kernel_size (`int`, *optional*, defaults to 5):
+ The kernel size of the Cross Stage Partial (CSP) layer.
+ csp_num_blocks (`int`, *optional*, defaults to 1):
+ Number of blocks within the Cross Stage Partial (CSP) layer.
+ """
+
+ model_type = "slanet"
+
+ sub_configs = {"backbone_config": AutoConfig}
+ post_conv_out_channels: int = 96
+ out_channels: int = 50
+ hidden_size: int = 256
+ max_text_length: int = 500
+ backbone_config: dict | PreTrainedConfig | None = None
+
+ hidden_act: str = "hardswish"
+ csp_kernel_size: int = 5
+ csp_num_blocks: int = 1
+
+ def __post_init__(self, **kwargs):
+ self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+ backbone_config=self.backbone_config,
+ default_config_type="pp_lcnet",
+ default_config_kwargs={
+ "scale": 1,
+ "out_features": ["stage2", "stage3", "stage4", "stage5"],
+ "out_indices": [2, 3, 4, 5],
+ "divisor": 16,
+ },
+ **kwargs,
+ )
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["SLANetConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/slanet/modeling_slanet.py b/lib/python3.11/site-packages/transformers/models/slanet/modeling_slanet.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a25dc9b76012e401832c0262d72aed822781643
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/slanet/modeling_slanet.py
@@ -0,0 +1,480 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/slanet/modular_slanet.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_slanet.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ... import initialization as init
+from ...activations import ACT2CLS, ACT2FN
+from ...backbone_utils import filter_output_hidden_states, load_backbone
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, BaseModelOutputWithNoAttention
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_slanet import SLANetConfig
+
+
+class SLANetPreTrainedModel(PreTrainedModel):
+ config: SLANetConfig
+ base_model_prefix = "backbone"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = True
+ _keep_in_fp32_modules_strict = []
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ super()._init_weights(module)
+
+ # Initialize GRUCell (replicates PyTorch default reset_parameters)
+ if isinstance(module, nn.GRUCell):
+ std = 1.0 / math.sqrt(module.hidden_size) if module.hidden_size > 0 else 0
+ init.uniform_(module.weight_ih, -std, std)
+ init.uniform_(module.weight_hh, -std, std)
+ if module.bias_ih is not None:
+ init.uniform_(module.bias_ih, -std, std)
+ if module.bias_hh is not None:
+ init.uniform_(module.bias_hh, -std, std)
+
+ # Initialize SLAHead layers
+ if isinstance(module, SLANetSLAHead):
+ std = 1.0 / math.sqrt(self.config.hidden_size * 1.0)
+ # Initialize structure_generator and loc_generator layers
+ for generator in (module.structure_generator,):
+ for layer in generator.children():
+ if isinstance(layer, nn.Linear):
+ init.uniform_(layer.weight, -std, std)
+ if layer.bias is not None:
+ init.uniform_(layer.bias, -std, std)
+
+
+@auto_docstring
+@dataclass
+class SLANetForTableRecognitionOutput(BaseModelOutputWithNoAttention):
+ r"""
+ head_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Hidden-states of the SLANetSLAHead at each prediction step, varies up to max `self.config.max_text_length` states (depending on early exits).
+ head_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Attentions of the SLANetSLAHead at each prediction step, varies up to max `self.config.max_text_length` attentions (depending on early exits).
+ """
+
+ head_hidden_states: torch.FloatTensor | None = None
+ head_attentions: torch.FloatTensor | None = None
+
+
+class SLANetAttentionGRUCell(nn.Module):
+ def __init__(self, input_size, hidden_size, num_embeddings):
+ super().__init__()
+
+ self.input_to_hidden = nn.Linear(input_size, hidden_size, bias=False)
+ self.hidden_to_hidden = nn.Linear(hidden_size, hidden_size)
+ self.score = nn.Linear(hidden_size, 1, bias=False)
+
+ self.rnn = nn.GRUCell(input_size + num_embeddings, hidden_size)
+
+ def forward(
+ self,
+ prev_hidden: torch.FloatTensor,
+ batch_hidden: torch.FloatTensor,
+ char_onehots: torch.FloatTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ):
+ batch_hidden_proj = self.input_to_hidden(batch_hidden)
+ prev_hidden_proj = self.hidden_to_hidden(prev_hidden).unsqueeze(1)
+
+ attention_scores = batch_hidden_proj + prev_hidden_proj
+ attention_scores = torch.tanh(attention_scores)
+ attention_scores = self.score(attention_scores)
+
+ attn_weights = F.softmax(attention_scores, dim=1, dtype=torch.float32).to(attention_scores.dtype)
+ attn_weights = attn_weights.transpose(1, 2)
+ context = torch.matmul(attn_weights, batch_hidden).squeeze(1)
+ concat_context = torch.cat([context, char_onehots], 1)
+ hidden_states = self.rnn(concat_context, prev_hidden)
+
+ return hidden_states, attn_weights
+
+
+class SLANetMLP(nn.Module):
+ def __init__(self, hidden_size, out_channels, activation=None):
+ super().__init__()
+ self.fc1 = nn.Linear(hidden_size, hidden_size)
+ self.fc2 = nn.Linear(hidden_size, out_channels)
+ self.act_fn = nn.Identity() if activation is None else ACT2CLS[activation]()
+
+ def forward(self, hidden_states):
+ hidden_states = self.fc1(hidden_states)
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = self.act_fn(hidden_states)
+ return hidden_states
+
+
+class SLANetSLAHead(SLANetPreTrainedModel):
+ _can_record_outputs = {
+ "attentions": SLANetAttentionGRUCell,
+ }
+
+ def __init__(
+ self,
+ config: dict | None = None,
+ **kwargs,
+ ):
+ super().__init__(config)
+
+ self.structure_attention_cell = SLANetAttentionGRUCell(
+ config.post_conv_out_channels, config.hidden_size, config.out_channels
+ )
+ self.structure_generator = SLANetMLP(config.hidden_size, config.out_channels)
+
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @filter_output_hidden_states
+ def forward(
+ self,
+ hidden_states: torch.FloatTensor,
+ targets: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ):
+ features = torch.zeros(
+ (hidden_states.shape[0], self.config.hidden_size), dtype=torch.float32, device=hidden_states.device
+ )
+ predicted_chars = torch.zeros(size=[hidden_states.shape[0]], dtype=torch.long, device=hidden_states.device)
+
+ structure_preds_list = []
+ structure_ids_list = []
+ for _ in range(self.config.max_text_length + 1):
+ embedding_feature = F.one_hot(predicted_chars, self.config.out_channels).float()
+ features, _ = self.structure_attention_cell(features, hidden_states.float(), embedding_feature)
+ structure_step = self.structure_generator(features)
+ predicted_chars = structure_step.argmax(dim=1)
+
+ structure_preds_list.append(structure_step)
+ structure_ids_list.append(predicted_chars)
+ if torch.stack(structure_ids_list, dim=1).eq(self.config.out_channels - 1).any(-1).all():
+ break
+ structure_preds = F.softmax(torch.stack(structure_preds_list, dim=1), dim=-1, dtype=torch.float32).to(
+ hidden_states.dtype
+ )
+
+ return BaseModelOutput(last_hidden_state=structure_preds, hidden_states=structure_preds_list)
+
+
+class SLANetConvLayer(nn.Module):
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int = 3,
+ stride: int = 1,
+ bias: bool = False,
+ dilation: int | tuple[int, int] = 1,
+ groups: int = 1,
+ activation: str = "hardswish",
+ ):
+ super().__init__()
+ self.convolution = nn.Conv2d(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=kernel_size // 2,
+ bias=bias,
+ dilation=dilation,
+ groups=groups,
+ )
+ self.normalization = nn.BatchNorm2d(out_channels)
+ self.activation = ACT2FN[activation] if activation is not None else nn.Identity()
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.convolution(hidden_states)
+ hidden_states = self.normalization(hidden_states)
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+class SLANetDepthwiseSeparableConvLayer(GradientCheckpointingLayer):
+ """
+ Depthwise Separable Convolution Layer: Depthwise Conv -> Pointwise Conv
+ Core component of lightweight models (e.g., MobileNet, PP-LCNet) that significantly reduces
+ the number of parameters and computational cost.
+ """
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ stride,
+ kernel_size,
+ config,
+ ):
+ super().__init__()
+ self.depthwise_convolution = SLANetConvLayer(
+ in_channels=in_channels,
+ out_channels=in_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ groups=in_channels,
+ activation=config.hidden_act,
+ )
+ self.squeeze_excitation_module = nn.Identity()
+ self.pointwise_convolution = SLANetConvLayer(
+ in_channels=in_channels,
+ kernel_size=1,
+ out_channels=out_channels,
+ stride=1,
+ activation=config.hidden_act,
+ )
+
+ def forward(self, hidden_state):
+ hidden_state = self.depthwise_convolution(hidden_state)
+ hidden_state = self.squeeze_excitation_module(hidden_state)
+ hidden_state = self.pointwise_convolution(hidden_state)
+
+ return hidden_state
+
+
+class SLANetBottleneck(nn.Module):
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ kernel_size,
+ activation,
+ config,
+ ):
+ super().__init__()
+ self.conv1 = SLANetConvLayer(
+ in_channels=in_channels, out_channels=out_channels, kernel_size=1, activation=activation
+ )
+ self.conv2 = SLANetDepthwiseSeparableConvLayer(
+ in_channels=out_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=1,
+ config=config,
+ )
+
+ def forward(self, hidden_states: torch.FloatTensor) -> torch.FloatTensor:
+ hidden_states = self.conv1(hidden_states)
+ hidden_states = self.conv2(hidden_states)
+
+ return hidden_states
+
+
+class SLANetCSPLayer(nn.Module):
+ """
+ Cross Stage Partial (CSP) network layer. Similar in structure to DFineCSPRepLayer, but with a different forward computation.
+ """
+
+ def __init__(
+ self,
+ config,
+ in_channels,
+ out_channels,
+ kernel_size=3,
+ expansion=0.5,
+ num_blocks=1,
+ activation="hardswish",
+ ):
+ super().__init__()
+ hidden_channels = int(out_channels * expansion)
+ self.conv1 = SLANetConvLayer(in_channels, hidden_channels, 1, activation=activation)
+ self.conv2 = SLANetConvLayer(in_channels, hidden_channels, 1, activation=activation)
+ self.conv3 = SLANetConvLayer(2 * hidden_channels, out_channels, 1, activation=activation)
+ self.bottlenecks = nn.ModuleList(
+ [
+ SLANetBottleneck(hidden_channels, hidden_channels, kernel_size, activation, config)
+ for _ in range(num_blocks)
+ ]
+ )
+
+ def forward(self, hidden_states: torch.FloatTensor) -> torch.FloatTensor:
+ residual = self.conv1(hidden_states)
+
+ hidden_states = self.conv2(hidden_states)
+ for bottleneck in self.bottlenecks:
+ hidden_states = bottleneck(hidden_states)
+
+ hidden_states = torch.cat((hidden_states, residual), dim=1)
+ hidden_states = self.conv3(hidden_states)
+
+ return hidden_states
+
+
+class SLANetCSPPAN(nn.Module):
+ """
+ CSP-PAN: Path Aggregation Network with CSP layers
+ """
+
+ def __init__(
+ self,
+ config,
+ in_channel_list,
+ ):
+ super().__init__()
+ out_channels = config.post_conv_out_channels
+ activation = config.hidden_act
+ kernel_size = config.csp_kernel_size
+ csp_num_blocks = config.csp_num_blocks
+
+ self.channel_projector = nn.ModuleList(
+ [
+ SLANetConvLayer(
+ in_channels=in_channel_list[i], out_channels=out_channels, kernel_size=1, activation=activation
+ )
+ for i in range(len(in_channel_list))
+ ]
+ )
+
+ # build top-down blocks
+ self.upsample = nn.Upsample(scale_factor=2, mode="nearest")
+ self.top_down_blocks = nn.ModuleList(
+ [
+ SLANetCSPLayer(
+ config,
+ out_channels * 2,
+ out_channels,
+ kernel_size=kernel_size,
+ num_blocks=csp_num_blocks,
+ activation=activation,
+ )
+ for _ in range(len(in_channel_list) - 1, 0, -1)
+ ]
+ )
+
+ # build bottom-up blocks
+ self.downsamples = nn.ModuleList(
+ [
+ SLANetDepthwiseSeparableConvLayer(
+ out_channels,
+ out_channels,
+ kernel_size=kernel_size,
+ stride=2,
+ config=config,
+ )
+ for _ in range(len(in_channel_list) - 1)
+ ]
+ )
+ self.bottom_up_blocks = nn.ModuleList(
+ [
+ SLANetCSPLayer(
+ config,
+ out_channels * 2,
+ out_channels,
+ kernel_size=kernel_size,
+ num_blocks=csp_num_blocks,
+ activation=activation,
+ )
+ for _ in range(len(in_channel_list) - 1)
+ ]
+ )
+
+ def forward(self, hidden_states: torch.FloatTensor) -> torch.FloatTensor:
+ projected_features = []
+ for idx in range(len(self.channel_projector)):
+ projected_features.append(self.channel_projector[idx](hidden_states[idx]))
+
+ top_down_features = [projected_features[-1]]
+ for top_down_block, low_level_feature in zip(self.top_down_blocks, reversed(projected_features[:-1])):
+ high_level_feature = top_down_features[-1]
+ upsampled_feature = F.interpolate(
+ high_level_feature,
+ size=low_level_feature.shape[-2:],
+ mode="nearest",
+ )
+ fused_feature = top_down_block(torch.cat([upsampled_feature, low_level_feature], dim=1))
+ top_down_features.append(fused_feature)
+
+ pyramid_features = list(reversed(top_down_features))
+ output_feature = pyramid_features[0]
+ for downsample_layer, bottom_up_block, high_level_feature in zip(
+ self.downsamples, self.bottom_up_blocks, pyramid_features[1:]
+ ):
+ downsampled_feature = downsample_layer(output_feature)
+ output_feature = bottom_up_block(torch.cat([downsampled_feature, high_level_feature], dim=1))
+
+ hidden_states = output_feature.flatten(2).transpose(1, 2)
+ return hidden_states
+
+
+class SLANetBackbone(SLANetPreTrainedModel):
+ def __init__(self, config: SLANetConfig):
+ super().__init__(config)
+ self.vision_backbone = load_backbone(config)
+ self.post_csp_pan = SLANetCSPPAN(config, self.vision_backbone.num_features[2:])
+
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self, hidden_states: torch.FloatTensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple[torch.FloatTensor] | BaseModelOutputWithNoAttention:
+ outputs = self.vision_backbone(hidden_states, **kwargs)
+ hidden_states = self.post_csp_pan(outputs.feature_maps)
+ return BaseModelOutputWithNoAttention(
+ last_hidden_state=hidden_states,
+ hidden_states=outputs.hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ SLANet Table Recognition model for table recognition tasks. Wraps the core SLANetPreTrainedModel
+ and returns outputs compatible with the Transformers table recognition API.
+ """
+)
+class SLANetForTableRecognition(SLANetPreTrainedModel):
+ _keys_to_ignore_on_load_missing = ["num_batches_tracked"]
+
+ def __init__(self, config: SLANetConfig):
+ super().__init__(config)
+ self.backbone = SLANetBackbone(config=config)
+ self.head = SLANetSLAHead(config=config)
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self, pixel_values: torch.FloatTensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple[torch.FloatTensor] | SLANetForTableRecognitionOutput:
+ outputs = self.backbone(pixel_values, **kwargs)
+ head_outputs = self.head(outputs.last_hidden_state, **kwargs)
+ # Key difference: no attentions in its vision model
+ return SLANetForTableRecognitionOutput(
+ last_hidden_state=head_outputs.last_hidden_state,
+ hidden_states=outputs.hidden_states,
+ head_hidden_states=head_outputs.hidden_states,
+ head_attentions=head_outputs.attentions,
+ )
+
+
+__all__ = ["SLANetForTableRecognition", "SLANetPreTrainedModel", "SLANetSLAHead", "SLANetBackbone"]
diff --git a/lib/python3.11/site-packages/transformers/models/slanet/modular_slanet.py b/lib/python3.11/site-packages/transformers/models/slanet/modular_slanet.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c10a49fa8224b3ef7c517cf81356c58c3b19378
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/slanet/modular_slanet.py
@@ -0,0 +1,372 @@
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from huggingface_hub.dataclasses import strict
+
+from ... import initialization as init
+from ...backbone_utils import consolidate_backbone_kwargs_to_config, load_backbone
+from ...configuration_utils import PreTrainedConfig
+from ...modeling_outputs import BaseModelOutputWithNoAttention
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, logging
+from ..auto import AutoConfig
+from ..pp_lcnet.modeling_pp_lcnet import PPLCNetConvLayer, PPLCNetDepthwiseSeparableConvLayer
+from ..slanext.configuration_slanext import SLANeXtConfig
+from ..slanext.modeling_slanext import (
+ SLANeXtForTableRecognition,
+ SLANeXtPreTrainedModel,
+ SLANeXtSLAHead,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="PaddlePaddle/SLANet_plus_safetensors")
+@strict
+class SLANetConfig(SLANeXtConfig):
+ r"""
+ post_conv_out_channels (`int`, *optional*, defaults to 96):
+ Number of output channels for the post-encoder convolution layer.
+ out_channels (`int`, *optional*, defaults to 50):
+ Vocabulary size for the table structure token prediction head, i.e., the number of distinct structure
+ tokens the model can predict.
+ hidden_size (`int`, *optional*, defaults to 256):
+ Dimensionality of the hidden states in the attention GRU cell and the structure/location prediction heads.
+ max_text_length (`int`, *optional*, defaults to 500):
+ Maximum number of autoregressive decoding steps (tokens) for the structure and location decoder.
+ csp_kernel_size (`int`, *optional*, defaults to 5):
+ The kernel size of the Cross Stage Partial (CSP) layer.
+ csp_num_blocks (`int`, *optional*, defaults to 1):
+ Number of blocks within the Cross Stage Partial (CSP) layer.
+ """
+
+ sub_configs = {"backbone_config": AutoConfig}
+
+ vision_config = AttributeError()
+ backbone_config: dict | PreTrainedConfig | None = None
+
+ post_conv_in_channels = AttributeError()
+ post_conv_out_channels: int = 96
+ hidden_size: int = 256
+
+ hidden_act: str = "hardswish"
+ csp_kernel_size: int = 5
+ csp_num_blocks: int = 1
+
+ def __post_init__(self, **kwargs):
+ self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+ backbone_config=self.backbone_config,
+ default_config_type="pp_lcnet",
+ default_config_kwargs={
+ "scale": 1,
+ "out_features": ["stage2", "stage3", "stage4", "stage5"],
+ "out_indices": [2, 3, 4, 5],
+ "divisor": 16,
+ },
+ **kwargs,
+ )
+ PreTrainedConfig.__post_init__(**kwargs)
+
+
+class SLANetPreTrainedModel(SLANeXtPreTrainedModel):
+ _keep_in_fp32_modules_strict = []
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ PreTrainedModel._init_weights(module)
+
+ # Initialize GRUCell (replicates PyTorch default reset_parameters)
+ if isinstance(module, nn.GRUCell):
+ std = 1.0 / math.sqrt(module.hidden_size) if module.hidden_size > 0 else 0
+ init.uniform_(module.weight_ih, -std, std)
+ init.uniform_(module.weight_hh, -std, std)
+ if module.bias_ih is not None:
+ init.uniform_(module.bias_ih, -std, std)
+ if module.bias_hh is not None:
+ init.uniform_(module.bias_hh, -std, std)
+
+ # Initialize SLAHead layers
+ if isinstance(module, SLANetSLAHead):
+ std = 1.0 / math.sqrt(self.config.hidden_size * 1.0)
+ # Initialize structure_generator and loc_generator layers
+ for generator in (module.structure_generator,):
+ for layer in generator.children():
+ if isinstance(layer, nn.Linear):
+ init.uniform_(layer.weight, -std, std)
+ if layer.bias is not None:
+ init.uniform_(layer.bias, -std, std)
+
+
+@auto_docstring
+@dataclass
+class SLANetForTableRecognitionOutput(BaseModelOutputWithNoAttention):
+ r"""
+ head_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Hidden-states of the SLANetSLAHead at each prediction step, varies up to max `self.config.max_text_length` states (depending on early exits).
+ head_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Attentions of the SLANetSLAHead at each prediction step, varies up to max `self.config.max_text_length` attentions (depending on early exits).
+ """
+
+ head_hidden_states: torch.FloatTensor | None = None
+ head_attentions: torch.FloatTensor | None = None
+
+
+class SLANetSLAHead(SLANeXtSLAHead):
+ pass
+
+
+class SLANetConvLayer(PPLCNetConvLayer):
+ pass
+
+
+class SLANetDepthwiseSeparableConvLayer(PPLCNetDepthwiseSeparableConvLayer):
+ """
+ Depthwise Separable Convolution Layer: Depthwise Conv -> Pointwise Conv
+ Core component of lightweight models (e.g., MobileNet, PP-LCNet) that significantly reduces
+ the number of parameters and computational cost.
+ """
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ stride,
+ kernel_size,
+ config,
+ ):
+ super().__init__()
+ self.squeeze_excitation_module = nn.Identity()
+
+
+class SLANetBottleneck(nn.Module):
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ kernel_size,
+ activation,
+ config,
+ ):
+ super().__init__()
+ self.conv1 = SLANetConvLayer(
+ in_channels=in_channels, out_channels=out_channels, kernel_size=1, activation=activation
+ )
+ self.conv2 = SLANetDepthwiseSeparableConvLayer(
+ in_channels=out_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=1,
+ config=config,
+ )
+
+ def forward(self, hidden_states: torch.FloatTensor) -> torch.FloatTensor:
+ hidden_states = self.conv1(hidden_states)
+ hidden_states = self.conv2(hidden_states)
+
+ return hidden_states
+
+
+class SLANetCSPLayer(nn.Module):
+ """
+ Cross Stage Partial (CSP) network layer. Similar in structure to DFineCSPRepLayer, but with a different forward computation.
+ """
+
+ def __init__(
+ self,
+ config,
+ in_channels,
+ out_channels,
+ kernel_size=3,
+ expansion=0.5,
+ num_blocks=1,
+ activation="hardswish",
+ ):
+ super().__init__()
+ hidden_channels = int(out_channels * expansion)
+ self.conv1 = SLANetConvLayer(in_channels, hidden_channels, 1, activation=activation)
+ self.conv2 = SLANetConvLayer(in_channels, hidden_channels, 1, activation=activation)
+ self.conv3 = SLANetConvLayer(2 * hidden_channels, out_channels, 1, activation=activation)
+ self.bottlenecks = nn.ModuleList(
+ [
+ SLANetBottleneck(hidden_channels, hidden_channels, kernel_size, activation, config)
+ for _ in range(num_blocks)
+ ]
+ )
+
+ def forward(self, hidden_states: torch.FloatTensor) -> torch.FloatTensor:
+ residual = self.conv1(hidden_states)
+
+ hidden_states = self.conv2(hidden_states)
+ for bottleneck in self.bottlenecks:
+ hidden_states = bottleneck(hidden_states)
+
+ hidden_states = torch.cat((hidden_states, residual), dim=1)
+ hidden_states = self.conv3(hidden_states)
+
+ return hidden_states
+
+
+class SLANetCSPPAN(nn.Module):
+ """
+ CSP-PAN: Path Aggregation Network with CSP layers
+ """
+
+ def __init__(
+ self,
+ config,
+ in_channel_list,
+ ):
+ super().__init__()
+ out_channels = config.post_conv_out_channels
+ activation = config.hidden_act
+ kernel_size = config.csp_kernel_size
+ csp_num_blocks = config.csp_num_blocks
+
+ self.channel_projector = nn.ModuleList(
+ [
+ SLANetConvLayer(
+ in_channels=in_channel_list[i], out_channels=out_channels, kernel_size=1, activation=activation
+ )
+ for i in range(len(in_channel_list))
+ ]
+ )
+
+ # build top-down blocks
+ self.upsample = nn.Upsample(scale_factor=2, mode="nearest")
+ self.top_down_blocks = nn.ModuleList(
+ [
+ SLANetCSPLayer(
+ config,
+ out_channels * 2,
+ out_channels,
+ kernel_size=kernel_size,
+ num_blocks=csp_num_blocks,
+ activation=activation,
+ )
+ for _ in range(len(in_channel_list) - 1, 0, -1)
+ ]
+ )
+
+ # build bottom-up blocks
+ self.downsamples = nn.ModuleList(
+ [
+ SLANetDepthwiseSeparableConvLayer(
+ out_channels,
+ out_channels,
+ kernel_size=kernel_size,
+ stride=2,
+ config=config,
+ )
+ for _ in range(len(in_channel_list) - 1)
+ ]
+ )
+ self.bottom_up_blocks = nn.ModuleList(
+ [
+ SLANetCSPLayer(
+ config,
+ out_channels * 2,
+ out_channels,
+ kernel_size=kernel_size,
+ num_blocks=csp_num_blocks,
+ activation=activation,
+ )
+ for _ in range(len(in_channel_list) - 1)
+ ]
+ )
+
+ def forward(self, hidden_states: torch.FloatTensor) -> torch.FloatTensor:
+ projected_features = []
+ for idx in range(len(self.channel_projector)):
+ projected_features.append(self.channel_projector[idx](hidden_states[idx]))
+
+ top_down_features = [projected_features[-1]]
+ for top_down_block, low_level_feature in zip(self.top_down_blocks, reversed(projected_features[:-1])):
+ high_level_feature = top_down_features[-1]
+ upsampled_feature = F.interpolate(
+ high_level_feature,
+ size=low_level_feature.shape[-2:],
+ mode="nearest",
+ )
+ fused_feature = top_down_block(torch.cat([upsampled_feature, low_level_feature], dim=1))
+ top_down_features.append(fused_feature)
+
+ pyramid_features = list(reversed(top_down_features))
+ output_feature = pyramid_features[0]
+ for downsample_layer, bottom_up_block, high_level_feature in zip(
+ self.downsamples, self.bottom_up_blocks, pyramid_features[1:]
+ ):
+ downsampled_feature = downsample_layer(output_feature)
+ output_feature = bottom_up_block(torch.cat([downsampled_feature, high_level_feature], dim=1))
+
+ hidden_states = output_feature.flatten(2).transpose(1, 2)
+ return hidden_states
+
+
+class SLANetBackbone(SLANetPreTrainedModel):
+ def __init__(self, config: SLANetConfig):
+ super().__init__(config)
+ self.vision_backbone = load_backbone(config)
+ self.post_csp_pan = SLANetCSPPAN(config, self.vision_backbone.num_features[2:])
+
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self, hidden_states: torch.FloatTensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple[torch.FloatTensor] | BaseModelOutputWithNoAttention:
+ outputs = self.vision_backbone(hidden_states, **kwargs)
+ hidden_states = self.post_csp_pan(outputs.feature_maps)
+ return BaseModelOutputWithNoAttention(
+ last_hidden_state=hidden_states,
+ hidden_states=outputs.hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ SLANet Table Recognition model for table recognition tasks. Wraps the core SLANetPreTrainedModel
+ and returns outputs compatible with the Transformers table recognition API.
+ """
+)
+class SLANetForTableRecognition(SLANeXtForTableRecognition):
+ _keys_to_ignore_on_load_missing = ["num_batches_tracked"]
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self, pixel_values: torch.FloatTensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple[torch.FloatTensor] | SLANetForTableRecognitionOutput:
+ outputs = self.backbone(pixel_values, **kwargs)
+ head_outputs = self.head(outputs.last_hidden_state, **kwargs)
+ # Key difference: no attentions in its vision model
+ return SLANetForTableRecognitionOutput(
+ last_hidden_state=head_outputs.last_hidden_state,
+ hidden_states=outputs.hidden_states,
+ head_hidden_states=head_outputs.hidden_states,
+ head_attentions=head_outputs.attentions,
+ )
+
+
+__all__ = ["SLANetConfig", "SLANetForTableRecognition", "SLANetPreTrainedModel", "SLANetSLAHead", "SLANetBackbone"]
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/__init__.py b/lib/python3.11/site-packages/transformers/models/slanext/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcd21c1731d44ad05207078647116c7ee86e8502
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/slanext/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2026 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_slanext import *
+ from .image_processing_slanext import *
+ from .modeling_slanext import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3bd8ad020f209072f9da89d8e51a7d2b561a2b0a
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/configuration_slanext.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/configuration_slanext.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..876e534355d7f88b39e5c8ea84590f820dc3d1dd
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/configuration_slanext.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/image_processing_slanext.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/image_processing_slanext.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1a8fa61a76657586d9c4f76f74772fd48e395492
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/image_processing_slanext.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/modeling_slanext.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/modeling_slanext.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..085a634f69a57197aa081d5ef44f7a097b6441e2
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/modeling_slanext.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/modular_slanext.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/modular_slanext.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58c20c18da12153cb5d374534246eb62a7aad303
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/slanext/__pycache__/modular_slanext.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/configuration_slanext.py b/lib/python3.11/site-packages/transformers/models/slanext/configuration_slanext.py
new file mode 100644
index 0000000000000000000000000000000000000000..aac603aa4a01583a9350cb82bfe7fac1ce6b2f80
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/slanext/configuration_slanext.py
@@ -0,0 +1,103 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/slanext/modular_slanext.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_slanext.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="PaddlePaddle/SLANeXt_wired_safetensors")
+@strict
+class SLANeXtVisionConfig(PreTrainedConfig):
+ r"""
+ output_channels (`int`, *optional*, defaults to 256):
+ Dimensionality of the output channels in the Patch Encoder.
+ use_abs_pos (`bool`, *optional*, defaults to `True`):
+ Whether to use absolute position embedding.
+ use_rel_pos (`bool`, *optional*, defaults to `True`):
+ Whether to use relative position embedding.
+ window_size (`int`, *optional*, defaults to 14):
+ Window size for relative position.
+ global_attn_indexes (`list[int]`, *optional*, defaults to `[2, 5, 8, 11]`):
+ The indexes of the global attention layers.
+ mlp_dim (`int`, *optional*, defaults to 3072):
+ The dimensionality of the MLP layer in the Transformer encoder.
+ """
+
+ base_config_key = "vision_config"
+ hidden_size: int = 768
+ output_channels: int = 256
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ num_channels: int = 3
+ image_size: int = 512
+ patch_size: int | list[int] | tuple[int, int] = 16
+ hidden_act: str = "gelu"
+ layer_norm_eps: float = 1e-06
+ attention_dropout: float | int = 0.0
+ initializer_range: float = 1e-10
+ qkv_bias: bool = True
+ use_abs_pos: bool = True
+ use_rel_pos: bool = True
+ window_size: int = 14
+ global_attn_indexes: list[int] | tuple[int, ...] = (2, 5, 8, 11)
+ mlp_dim: int = 3072
+
+
+@auto_docstring(checkpoint="PaddlePaddle/SLANeXt_wired_safetensors")
+@strict
+class SLANeXtConfig(PreTrainedConfig):
+ r"""
+ vision_config (`dict` or [`SLANeXtVisionConfig`], *optional*):
+ Configuration for the vision encoder. If `None`, a default [`SLANeXtVisionConfig`] is used.
+ post_conv_in_channels (`int`, *optional*, defaults to 256):
+ Number of input channels for the post-encoder convolution layer.
+ post_conv_out_channels (`int`, *optional*, defaults to 512):
+ Number of output channels for the post-encoder convolution layer.
+ out_channels (`int`, *optional*, defaults to 50):
+ Vocabulary size for the table structure token prediction head, i.e., the number of distinct structure
+ tokens the model can predict.
+ hidden_size (`int`, *optional*, defaults to 512):
+ Dimensionality of the hidden states in the attention GRU cell and the structure/location prediction heads.
+ max_text_length (`int`, *optional*, defaults to 500):
+ Maximum number of autoregressive decoding steps (tokens) for the structure and location decoder.
+ """
+
+ model_type = "slanext"
+ sub_configs = {"vision_config": SLANeXtVisionConfig}
+
+ vision_config: dict | SLANeXtVisionConfig | None = None
+ post_conv_in_channels: int = 256
+ post_conv_out_channels: int = 512
+ out_channels: int = 50
+ hidden_size: int = 512
+ max_text_length: int = 500
+
+ def __post_init__(self, **kwargs):
+ if self.vision_config is None:
+ self.vision_config = SLANeXtVisionConfig()
+ elif isinstance(self.vision_config, dict):
+ self.vision_config = SLANeXtVisionConfig(**self.vision_config)
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["SLANeXtConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/image_processing_slanext.py b/lib/python3.11/site-packages/transformers/models/slanext/image_processing_slanext.py
new file mode 100644
index 0000000000000000000000000000000000000000..f87aed72137f8871b1a0212bb42b6fef194454ef
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/slanext/image_processing_slanext.py
@@ -0,0 +1,257 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/slanext/modular_slanext.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_slanext.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 torch
+import torchvision.transforms.v2.functional as tvF
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, SizeDict
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import auto_docstring, is_torchdynamo_compiling, logging
+from ...utils.generic import TensorType
+from ...utils.import_utils import requires
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring
+@requires(backends=("torch",))
+class SLANeXtImageProcessor(TorchvisionBackend):
+ resample = 2 # PILImageResampling.BILINEAR
+ image_mean = IMAGENET_DEFAULT_MEAN
+ image_std = IMAGENET_DEFAULT_STD
+ size = {"height": 512, "width": 512}
+ pad_size = {"height": 512, "width": 512}
+ do_convert_rgb = True
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ do_pad = True
+
+ def _resize(
+ self,
+ image: "torch.Tensor",
+ size: SizeDict,
+ ) -> "torch.Tensor":
+ batch_size, channels, height, width = image.shape
+ image = image.view(batch_size * channels, height, width)
+
+ device = image.device
+
+ scale = max(size.height, size.width) / max(height, width)
+ target_height = round(height * scale)
+ target_width = round(width * scale)
+
+ target_col = torch.arange(target_width, dtype=torch.float32, device=device)
+ src_col = (target_col + 0.5) * (float(width) / float(target_width)) - 0.5
+ src_col_floor = src_col.floor().to(torch.int32)
+ src_col_frac = src_col - src_col_floor.float()
+ # boundary handling
+ src_col_frac = torch.where(src_col_floor < 0, torch.zeros_like(src_col_frac), src_col_frac)
+ src_col_floor = torch.where(src_col_floor < 0, torch.zeros_like(src_col_floor), src_col_floor)
+ src_col_frac = torch.where(src_col_floor >= width - 1, torch.ones_like(src_col_frac), src_col_frac)
+ src_col_floor = torch.where(
+ src_col_floor >= width - 1, torch.full_like(src_col_floor, width - 2), src_col_floor
+ )
+ # fixed-point weights
+ weight_right = (src_col_frac * 2048 + 0.5).floor().to(torch.int32) # round-to-nearest
+ weight_left = 2048 - weight_right # (target_w,)
+ # --- row coordinate tables ---
+ target_row = torch.arange(target_height, dtype=torch.float32, device=device)
+ src_row = (target_row + 0.5) * (float(height) / float(target_height)) - 0.5
+ src_row_floor = src_row.floor().to(torch.int32)
+ src_row_frac = src_row - src_row_floor.float()
+ src_row_frac = torch.where(src_row_floor < 0, torch.zeros_like(src_row_frac), src_row_frac)
+ src_row_floor = torch.where(src_row_floor < 0, torch.zeros_like(src_row_floor), src_row_floor)
+ src_row_frac = torch.where(src_row_floor >= height - 1, torch.ones_like(src_row_frac), src_row_frac)
+ src_row_floor = torch.where(
+ src_row_floor >= height - 1, torch.full_like(src_row_floor, height - 2), src_row_floor
+ )
+ weight_bottom = (src_row_frac * 2048 + 0.5).floor().to(torch.int32)
+ weight_top = 2048 - weight_bottom # (target_h,)
+
+ image_uint8 = image.clamp(0, 255).to(torch.uint8) # (C, H, W)
+ image_int32 = image_uint8.to(torch.int32) # (C, H, W)
+ col_left = src_col_floor.long() # (target_w,)
+ col_right = (src_col_floor + 1).long() # (target_w,) safe: src_col_floor <= width-2
+ row_top = src_row_floor.long() # (target_h,)
+ row_bottom = (src_row_floor + 1).long() # (target_h,)
+ # gather 4 neighbours: (C, target_h, target_w)
+ pixel_top_left = image_int32[:, row_top[:, None], col_left[None, :]]
+ pixel_top_right = image_int32[:, row_top[:, None], col_right[None, :]]
+ pixel_bottom_left = image_int32[:, row_bottom[:, None], col_left[None, :]]
+ pixel_bottom_right = image_int32[:, row_bottom[:, None], col_right[None, :]]
+ # fixed-point bilinear: weights broadcast over (C, target_h, target_w)
+ weight_bottom_3d = weight_bottom.view(1, target_height, 1)
+ weight_top_3d = weight_top.view(1, target_height, 1)
+ weight_right_3d = weight_right.view(1, 1, target_width)
+ weight_left_3d = weight_left.view(1, 1, target_width)
+ interp = weight_top_3d * (
+ weight_left_3d * pixel_top_left + weight_right_3d * pixel_top_right
+ ) + weight_bottom_3d * (weight_left_3d * pixel_bottom_left + weight_right_3d * pixel_bottom_right)
+ interp = (interp + (1 << 21)) >> 22
+ result = interp.clamp(0, 255).to(torch.uint8) # (B*C, target_h, target_w)
+
+ return result.view(batch_size, channels, target_height, target_width).to(dtype=image.dtype)
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "tvF.InterpolationMode | int | None",
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_pad: bool | None,
+ pad_size: SizeDict | None,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ if resample is not None and not is_torchdynamo_compiling():
+ logger.warning_once("Resampling is not supported in SLANeXt")
+
+ # Group images by size for batched resizing
+ grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+ resized_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_resize:
+ stacked_images = self._resize(image=stacked_images, size=size)
+ resized_images_grouped[shape] = stacked_images
+ resized_images = reorder_images(resized_images_grouped, grouped_images_index)
+
+ # Group images by size for further processing
+ # Needed in case do_resize is False, or resize returns images with different sizes
+ grouped_images, grouped_images_index = group_images_by_shape(resized_images, disable_grouping=disable_grouping)
+ processed_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_center_crop:
+ stacked_images = self.center_crop(stacked_images, crop_size)
+ # Fused rescale and normalize
+ stacked_images = self.rescale_and_normalize(
+ stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ processed_images_grouped[shape] = stacked_images
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index)
+
+ if do_pad:
+ processed_images = self.pad(processed_images, pad_size=pad_size, disable_grouping=disable_grouping)
+
+ return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+ def __init__(self, **kwargs: Unpack[ImagesKwargs]):
+ super().__init__(**kwargs)
+ self.init_decoder()
+
+ def init_decoder(self):
+ """
+ Initialize the decoder vocabulary for table structure recognition.
+
+ Builds a character dictionary mapping HTML table structure tokens (e.g., `<thead>`, `<tr>`, `<td>`, colspan/
+ rowspan attributes) to integer indices. The dictionary includes special `"sos"` (start-of-sequence) and
+ `"eos"` (end-of-sequence) tokens. Merged `<td></td>` tokens are used in place of standalone `<td>` tokens
+ when applicable.
+ """
+ dict_character = [
+ "<thead>",
+ "</thead>",
+ "<tbody>",
+ "</tbody>",
+ "<tr>",
+ "</tr>",
+ "<td>",
+ "<td",
+ ">",
+ "</td>",
+ ]
+ dict_character += [f' colspan="{i + 2}"' for i in range(19)]
+ dict_character += [f' rowspan="{i + 2}"' for i in range(19)]
+
+ if "<td></td>" not in dict_character:
+ dict_character.append("<td></td>")
+ if "<td>" in dict_character:
+ dict_character.remove("<td>")
+
+ dict_character = ["sos"] + dict_character + ["eos"]
+ self.dict = {char: i for i, char in enumerate(dict_character)}
+ self.character = dict_character
+ self.td_token = ["<td>", "<td", "<td></td>"]
+ self.bos_id = self.dict["sos"]
+ self.eos_id = self.dict["eos"]
+
+ def post_process_table_recognition(self, outputs):
+ """
+ Post-process the raw model outputs to decode the predicted table structure into an HTML token sequence.
+
+ Converts the model's predicted probability distributions over the structure vocabulary into a sequence of
+ HTML tokens representing the table structure. The decoded tokens are wrapped with `<html>`, `<body>`, and
+ `<table>` tags to form a complete HTML table structure.
+
+ Args:
+ outputs ([`SLANeXtForTableRecognitionOutput`]):
+ Raw outputs from the SLANeXt model. The `last_hidden_state` field contains the predicted probability
+ distributions over the structure vocabulary at each decoding step, with shape
+ `(batch_size, max_text_length, num_classes)`.
+
+ Returns:
+ `dict`: A dictionary containing:
+ - **structure** (`list[str]`): The predicted HTML table structure as a list of tokens, wrapped with
+ `<html>`, `<body>`, and `<table>` tags.
+ - **structure_score** (`float`): The mean confidence score across all predicted tokens.
+ """
+ self.pred = outputs.last_hidden_state
+ structure_probs = self.pred[0:1]
+ ignored_tokens = [int(self.bos_id), int(self.eos_id)]
+ end_idx = int(self.eos_id)
+
+ structure_idx = structure_probs.argmax(dim=2)
+ structure_probs = structure_probs.max(dim=2).values
+
+ structure_str_list = []
+ batch_size = structure_idx.shape[0]
+ for batch_index in range(batch_size):
+ structure_list = []
+ score_list = []
+ for position in range(structure_idx.shape[1]):
+ char_idx = int(structure_idx[batch_index, position])
+ if position > 0 and char_idx == end_idx:
+ break
+ if char_idx in ignored_tokens:
+ continue
+ text = self.character[char_idx]
+ structure_list.append(text)
+ score_list.append(structure_probs[batch_index, position])
+ structure_str_list.append(structure_list)
+ structure_score = torch.stack(score_list).mean().item()
+
+ structure = ["<html>", "<body>", "<table>"] + structure_str_list[0] + ["</table>", "</body>", "</html>"]
+ return {"structure": structure, "structure_score": structure_score}
+
+
+__all__ = ["SLANeXtImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/modeling_slanext.py b/lib/python3.11/site-packages/transformers/models/slanext/modeling_slanext.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa7db0342d73c4b6022b9a8e5c92351c66f2953d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/slanext/modeling_slanext.py
@@ -0,0 +1,643 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/slanext/modular_slanext.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_slanext.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 collections
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ... import initialization as init
+from ...activations import ACT2CLS, ACT2FN
+from ...backbone_utils import filter_output_hidden_states
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, ModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_slanext import SLANeXtConfig, SLANeXtVisionConfig
+
+
+class SLANeXtVisionAttention(nn.Module):
+ """Multi-head Attention block with relative position embeddings."""
+
+ def __init__(self, config, window_size):
+ super().__init__()
+ input_size = (
+ (config.image_size // config.patch_size, config.image_size // config.patch_size)
+ if window_size == 0
+ else (window_size, window_size)
+ )
+
+ self.num_attention_heads = config.num_attention_heads
+ head_dim = config.hidden_size // config.num_attention_heads
+ self.scale = head_dim**-0.5
+ self.dropout = config.attention_dropout
+
+ self.qkv = nn.Linear(config.hidden_size, config.hidden_size * 3, bias=config.qkv_bias)
+ self.proj = nn.Linear(config.hidden_size, config.hidden_size)
+
+ self.use_rel_pos = config.use_rel_pos
+ if self.use_rel_pos:
+ if input_size is None:
+ raise ValueError("Input size must be provided if using relative positional encoding.")
+
+ # initialize relative positional embeddings
+ self.rel_pos_h = nn.Parameter(torch.zeros(2 * input_size[0] - 1, head_dim))
+ self.rel_pos_w = nn.Parameter(torch.zeros(2 * input_size[1] - 1, head_dim))
+
+ def get_rel_pos(self, q_size: int, k_size: int, rel_pos: torch.Tensor) -> torch.Tensor:
+ """
+ Get relative positional embeddings according to the relative positions of
+ query and key sizes.
+
+ Args:
+ q_size (int):
+ size of the query.
+ k_size (int):
+ size of key k.
+ rel_pos (`torch.Tensor`):
+ relative position embeddings (L, channel).
+
+ Returns:
+ Extracted positional embeddings according to relative positions.
+ """
+ max_rel_dist = int(2 * max(q_size, k_size) - 1)
+ # Interpolate rel pos.
+ rel_pos_resized = F.interpolate(
+ rel_pos.reshape(1, rel_pos.shape[0], -1).transpose(1, 2),
+ size=max_rel_dist,
+ mode="linear",
+ )
+ rel_pos_resized = rel_pos_resized.reshape(-1, max_rel_dist).permute(1, 0)
+
+ # Scale the coords with short length if shapes for q and k are different.
+ q_coords = torch.arange(q_size)[:, None] * max(k_size / q_size, 1.0)
+ k_coords = torch.arange(k_size)[None, :] * max(q_size / k_size, 1.0)
+ relative_coords = (q_coords - k_coords) + (k_size - 1) * max(q_size / k_size, 1.0)
+
+ return rel_pos_resized[relative_coords.long()]
+
+ def get_decomposed_rel_pos(
+ self,
+ query: torch.Tensor,
+ rel_pos_h: torch.Tensor,
+ rel_pos_w: torch.Tensor,
+ q_size: tuple[int, int],
+ k_size: tuple[int, int],
+ ) -> torch.Tensor:
+ """
+ Calculate decomposed Relative Positional Embeddings from :paper:`mvitv2`.
+ https://github.com/facebookresearch/mvit/blob/19786631e330df9f3622e5402b4a419a263a2c80/mvit/models/attention.py
+
+ Args:
+ query (`torch.Tensor`):
+ query q in the attention layer with shape (batch_size, query_height * query_width, channel).
+ rel_pos_h (`torch.Tensor`):
+ relative position embeddings (Lh, channel) for height axis.
+ rel_pos_w (`torch.Tensor`):
+ relative position embeddings (Lw, channel) for width axis.
+ q_size (tuple):
+ spatial sequence size of query q with (query_height, query_width).
+ k_size (tuple):
+ spatial sequence size of key k with (key_height, key_width).
+
+ Returns:
+ decomposed_rel_pos (`torch.Tensor`):
+ decomposed relative position embeddings.
+ """
+ query_height, query_width = q_size
+ key_height, key_width = k_size
+ relative_position_height = self.get_rel_pos(query_height, key_height, rel_pos_h)
+ relative_position_width = self.get_rel_pos(query_width, key_width, rel_pos_w)
+
+ batch_size, _, dim = query.shape
+ reshaped_query = query.reshape(batch_size, query_height, query_width, dim)
+ rel_h = torch.einsum("bhwc,hkc->bhwk", reshaped_query, relative_position_height)
+ rel_w = torch.einsum("bhwc,wkc->bhwk", reshaped_query, relative_position_width)
+
+ decomposed_rel_pos = rel_h[:, :, :, :, None] + rel_w[:, :, :, None, :]
+
+ return decomposed_rel_pos
+
+ def forward(self, hidden_states: torch.Tensor, output_attentions=None) -> tuple[torch.Tensor, torch.Tensor]:
+ batch_size, height, width, _ = hidden_states.shape
+ # qkv with shape (3, batch_size, nHead, height * width, channel)
+ qkv = (
+ self.qkv(hidden_states)
+ .reshape(batch_size, height * width, 3, self.num_attention_heads, -1)
+ .permute(2, 0, 3, 1, 4)
+ )
+ # q, k, v with shape (batch_size * nHead, height * width, channel)
+ query, key, value = qkv.reshape(3, batch_size * self.num_attention_heads, height * width, -1).unbind(0)
+
+ attn_weights = (query * self.scale) @ key.transpose(-2, -1)
+
+ if self.use_rel_pos:
+ decomposed_rel_pos = self.get_decomposed_rel_pos(
+ query, self.rel_pos_h, self.rel_pos_w, (height, width), (height, width)
+ )
+ decomposed_rel_pos = decomposed_rel_pos.reshape_as(attn_weights)
+ attn_weights = attn_weights + decomposed_rel_pos
+
+ attn_weights = torch.nn.functional.softmax(attn_weights, dtype=torch.float32, dim=-1).to(query.dtype)
+
+ attn_probs = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+ attn_output = (attn_probs @ value).reshape(batch_size, self.num_attention_heads, height, width, -1)
+ attn_output = attn_output.permute(0, 2, 3, 1, 4).reshape(batch_size, height, width, -1)
+
+ attn_output = self.proj(attn_output)
+ return attn_output, attn_weights
+
+
+class SLANeXtAttentionGRUCell(nn.Module):
+ def __init__(self, input_size, hidden_size, num_embeddings):
+ super().__init__()
+
+ self.input_to_hidden = nn.Linear(input_size, hidden_size, bias=False)
+ self.hidden_to_hidden = nn.Linear(hidden_size, hidden_size)
+ self.score = nn.Linear(hidden_size, 1, bias=False)
+
+ self.rnn = nn.GRUCell(input_size + num_embeddings, hidden_size)
+
+ def forward(
+ self,
+ prev_hidden: torch.FloatTensor,
+ batch_hidden: torch.FloatTensor,
+ char_onehots: torch.FloatTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ):
+ batch_hidden_proj = self.input_to_hidden(batch_hidden)
+ prev_hidden_proj = self.hidden_to_hidden(prev_hidden).unsqueeze(1)
+
+ attention_scores = batch_hidden_proj + prev_hidden_proj
+ attention_scores = torch.tanh(attention_scores)
+ attention_scores = self.score(attention_scores)
+
+ attn_weights = F.softmax(attention_scores, dim=1, dtype=torch.float32).to(attention_scores.dtype)
+ attn_weights = attn_weights.transpose(1, 2)
+ context = torch.matmul(attn_weights, batch_hidden).squeeze(1)
+ concat_context = torch.cat([context, char_onehots], 1)
+ hidden_states = self.rnn(concat_context, prev_hidden)
+
+ return hidden_states, attn_weights
+
+
+class SLANeXtMLP(nn.Module):
+ def __init__(self, hidden_size, out_channels, activation=None):
+ super().__init__()
+ self.fc1 = nn.Linear(hidden_size, hidden_size)
+ self.fc2 = nn.Linear(hidden_size, out_channels)
+ self.act_fn = nn.Identity() if activation is None else ACT2CLS[activation]()
+
+ def forward(self, hidden_states):
+ hidden_states = self.fc1(hidden_states)
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = self.act_fn(hidden_states)
+ return hidden_states
+
+
+class SLANeXtPreTrainedModel(PreTrainedModel):
+ config: SLANeXtConfig
+ base_model_prefix = "backbone"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = True
+ _keep_in_fp32_modules_strict = ["structure_attention_cell", "structure_generator"]
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ super()._init_weights(module)
+
+ # Initialize positional embeddings to zero (SLANeXtVisionEncoder holds pos_embed)
+ if isinstance(module, SLANeXtVisionEncoder):
+ if module.pos_embed is not None:
+ init.constant_(module.pos_embed, 0.0)
+
+ # Initialize relative positional embeddings to zero (SLANeXtVisionAttention holds rel_pos_h/w)
+ if isinstance(module, SLANeXtVisionAttention):
+ if module.use_rel_pos:
+ init.constant_(module.rel_pos_h, 0.0)
+ init.constant_(module.rel_pos_w, 0.0)
+
+ # Initialize GRUCell (replicates PyTorch default reset_parameters)
+ if isinstance(module, nn.GRUCell):
+ std = 1.0 / math.sqrt(module.hidden_size) if module.hidden_size > 0 else 0
+ init.uniform_(module.weight_ih, -std, std)
+ init.uniform_(module.weight_hh, -std, std)
+ if module.bias_ih is not None:
+ init.uniform_(module.bias_ih, -std, std)
+ if module.bias_hh is not None:
+ init.uniform_(module.bias_hh, -std, std)
+
+ # Initialize SLAHead layers
+ if isinstance(module, SLANeXtSLAHead):
+ std = 1.0 / math.sqrt(self.config.hidden_size * 1.0)
+ # Initialize structure_generator and loc_generator layers
+ for generator in (module.structure_generator,):
+ for layer in generator.children():
+ if isinstance(layer, nn.Linear):
+ init.uniform_(layer.weight, -std, std)
+ if layer.bias is not None:
+ init.uniform_(layer.bias, -std, std)
+
+
+class SLANeXtMLPBlock(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.lin1 = nn.Linear(config.hidden_size, config.mlp_dim)
+ self.lin2 = nn.Linear(config.mlp_dim, config.hidden_size)
+ self.act = ACT2FN[config.hidden_act]
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.lin1(hidden_states)
+ hidden_states = self.act(hidden_states)
+ hidden_states = self.lin2(hidden_states)
+ return hidden_states
+
+
+class SLANeXtVisionLayer(GradientCheckpointingLayer):
+ def __init__(self, config, window_size):
+ super().__init__()
+ self.layer_norm1 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.attn = SLANeXtVisionAttention(config, window_size)
+ self.layer_norm2 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.mlp = SLANeXtMLPBlock(config)
+ self.window_size = window_size
+
+ def window_partition(self, hidden_states: torch.Tensor, window_size: int) -> tuple[torch.Tensor, tuple[int, int]]:
+ """
+ Args:
+ Partition into non-overlapping windows with padding if needed.
+ hidden_states (tensor): input tokens with [batch_size, height, width, channel]. window_size (int): window
+ size.
+
+ Returns:
+ windows: windows after partition with [batch_size * num_windows, window_size, window_size, channel].
+ (pad_height, pad_width): padded height and width before partition
+ """
+ batch_size, height, width, channel = hidden_states.shape
+
+ pad_h = (window_size - height % window_size) % window_size
+ pad_w = (window_size - width % window_size) % window_size
+ hidden_states = F.pad(hidden_states, (0, 0, 0, pad_w, 0, pad_h))
+ pad_height, pad_width = height + pad_h, width + pad_w
+
+ hidden_states = hidden_states.reshape(
+ batch_size, pad_height // window_size, window_size, pad_width // window_size, window_size, channel
+ )
+ windows = hidden_states.permute(0, 1, 3, 2, 4, 5).contiguous().reshape(-1, window_size, window_size, channel)
+ return windows, (pad_height, pad_width)
+
+ def window_unpartition(
+ self, windows: torch.Tensor, window_size: int, padding_shape: tuple[int, int], original_shape: tuple[int, int]
+ ) -> torch.Tensor:
+ """
+ Args:
+ Window unpartition into original sequences and removing padding.
+ hidden_states (tensor):
+ input tokens with [batch_size * num_windows, window_size, window_size, channel].
+ window_size (int):
+ window size.
+ padding_shape (Tuple):
+ padded height and width (pad_height, pad_width).
+ original_shape (Tuple): original height and width (height, width) before padding.
+
+ Returns:
+ hidden_states: unpartitioned sequences with [batch_size, height, width, channel].
+ """
+ pad_height, pad_width = padding_shape
+ height, width = original_shape
+ batch_size = windows.shape[0] // (pad_height * pad_width // window_size // window_size)
+ hidden_states = windows.reshape(
+ batch_size, pad_height // window_size, pad_width // window_size, window_size, window_size, -1
+ )
+ hidden_states = (
+ hidden_states.permute(0, 1, 3, 2, 4, 5).contiguous().reshape(batch_size, pad_height, pad_width, -1)
+ )
+
+ hidden_states = hidden_states[:, :height, :width, :].contiguous()
+ return hidden_states
+
+ def forward(self, hidden_states: torch.Tensor) -> tuple[torch.FloatTensor]:
+ residual = hidden_states
+ hidden_states = self.layer_norm1(hidden_states)
+ # Window partition
+ if self.window_size > 0:
+ height, width = hidden_states.shape[1], hidden_states.shape[2]
+ hidden_states, padding_shape = self.window_partition(hidden_states, self.window_size)
+
+ hidden_states, attn_weights = self.attn(
+ hidden_states=hidden_states,
+ )
+ # Reverse window partition
+ if self.window_size > 0:
+ hidden_states = self.window_unpartition(hidden_states, self.window_size, padding_shape, (height, width))
+
+ hidden_states = residual + hidden_states
+ layernorm_output = self.layer_norm2(hidden_states)
+ hidden_states = hidden_states + self.mlp(layernorm_output)
+ return hidden_states
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for slanext vision model's outputs that also contains image embeddings obtained by applying the projection
+ layer to the pooler_output.
+ """
+)
+@dataclass
+class SLANeXtVisionEncoderOutput(ModelOutput):
+ r"""
+ image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
+ The image embeddings obtained by applying the projection layer to the pooler_output.
+ """
+
+ image_embeds: torch.FloatTensor | None = None
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+
+
+class SLANeXtPatchEmbeddings(nn.Module):
+ """
+ This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
+ `hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
+ Transformer.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ image_size, patch_size = config.image_size, config.patch_size
+ num_channels, hidden_size = config.num_channels, config.hidden_size
+ image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+ num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
+ self.image_size = image_size
+ self.patch_size = patch_size
+ self.num_channels = num_channels
+ self.num_patches = num_patches
+
+ self.projection = nn.Conv2d(num_channels, hidden_size, kernel_size=patch_size, stride=patch_size)
+
+ def forward(self, pixel_values):
+ batch_size, num_channels, height, width = pixel_values.shape
+ 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."
+ )
+ if height != self.image_size[0] or width != self.image_size[1]:
+ raise ValueError(
+ f"Input image size ({height}*{width}) doesn't match model ({self.image_size[0]}*{self.image_size[1]})."
+ )
+ embeddings = self.projection(pixel_values).permute(0, 2, 3, 1)
+ return embeddings
+
+
+class SLANeXtLayerNorm(nn.LayerNorm):
+ r"""LayerNorm that supports two data formats: channels_last (default) or channels_first.
+ The ordering of the dimensions in the inputs. channels_last corresponds to inputs with shape (batch_size, height,
+ width, channels) while channels_first corresponds to inputs with shape (batch_size, channels, height, width).
+ """
+
+ def __init__(self, normalized_shape, *, eps=1e-6, data_format="channels_last", **kwargs):
+ super().__init__(normalized_shape, eps=eps, **kwargs)
+ if data_format not in ["channels_last", "channels_first"]:
+ raise NotImplementedError(f"Unsupported data format: {data_format}")
+ self.data_format = data_format
+
+ def forward(self, features: torch.Tensor) -> torch.Tensor:
+ """
+ Args:
+ features: Tensor of shape (batch_size, channels, height, width) OR (batch_size, height, width, channels)
+ """
+ if self.data_format == "channels_first":
+ features = features.permute(0, 2, 3, 1)
+ features = super().forward(features)
+ features = features.permute(0, 3, 1, 2)
+ else:
+ features = super().forward(features)
+ return features
+
+
+class SLANeXtVisionNeck(nn.Module):
+ def __init__(self, config: SLANeXtVisionConfig):
+ super().__init__()
+ self.config = config
+
+ self.conv1 = nn.Conv2d(config.hidden_size, config.output_channels, kernel_size=1, bias=False)
+ self.layer_norm1 = SLANeXtLayerNorm(config.output_channels, data_format="channels_first")
+ self.conv2 = nn.Conv2d(config.output_channels, config.output_channels, kernel_size=3, padding=1, bias=False)
+ self.layer_norm2 = SLANeXtLayerNorm(config.output_channels, data_format="channels_first")
+
+ def forward(self, hidden_states):
+ hidden_states = hidden_states.permute(0, 3, 1, 2)
+ hidden_states = self.conv1(hidden_states)
+ hidden_states = self.layer_norm1(hidden_states)
+
+ hidden_states = self.conv2(hidden_states)
+ hidden_states = self.layer_norm2(hidden_states)
+ return hidden_states
+
+
+class SLANeXtVisionEncoder(SLANeXtPreTrainedModel):
+ _can_record_outputs = {"hidden_states": SLANeXtVisionLayer, "attentions": SLANeXtVisionAttention}
+ input_modalities = ("image",)
+
+ def __init__(self, config: SLANeXtVisionConfig):
+ super().__init__(config)
+ self.config = config
+ self.image_size = config.image_size
+ self.patch_embed = SLANeXtPatchEmbeddings(config)
+
+ self.pos_embed = None
+ if config.use_abs_pos:
+ # Initialize absolute positional embedding with pretrain image size.
+ self.pos_embed = nn.Parameter(
+ torch.zeros(
+ 1,
+ config.image_size // config.patch_size,
+ config.image_size // config.patch_size,
+ config.hidden_size,
+ )
+ )
+
+ self.layers = nn.ModuleList()
+ for i in range(config.num_hidden_layers):
+ layer = SLANeXtVisionLayer(
+ config,
+ window_size=config.window_size if i not in config.global_attn_indexes else 0,
+ )
+ self.layers.append(layer)
+
+ self.neck = SLANeXtVisionNeck(config)
+
+ self.gradient_checkpointing = False
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.patch_embed
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ def forward(
+ self, pixel_values: torch.FloatTensor | None = None, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple | SLANeXtVisionEncoderOutput:
+ if pixel_values is None:
+ raise ValueError("You have to specify pixel_values")
+
+ hidden_states = self.patch_embed(pixel_values)
+ if self.pos_embed is not None:
+ hidden_states = hidden_states + self.pos_embed
+ for layer_module in self.layers:
+ hidden_states = layer_module(hidden_states)
+ hidden_states = self.neck(hidden_states)
+ return SLANeXtVisionEncoderOutput(
+ last_hidden_state=hidden_states,
+ )
+
+
+class SLANeXtBackbone(SLANeXtPreTrainedModel):
+ def __init__(
+ self,
+ config: dict | None = None,
+ **kwargs,
+ ):
+ super().__init__(config)
+ self.vision_tower = SLANeXtVisionEncoder(config.vision_config)
+ self.post_conv = nn.Conv2d(
+ config.post_conv_in_channels, config.post_conv_out_channels, kernel_size=3, stride=2, padding=1, bias=False
+ )
+ self.post_init()
+
+ def forward(self, hidden_states: torch.Tensor, **kwargs: Unpack[TransformersKwargs]):
+ vision_output = self.vision_tower(hidden_states, **kwargs)
+ hidden_states = self.post_conv(vision_output.last_hidden_state)
+ hidden_states = hidden_states.flatten(2).transpose(1, 2)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=vision_output.hidden_states,
+ attentions=vision_output.attentions,
+ )
+
+
+class SLANeXtSLAHead(SLANeXtPreTrainedModel):
+ _can_record_outputs = {
+ "attentions": SLANeXtAttentionGRUCell,
+ }
+
+ def __init__(
+ self,
+ config: dict | None = None,
+ **kwargs,
+ ):
+ super().__init__(config)
+
+ self.structure_attention_cell = SLANeXtAttentionGRUCell(
+ config.post_conv_out_channels, config.hidden_size, config.out_channels
+ )
+ self.structure_generator = SLANeXtMLP(config.hidden_size, config.out_channels)
+
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @filter_output_hidden_states
+ def forward(
+ self,
+ hidden_states: torch.FloatTensor,
+ targets: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ):
+ features = torch.zeros(
+ (hidden_states.shape[0], self.config.hidden_size), dtype=torch.float32, device=hidden_states.device
+ )
+ predicted_chars = torch.zeros(size=[hidden_states.shape[0]], dtype=torch.long, device=hidden_states.device)
+
+ structure_preds_list = []
+ structure_ids_list = []
+ for _ in range(self.config.max_text_length + 1):
+ embedding_feature = F.one_hot(predicted_chars, self.config.out_channels).float()
+ features, _ = self.structure_attention_cell(features, hidden_states.float(), embedding_feature)
+ structure_step = self.structure_generator(features)
+ predicted_chars = structure_step.argmax(dim=1)
+
+ structure_preds_list.append(structure_step)
+ structure_ids_list.append(predicted_chars)
+ if torch.stack(structure_ids_list, dim=1).eq(self.config.out_channels - 1).any(-1).all():
+ break
+ structure_preds = F.softmax(torch.stack(structure_preds_list, dim=1), dim=-1, dtype=torch.float32).to(
+ hidden_states.dtype
+ )
+
+ return BaseModelOutput(last_hidden_state=structure_preds, hidden_states=structure_preds_list)
+
+
+@auto_docstring
+@dataclass
+class SLANeXtForTableRecognitionOutput(BaseModelOutput):
+ r"""
+ head_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Hidden-states of the SLANeXtSLAHead at each prediction step, varies up to max `self.config.max_text_length` states (depending on early exits).
+ head_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Attentions of the SLANeXtSLAHead at each prediction step, varies up to max `self.config.max_text_length` attentions (depending on early exits).
+ """
+
+ head_hidden_states: torch.FloatTensor | None = None
+ head_attentions: torch.FloatTensor | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ SLANeXt Table Recognition model for table recognition tasks. Wraps the core SLANeXtPreTrainedModel
+ and returns outputs compatible with the Transformers table recognition API.
+ """
+)
+class SLANeXtForTableRecognition(SLANeXtPreTrainedModel):
+ def __init__(self, config: SLANeXtConfig):
+ super().__init__(config)
+ self.backbone = SLANeXtBackbone(config=config)
+ self.head = SLANeXtSLAHead(config=config)
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self, pixel_values: torch.FloatTensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple[torch.FloatTensor] | SLANeXtForTableRecognitionOutput:
+ backbone_outputs = self.backbone(pixel_values, **kwargs)
+ head_outputs = self.head(backbone_outputs.last_hidden_state, **kwargs)
+ return SLANeXtForTableRecognitionOutput(
+ last_hidden_state=head_outputs.last_hidden_state,
+ hidden_states=backbone_outputs.hidden_states,
+ attentions=backbone_outputs.attentions,
+ head_hidden_states=head_outputs.hidden_states,
+ head_attentions=head_outputs.attentions,
+ )
+
+
+__all__ = ["SLANeXtSLAHead", "SLANeXtBackbone", "SLANeXtForTableRecognition", "SLANeXtPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/slanext/modular_slanext.py b/lib/python3.11/site-packages/transformers/models/slanext/modular_slanext.py
new file mode 100644
index 0000000000000000000000000000000000000000..a63acd1e362d19cecab15acec159897b0918aefa
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/slanext/modular_slanext.py
@@ -0,0 +1,539 @@
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms.v2.functional as tvF
+from huggingface_hub.dataclasses import strict
+
+from ... import initialization as init
+from ...activations import ACT2CLS
+from ...backbone_utils import filter_output_hidden_states
+from ...configuration_utils import PreTrainedConfig
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, SizeDict
+from ...modeling_outputs import BaseModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, is_torchdynamo_compiling, logging
+from ...utils.generic import TensorType, merge_with_config_defaults
+from ...utils.import_utils import requires
+from ...utils.output_capturing import capture_outputs
+from ..got_ocr2.configuration_got_ocr2 import GotOcr2VisionConfig
+from ..got_ocr2.modeling_got_ocr2 import (
+ GotOcr2VisionAttention,
+ GotOcr2VisionEncoder,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="PaddlePaddle/SLANeXt_wired_safetensors")
+@strict
+class SLANeXtVisionConfig(GotOcr2VisionConfig):
+ image_size: int = 512
+
+
+class SLANeXtVisionAttention(GotOcr2VisionAttention):
+ pass
+
+
+@auto_docstring(checkpoint="PaddlePaddle/SLANeXt_wired_safetensors")
+@strict
+class SLANeXtConfig(PreTrainedConfig):
+ r"""
+ vision_config (`dict` or [`SLANeXtVisionConfig`], *optional*):
+ Configuration for the vision encoder. If `None`, a default [`SLANeXtVisionConfig`] is used.
+ post_conv_in_channels (`int`, *optional*, defaults to 256):
+ Number of input channels for the post-encoder convolution layer.
+ post_conv_out_channels (`int`, *optional*, defaults to 512):
+ Number of output channels for the post-encoder convolution layer.
+ out_channels (`int`, *optional*, defaults to 50):
+ Vocabulary size for the table structure token prediction head, i.e., the number of distinct structure
+ tokens the model can predict.
+ hidden_size (`int`, *optional*, defaults to 512):
+ Dimensionality of the hidden states in the attention GRU cell and the structure/location prediction heads.
+ max_text_length (`int`, *optional*, defaults to 500):
+ Maximum number of autoregressive decoding steps (tokens) for the structure and location decoder.
+ """
+
+ model_type = "slanext"
+ sub_configs = {"vision_config": SLANeXtVisionConfig}
+
+ vision_config: dict | SLANeXtVisionConfig | None = None
+ post_conv_in_channels: int = 256
+ post_conv_out_channels: int = 512
+ out_channels: int = 50
+ hidden_size: int = 512
+ max_text_length: int = 500
+
+ def __post_init__(self, **kwargs):
+ if self.vision_config is None:
+ self.vision_config = SLANeXtVisionConfig()
+ elif isinstance(self.vision_config, dict):
+ self.vision_config = SLANeXtVisionConfig(**self.vision_config)
+ super().__post_init__(**kwargs)
+
+
+class SLANeXtAttentionGRUCell(nn.Module):
+ def __init__(self, input_size, hidden_size, num_embeddings):
+ super().__init__()
+
+ self.input_to_hidden = nn.Linear(input_size, hidden_size, bias=False)
+ self.hidden_to_hidden = nn.Linear(hidden_size, hidden_size)
+ self.score = nn.Linear(hidden_size, 1, bias=False)
+
+ self.rnn = nn.GRUCell(input_size + num_embeddings, hidden_size)
+
+ def forward(
+ self,
+ prev_hidden: torch.FloatTensor,
+ batch_hidden: torch.FloatTensor,
+ char_onehots: torch.FloatTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ):
+ batch_hidden_proj = self.input_to_hidden(batch_hidden)
+ prev_hidden_proj = self.hidden_to_hidden(prev_hidden).unsqueeze(1)
+
+ attention_scores = batch_hidden_proj + prev_hidden_proj
+ attention_scores = torch.tanh(attention_scores)
+ attention_scores = self.score(attention_scores)
+
+ attn_weights = F.softmax(attention_scores, dim=1, dtype=torch.float32).to(attention_scores.dtype)
+ attn_weights = attn_weights.transpose(1, 2)
+ context = torch.matmul(attn_weights, batch_hidden).squeeze(1)
+ concat_context = torch.cat([context, char_onehots], 1)
+ hidden_states = self.rnn(concat_context, prev_hidden)
+
+ return hidden_states, attn_weights
+
+
+class SLANeXtMLP(nn.Module):
+ def __init__(self, hidden_size, out_channels, activation=None):
+ super().__init__()
+ self.fc1 = nn.Linear(hidden_size, hidden_size)
+ self.fc2 = nn.Linear(hidden_size, out_channels)
+ self.act_fn = nn.Identity() if activation is None else ACT2CLS[activation]()
+
+ def forward(self, hidden_states):
+ hidden_states = self.fc1(hidden_states)
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = self.act_fn(hidden_states)
+ return hidden_states
+
+
+class SLANeXtPreTrainedModel(PreTrainedModel):
+ config: SLANeXtConfig
+ base_model_prefix = "backbone"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = True
+ _keep_in_fp32_modules_strict = ["structure_attention_cell", "structure_generator"]
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ super()._init_weights(module)
+
+ # Initialize positional embeddings to zero (SLANeXtVisionEncoder holds pos_embed)
+ if isinstance(module, SLANeXtVisionEncoder):
+ if module.pos_embed is not None:
+ init.constant_(module.pos_embed, 0.0)
+
+ # Initialize relative positional embeddings to zero (SLANeXtVisionAttention holds rel_pos_h/w)
+ if isinstance(module, SLANeXtVisionAttention):
+ if module.use_rel_pos:
+ init.constant_(module.rel_pos_h, 0.0)
+ init.constant_(module.rel_pos_w, 0.0)
+
+ # Initialize GRUCell (replicates PyTorch default reset_parameters)
+ if isinstance(module, nn.GRUCell):
+ std = 1.0 / math.sqrt(module.hidden_size) if module.hidden_size > 0 else 0
+ init.uniform_(module.weight_ih, -std, std)
+ init.uniform_(module.weight_hh, -std, std)
+ if module.bias_ih is not None:
+ init.uniform_(module.bias_ih, -std, std)
+ if module.bias_hh is not None:
+ init.uniform_(module.bias_hh, -std, std)
+
+ # Initialize SLAHead layers
+ if isinstance(module, SLANeXtSLAHead):
+ std = 1.0 / math.sqrt(self.config.hidden_size * 1.0)
+ # Initialize structure_generator and loc_generator layers
+ for generator in (module.structure_generator,):
+ for layer in generator.children():
+ if isinstance(layer, nn.Linear):
+ init.uniform_(layer.weight, -std, std)
+ if layer.bias is not None:
+ init.uniform_(layer.bias, -std, std)
+
+
+class SLANeXtVisionEncoder(GotOcr2VisionEncoder):
+ pass
+
+
+class SLANeXtBackbone(SLANeXtPreTrainedModel):
+ def __init__(
+ self,
+ config: dict | None = None,
+ **kwargs,
+ ):
+ super().__init__(config)
+ self.vision_tower = SLANeXtVisionEncoder(config.vision_config)
+ self.post_conv = nn.Conv2d(
+ config.post_conv_in_channels, config.post_conv_out_channels, kernel_size=3, stride=2, padding=1, bias=False
+ )
+ self.post_init()
+
+ def forward(self, hidden_states: torch.Tensor, **kwargs: Unpack[TransformersKwargs]):
+ vision_output = self.vision_tower(hidden_states, **kwargs)
+ hidden_states = self.post_conv(vision_output.last_hidden_state)
+ hidden_states = hidden_states.flatten(2).transpose(1, 2)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=vision_output.hidden_states,
+ attentions=vision_output.attentions,
+ )
+
+
+class SLANeXtSLAHead(SLANeXtPreTrainedModel):
+ _can_record_outputs = {
+ "attentions": SLANeXtAttentionGRUCell,
+ }
+
+ def __init__(
+ self,
+ config: dict | None = None,
+ **kwargs,
+ ):
+ super().__init__(config)
+
+ self.structure_attention_cell = SLANeXtAttentionGRUCell(
+ config.post_conv_out_channels, config.hidden_size, config.out_channels
+ )
+ self.structure_generator = SLANeXtMLP(config.hidden_size, config.out_channels)
+
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @filter_output_hidden_states
+ def forward(
+ self,
+ hidden_states: torch.FloatTensor,
+ targets: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ):
+ features = torch.zeros(
+ (hidden_states.shape[0], self.config.hidden_size), dtype=torch.float32, device=hidden_states.device
+ )
+ predicted_chars = torch.zeros(size=[hidden_states.shape[0]], dtype=torch.long, device=hidden_states.device)
+
+ structure_preds_list = []
+ structure_ids_list = []
+ for _ in range(self.config.max_text_length + 1):
+ embedding_feature = F.one_hot(predicted_chars, self.config.out_channels).float()
+ features, _ = self.structure_attention_cell(features, hidden_states.float(), embedding_feature)
+ structure_step = self.structure_generator(features)
+ predicted_chars = structure_step.argmax(dim=1)
+
+ structure_preds_list.append(structure_step)
+ structure_ids_list.append(predicted_chars)
+ if torch.stack(structure_ids_list, dim=1).eq(self.config.out_channels - 1).any(-1).all():
+ break
+ structure_preds = F.softmax(torch.stack(structure_preds_list, dim=1), dim=-1, dtype=torch.float32).to(
+ hidden_states.dtype
+ )
+
+ return BaseModelOutput(last_hidden_state=structure_preds, hidden_states=structure_preds_list)
+
+
+@auto_docstring
+@dataclass
+class SLANeXtForTableRecognitionOutput(BaseModelOutput):
+ r"""
+ head_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Hidden-states of the SLANeXtSLAHead at each prediction step, varies up to max `self.config.max_text_length` states (depending on early exits).
+ head_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Attentions of the SLANeXtSLAHead at each prediction step, varies up to max `self.config.max_text_length` attentions (depending on early exits).
+ """
+
+ head_hidden_states: torch.FloatTensor | None = None
+ head_attentions: torch.FloatTensor | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ SLANeXt Table Recognition model for table recognition tasks. Wraps the core SLANeXtPreTrainedModel
+ and returns outputs compatible with the Transformers table recognition API.
+ """
+)
+class SLANeXtForTableRecognition(SLANeXtPreTrainedModel):
+ def __init__(self, config: SLANeXtConfig):
+ super().__init__(config)
+ self.backbone = SLANeXtBackbone(config=config)
+ self.head = SLANeXtSLAHead(config=config)
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self, pixel_values: torch.FloatTensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple[torch.FloatTensor] | SLANeXtForTableRecognitionOutput:
+ backbone_outputs = self.backbone(pixel_values, **kwargs)
+ head_outputs = self.head(backbone_outputs.last_hidden_state, **kwargs)
+ return SLANeXtForTableRecognitionOutput(
+ last_hidden_state=head_outputs.last_hidden_state,
+ hidden_states=backbone_outputs.hidden_states,
+ attentions=backbone_outputs.attentions,
+ head_hidden_states=head_outputs.hidden_states,
+ head_attentions=head_outputs.attentions,
+ )
+
+
+@auto_docstring
+@requires(backends=("torch",))
+class SLANeXtImageProcessor(TorchvisionBackend):
+ resample = 2 # PILImageResampling.BILINEAR
+ image_mean = IMAGENET_DEFAULT_MEAN
+ image_std = IMAGENET_DEFAULT_STD
+ size = {"height": 512, "width": 512}
+ pad_size = {"height": 512, "width": 512}
+ do_convert_rgb = True
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ do_pad = True
+
+ def _resize(
+ self,
+ image: "torch.Tensor",
+ size: SizeDict,
+ ) -> "torch.Tensor":
+ batch_size, channels, height, width = image.shape
+ image = image.view(batch_size * channels, height, width)
+
+ device = image.device
+
+ scale = max(size.height, size.width) / max(height, width)
+ target_height = round(height * scale)
+ target_width = round(width * scale)
+
+ target_col = torch.arange(target_width, dtype=torch.float32, device=device)
+ src_col = (target_col + 0.5) * (float(width) / float(target_width)) - 0.5
+ src_col_floor = src_col.floor().to(torch.int32)
+ src_col_frac = src_col - src_col_floor.float()
+ # boundary handling
+ src_col_frac = torch.where(src_col_floor < 0, torch.zeros_like(src_col_frac), src_col_frac)
+ src_col_floor = torch.where(src_col_floor < 0, torch.zeros_like(src_col_floor), src_col_floor)
+ src_col_frac = torch.where(src_col_floor >= width - 1, torch.ones_like(src_col_frac), src_col_frac)
+ src_col_floor = torch.where(
+ src_col_floor >= width - 1, torch.full_like(src_col_floor, width - 2), src_col_floor
+ )
+ # fixed-point weights
+ weight_right = (src_col_frac * 2048 + 0.5).floor().to(torch.int32) # round-to-nearest
+ weight_left = 2048 - weight_right # (target_w,)
+ # --- row coordinate tables ---
+ target_row = torch.arange(target_height, dtype=torch.float32, device=device)
+ src_row = (target_row + 0.5) * (float(height) / float(target_height)) - 0.5
+ src_row_floor = src_row.floor().to(torch.int32)
+ src_row_frac = src_row - src_row_floor.float()
+ src_row_frac = torch.where(src_row_floor < 0, torch.zeros_like(src_row_frac), src_row_frac)
+ src_row_floor = torch.where(src_row_floor < 0, torch.zeros_like(src_row_floor), src_row_floor)
+ src_row_frac = torch.where(src_row_floor >= height - 1, torch.ones_like(src_row_frac), src_row_frac)
+ src_row_floor = torch.where(
+ src_row_floor >= height - 1, torch.full_like(src_row_floor, height - 2), src_row_floor
+ )
+ weight_bottom = (src_row_frac * 2048 + 0.5).floor().to(torch.int32)
+ weight_top = 2048 - weight_bottom # (target_h,)
+
+ image_uint8 = image.clamp(0, 255).to(torch.uint8) # (C, H, W)
+ image_int32 = image_uint8.to(torch.int32) # (C, H, W)
+ col_left = src_col_floor.long() # (target_w,)
+ col_right = (src_col_floor + 1).long() # (target_w,) safe: src_col_floor <= width-2
+ row_top = src_row_floor.long() # (target_h,)
+ row_bottom = (src_row_floor + 1).long() # (target_h,)
+ # gather 4 neighbours: (C, target_h, target_w)
+ pixel_top_left = image_int32[:, row_top[:, None], col_left[None, :]]
+ pixel_top_right = image_int32[:, row_top[:, None], col_right[None, :]]
+ pixel_bottom_left = image_int32[:, row_bottom[:, None], col_left[None, :]]
+ pixel_bottom_right = image_int32[:, row_bottom[:, None], col_right[None, :]]
+ # fixed-point bilinear: weights broadcast over (C, target_h, target_w)
+ weight_bottom_3d = weight_bottom.view(1, target_height, 1)
+ weight_top_3d = weight_top.view(1, target_height, 1)
+ weight_right_3d = weight_right.view(1, 1, target_width)
+ weight_left_3d = weight_left.view(1, 1, target_width)
+ interp = weight_top_3d * (
+ weight_left_3d * pixel_top_left + weight_right_3d * pixel_top_right
+ ) + weight_bottom_3d * (weight_left_3d * pixel_bottom_left + weight_right_3d * pixel_bottom_right)
+ interp = (interp + (1 << 21)) >> 22
+ result = interp.clamp(0, 255).to(torch.uint8) # (B*C, target_h, target_w)
+
+ return result.view(batch_size, channels, target_height, target_width).to(dtype=image.dtype)
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "tvF.InterpolationMode | int | None",
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_pad: bool | None,
+ pad_size: SizeDict | None,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ if resample is not None and not is_torchdynamo_compiling():
+ logger.warning_once("Resampling is not supported in SLANeXt")
+
+ # Group images by size for batched resizing
+ grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+ resized_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_resize:
+ stacked_images = self._resize(image=stacked_images, size=size)
+ resized_images_grouped[shape] = stacked_images
+ resized_images = reorder_images(resized_images_grouped, grouped_images_index)
+
+ # Group images by size for further processing
+ # Needed in case do_resize is False, or resize returns images with different sizes
+ grouped_images, grouped_images_index = group_images_by_shape(resized_images, disable_grouping=disable_grouping)
+ processed_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_center_crop:
+ stacked_images = self.center_crop(stacked_images, crop_size)
+ # Fused rescale and normalize
+ stacked_images = self.rescale_and_normalize(
+ stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ processed_images_grouped[shape] = stacked_images
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index)
+
+ if do_pad:
+ processed_images = self.pad(processed_images, pad_size=pad_size, disable_grouping=disable_grouping)
+
+ return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+ def __init__(self, **kwargs: Unpack[ImagesKwargs]):
+ super().__init__(**kwargs)
+ self.init_decoder()
+
+ def init_decoder(self):
+ """
+ Initialize the decoder vocabulary for table structure recognition.
+
+ Builds a character dictionary mapping HTML table structure tokens (e.g., `<thead>`, `<tr>`, `<td>`, colspan/
+ rowspan attributes) to integer indices. The dictionary includes special `"sos"` (start-of-sequence) and
+ `"eos"` (end-of-sequence) tokens. Merged `<td></td>` tokens are used in place of standalone `<td>` tokens
+ when applicable.
+ """
+ dict_character = [
+ "<thead>",
+ "</thead>",
+ "<tbody>",
+ "</tbody>",
+ "<tr>",
+ "</tr>",
+ "<td>",
+ "<td",
+ ">",
+ "</td>",
+ ]
+ dict_character += [f' colspan="{i + 2}"' for i in range(19)]
+ dict_character += [f' rowspan="{i + 2}"' for i in range(19)]
+
+ if "<td></td>" not in dict_character:
+ dict_character.append("<td></td>")
+ if "<td>" in dict_character:
+ dict_character.remove("<td>")
+
+ dict_character = ["sos"] + dict_character + ["eos"]
+ self.dict = {char: i for i, char in enumerate(dict_character)}
+ self.character = dict_character
+ self.td_token = ["<td>", "<td", "<td></td>"]
+ self.bos_id = self.dict["sos"]
+ self.eos_id = self.dict["eos"]
+
+ def post_process_table_recognition(self, outputs):
+ """
+ Post-process the raw model outputs to decode the predicted table structure into an HTML token sequence.
+
+ Converts the model's predicted probability distributions over the structure vocabulary into a sequence of
+ HTML tokens representing the table structure. The decoded tokens are wrapped with `<html>`, `<body>`, and
+ `<table>` tags to form a complete HTML table structure.
+
+ Args:
+ outputs ([`SLANeXtForTableRecognitionOutput`]):
+ Raw outputs from the SLANeXt model. The `last_hidden_state` field contains the predicted probability
+ distributions over the structure vocabulary at each decoding step, with shape
+ `(batch_size, max_text_length, num_classes)`.
+
+ Returns:
+ `dict`: A dictionary containing:
+ - **structure** (`list[str]`): The predicted HTML table structure as a list of tokens, wrapped with
+ `<html>`, `<body>`, and `<table>` tags.
+ - **structure_score** (`float`): The mean confidence score across all predicted tokens.
+ """
+ self.pred = outputs.last_hidden_state
+ structure_probs = self.pred[0:1]
+ ignored_tokens = [int(self.bos_id), int(self.eos_id)]
+ end_idx = int(self.eos_id)
+
+ structure_idx = structure_probs.argmax(dim=2)
+ structure_probs = structure_probs.max(dim=2).values
+
+ structure_str_list = []
+ batch_size = structure_idx.shape[0]
+ for batch_index in range(batch_size):
+ structure_list = []
+ score_list = []
+ for position in range(structure_idx.shape[1]):
+ char_idx = int(structure_idx[batch_index, position])
+ if position > 0 and char_idx == end_idx:
+ break
+ if char_idx in ignored_tokens:
+ continue
+ text = self.character[char_idx]
+ structure_list.append(text)
+ score_list.append(structure_probs[batch_index, position])
+ structure_str_list.append(structure_list)
+ structure_score = torch.stack(score_list).mean().item()
+
+ structure = ["<html>", "<body>", "<table>"] + structure_str_list[0] + ["</table>", "</body>", "</html>"]
+ return {"structure": structure, "structure_score": structure_score}
+
+
+__all__ = [
+ "SLANeXtImageProcessor",
+ "SLANeXtConfig",
+ "SLANeXtSLAHead",
+ "SLANeXtBackbone",
+ "SLANeXtForTableRecognition",
+ "SLANeXtPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/smollm3/__init__.py b/lib/python3.11/site-packages/transformers/models/smollm3/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..188d99ef78669b038c92223edb6b0caa4d2bb6be
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smollm3/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2025 The HuggingFace Inc. 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_smollm3 import *
+ from .modeling_smollm3 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..872612288c31e1eead572c9202e1e60ffa142505
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/configuration_smollm3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/configuration_smollm3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..72b6841ef46f34aca84b13ea64ab7a9267341dac
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/configuration_smollm3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/modeling_smollm3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/modeling_smollm3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..642837982e7c6a8c77b317c3458341e010426379
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/modeling_smollm3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/modular_smollm3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/modular_smollm3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..28e86c2e6ed03b4663c458a38b804c1415bd49e8
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smollm3/__pycache__/modular_smollm3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smollm3/configuration_smollm3.py b/lib/python3.11/site-packages/transformers/models/smollm3/configuration_smollm3.py
new file mode 100644
index 0000000000000000000000000000000000000000..f48c979a1dd3186cb76efc8c81c46222aa71c820
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smollm3/configuration_smollm3.py
@@ -0,0 +1,118 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/smollm3/modular_smollm3.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_smollm3.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 The HuggingFace Inc. 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...modeling_rope_utils import RopeParameters
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="HuggingFaceTB/SmolLM3-3B")
+@strict
+class SmolLM3Config(PreTrainedConfig):
+ r"""
+ no_rope_layers (`List[int]`, *optional*):
+ List with at least the same length as the number of layers in the model.
+ A `1` at an index position indicates that the corresponding layer will use RoPE,
+ while a `0` indicates that it's a NoPE layer.
+ no_rope_layer_interval (`int`, *optional*, defaults to 4):
+ If `no_rope_layers` is `None`, it will be created using a NoPE layer every
+ `no_rope_layer_interval` layers.
+
+ ```python
+ >>> from transformers import SmolLM3Model, SmolLM3Config
+
+ >>> # Initializing a SmolLM3 style configuration
+ >>> configuration = SmolLM3Config()
+
+ >>> # Initializing a model from the SmolLM3 style configuration
+ >>> model = SmolLM3Model(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "smollm3"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ default_theta = 2000000.0
+
+ base_model_tp_plan = {
+ "layers.*.self_attn.q_proj": "colwise",
+ "layers.*.self_attn.k_proj": "colwise",
+ "layers.*.self_attn.v_proj": "colwise",
+ "layers.*.self_attn.o_proj": "rowwise",
+ "layers.*.mlp.gate_proj": "colwise",
+ "layers.*.mlp.up_proj": "colwise",
+ "layers.*.mlp.down_proj": "rowwise",
+ }
+ base_model_pp_plan = {
+ "embed_tokens": (["input_ids"], ["inputs_embeds"]),
+ "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
+ "norm": (["hidden_states"], ["hidden_states"]),
+ }
+
+ vocab_size: int = 128256
+ hidden_size: int = 2048
+ intermediate_size: int = 11008
+ num_hidden_layers: int = 36
+ num_attention_heads: int = 16
+ num_key_value_heads: int | None = 4
+ hidden_act: str = "silu"
+ max_position_embeddings: int = 32768
+ initializer_range: float = 0.02
+ rms_norm_eps: float = 1e-6
+ use_cache: bool = True
+ pad_token_id: int | None = 128004
+ bos_token_id: int | None = 128000
+ eos_token_id: int | list[int] | None = 128001
+ rope_parameters: RopeParameters | dict | None = None
+ use_sliding_window: bool = False
+ sliding_window: int | None = None
+ no_rope_layers: list[int] | None = None
+ no_rope_layer_interval: int = 4
+ layer_types: list[str] | None = None
+ attention_bias: bool = False
+ attention_dropout: float | int = 0.0
+ mlp_bias: bool = False
+ tie_word_embeddings: bool = True
+
+ def __post_init__(self, **kwargs):
+ if self.num_key_value_heads is None:
+ self.num_key_value_heads = self.num_attention_heads
+
+ if self.no_rope_layers is None:
+ self.no_rope_layers = [
+ int((layer_idx + 1) % self.no_rope_layer_interval != 0) for layer_idx in range(self.num_hidden_layers)
+ ]
+
+ if self.layer_types is None:
+ self.layer_types = []
+ for layer_idx in range(self.num_hidden_layers):
+ has_rope = self.no_rope_layers[layer_idx]
+ if self.use_sliding_window and self.sliding_window is not None and not has_rope:
+ self.layer_types.append("sliding_attention")
+ else:
+ self.layer_types.append("full_attention")
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["SmolLM3Config"]
diff --git a/lib/python3.11/site-packages/transformers/models/smollm3/modeling_smollm3.py b/lib/python3.11/site-packages/transformers/models/smollm3/modeling_smollm3.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d911e414b0f3176aa923a3247ea681216f0a11f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smollm3/modeling_smollm3.py
@@ -0,0 +1,538 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/smollm3/modular_smollm3.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_smollm3.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 The HuggingFace Inc. 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 collections.abc import Callable
+from typing import Optional
+
+import torch
+from torch import nn
+
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache
+from ...generation import GenerationMixin
+from ...integrations import use_kernel_forward_from_hub, use_kernel_func_from_hub, use_kernelized_func
+from ...masking_utils import create_causal_mask, create_sliding_window_causal_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import (
+ GenericForQuestionAnswering,
+ GenericForSequenceClassification,
+ GenericForTokenClassification,
+ GradientCheckpointingLayer,
+)
+from ...modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
+from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ...utils.generic import maybe_autocast, merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_smollm3 import SmolLM3Config
+
+
+class SmolLM3RotaryEmbedding(nn.Module):
+ inv_freq: torch.Tensor # fix linting for `register_buffer`
+
+ def __init__(self, config: SmolLM3Config, device=None):
+ super().__init__()
+ self.max_seq_len_cached = config.max_position_embeddings
+ self.original_max_seq_len = config.max_position_embeddings
+
+ self.config = config
+
+ self.rope_type = self.config.rope_parameters["rope_type"]
+ rope_init_fn: Callable = self.compute_default_rope_parameters
+ if self.rope_type != "default":
+ rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
+ inv_freq, self.attention_scaling = rope_init_fn(self.config, device)
+
+ self.register_buffer("inv_freq", inv_freq, persistent=False)
+ self.register_buffer("original_inv_freq", inv_freq.clone(), persistent=False)
+
+ @staticmethod
+ def compute_default_rope_parameters(
+ config: SmolLM3Config | None = None,
+ device: Optional["torch.device"] = None,
+ seq_len: int | None = None,
+ ) -> tuple["torch.Tensor", float]:
+ """
+ Computes the inverse frequencies according to the original RoPE implementation
+ Args:
+ config ([`~transformers.PreTrainedConfig`]):
+ The model configuration.
+ device (`torch.device`):
+ The device to use for initialization of the inverse frequencies.
+ seq_len (`int`, *optional*):
+ The current sequence length. Unused for this type of RoPE.
+ Returns:
+ Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
+ post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
+ """
+ base = config.rope_parameters["rope_theta"]
+ dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
+
+ attention_factor = 1.0 # Unused in this type of RoPE
+
+ # Compute the inverse frequencies
+ inv_freq = 1.0 / (
+ base ** (torch.arange(0, dim, 2, dtype=torch.int64).to(device=device, dtype=torch.float) / dim)
+ )
+ return inv_freq, attention_factor
+
+ @torch.no_grad()
+ @dynamic_rope_update # power user: used with advanced RoPE types (e.g. dynamic rope)
+ def forward(self, x, position_ids):
+ inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)
+ position_ids_expanded = position_ids[:, None, :].float()
+
+ device_type = x.device.type if isinstance(x.device.type, str) and x.device.type != "mps" else "cpu"
+ with maybe_autocast(device_type=device_type, enabled=False): # Force float32
+ freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2)
+ emb = torch.cat((freqs, freqs), dim=-1)
+ cos = emb.cos() * self.attention_scaling
+ sin = emb.sin() * self.attention_scaling
+
+ return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+def rotate_half(x):
+ """Rotates half the hidden dims of the input."""
+ x1 = x[..., : x.shape[-1] // 2]
+ x2 = x[..., x.shape[-1] // 2 :]
+ return torch.cat((-x2, x1), dim=-1)
+
+
+@use_kernel_func_from_hub("rotary_pos_emb")
+def apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1):
+ """Applies Rotary Position Embedding to the query and key tensors.
+
+ Args:
+ q (`torch.Tensor`): The query tensor.
+ k (`torch.Tensor`): The key tensor.
+ cos (`torch.Tensor`): The cosine part of the rotary embedding.
+ sin (`torch.Tensor`): The sine part of the rotary embedding.
+ unsqueeze_dim (`int`, *optional*, defaults to 1):
+ The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+ sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+ that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+ k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+ cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+ the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+ Returns:
+ `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+ """
+ cos = cos.unsqueeze(unsqueeze_dim)
+ sin = sin.unsqueeze(unsqueeze_dim)
+ q_embed = (q * cos) + (rotate_half(q) * sin)
+ k_embed = (k * cos) + (rotate_half(k) * sin)
+ return q_embed, k_embed
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+ """
+ This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+ num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+ """
+ batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+ if n_rep == 1:
+ return hidden_states
+ hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+ return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float,
+ dropout: float = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ key_states = repeat_kv(key, module.num_key_value_groups)
+ value_states = repeat_kv(value, module.num_key_value_groups)
+
+ attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value_states)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+@use_kernelized_func(apply_rotary_pos_emb)
+class SmolLM3Attention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config: SmolLM3Config, layer_idx: int):
+ super().__init__()
+ self.config = config
+ self.layer_idx = layer_idx
+ self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+ self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
+ self.scaling = self.head_dim**-0.5
+ self.attention_dropout = config.attention_dropout
+ self.is_causal = True
+
+ self.q_proj = nn.Linear(
+ config.hidden_size, config.num_attention_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.k_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.v_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.o_proj = nn.Linear(
+ config.num_attention_heads * self.head_dim, config.hidden_size, bias=config.attention_bias
+ )
+
+ self.use_rope = config.no_rope_layers[layer_idx]
+ self.sliding_window = (
+ config.sliding_window
+ if config.use_sliding_window and config.layer_types[layer_idx] == "sliding_attention"
+ else None
+ )
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ attention_mask: torch.Tensor | None,
+ past_key_values: Cache | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ if self.use_rope:
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ if past_key_values is not None:
+ key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ scaling=self.scaling,
+ sliding_window=self.sliding_window,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+@use_kernel_forward_from_hub("RMSNorm")
+class SmolLM3RMSNorm(nn.Module):
+ def __init__(self, hidden_size, eps: float = 1e-6) -> None:
+ """
+ SmolLM3RMSNorm is equivalent to T5LayerNorm
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ input_dtype = hidden_states.dtype
+ hidden_states = hidden_states.to(torch.float32)
+ variance = hidden_states.pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+ return self.weight * hidden_states.to(input_dtype)
+
+ def extra_repr(self):
+ return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"
+
+
+class SmolLM3MLP(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.hidden_size = config.hidden_size
+ self.intermediate_size = config.intermediate_size
+ self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=config.mlp_bias)
+ self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=config.mlp_bias)
+ self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=config.mlp_bias)
+ self.act_fn = ACT2FN[config.hidden_act]
+
+ def forward(self, x):
+ down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+ return down_proj
+
+
+class SmolLM3DecoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: SmolLM3Config, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+
+ self.self_attn = SmolLM3Attention(config=config, layer_idx=layer_idx)
+
+ self.mlp = SmolLM3MLP(config)
+ self.input_layernorm = SmolLM3RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_attention_layernorm = SmolLM3RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = False,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ residual = hidden_states
+ hidden_states = self.input_layernorm(hidden_states)
+ # Self Attention
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ position_embeddings=position_embeddings,
+ **kwargs,
+ )
+ hidden_states = residual + hidden_states
+
+ # Fully Connected
+ residual = hidden_states
+ hidden_states = self.post_attention_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = residual + hidden_states
+ return hidden_states
+
+
+@auto_docstring
+class SmolLM3PreTrainedModel(PreTrainedModel):
+ config: SmolLM3Config
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["SmolLM3DecoderLayer"]
+ _skip_keys_device_placement = ["past_key_values"]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+
+ _can_compile_fullgraph = True
+ _supports_attention_backend = True
+ _can_record_outputs = {
+ "hidden_states": SmolLM3DecoderLayer,
+ "attentions": SmolLM3Attention,
+ }
+
+
+@auto_docstring
+class SmolLM3Model(SmolLM3PreTrainedModel):
+ def __init__(self, config: SmolLM3Config):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+ self.layers = nn.ModuleList(
+ [SmolLM3DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.norm = SmolLM3RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.rotary_emb = SmolLM3RotaryEmbedding(config=config)
+ self.gradient_checkpointing = False
+ self.has_sliding_layers = "sliding_attention" in self.config.layer_types
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPast:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if use_cache and past_key_values is None:
+ past_key_values = DynamicCache(config=self.config)
+
+ if position_ids is None:
+ past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+ position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens
+ position_ids = position_ids.unsqueeze(0)
+
+ # It may already have been prepared by e.g. `generate`
+ if not isinstance(causal_mask_mapping := attention_mask, dict):
+ # Prepare mask arguments
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ "past_key_values": past_key_values,
+ "position_ids": position_ids,
+ }
+ # Create the masks
+ causal_mask_mapping = {
+ "full_attention": create_causal_mask(**mask_kwargs),
+ }
+ # The sliding window alternating layers are not always activated depending on the config
+ if self.has_sliding_layers:
+ causal_mask_mapping["sliding_attention"] = create_sliding_window_causal_mask(**mask_kwargs)
+
+ hidden_states = inputs_embeds
+ position_embeddings = self.rotary_emb(hidden_states, position_ids)
+
+ for i, decoder_layer in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = decoder_layer(
+ hidden_states,
+ attention_mask=causal_mask_mapping[self.config.layer_types[i]],
+ position_embeddings=position_embeddings,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = self.norm(hidden_states)
+ return BaseModelOutputWithPast(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values if use_cache else None,
+ )
+
+
+@auto_docstring
+class SmolLM3ForCausalLM(SmolLM3PreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}
+ _tp_plan = {"lm_head": "colwise_gather_output"}
+ _pp_plan = {"lm_head": (["hidden_states"], ["logits"])}
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.model = SmolLM3Model(config)
+ self.vocab_size = config.vocab_size
+ self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ logits_to_keep: int | torch.Tensor = 0,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> CausalLMOutputWithPast:
+ r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, SmolLM3ForCausalLM
+
+ >>> model = SmolLM3ForCausalLM.from_pretrained("meta-smollm3/SmolLM3-2-7b-hf")
+ >>> tokenizer = AutoTokenizer.from_pretrained("meta-smollm3/SmolLM3-2-7b-hf")
+
+ >>> prompt = "Hey, are you conscious? Can you talk to me?"
+ >>> inputs = tokenizer(prompt, return_tensors="pt")
+
+ >>> # Generate
+ >>> generate_ids = model.generate(inputs.input_ids, max_length=30)
+ >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+ "Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."
+ ```"""
+ outputs: BaseModelOutputWithPast = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = outputs.last_hidden_state
+ # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+ slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+ logits = self.lm_head(hidden_states[:, slice_indices, :])
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits=logits, labels=labels, vocab_size=self.config.vocab_size, **kwargs)
+
+ return CausalLMOutputWithPast(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+class SmolLM3ForSequenceClassification(GenericForSequenceClassification, SmolLM3PreTrainedModel):
+ pass
+
+
+class SmolLM3ForTokenClassification(GenericForTokenClassification, SmolLM3PreTrainedModel):
+ pass
+
+
+class SmolLM3ForQuestionAnswering(GenericForQuestionAnswering, SmolLM3PreTrainedModel):
+ base_model_prefix = "transformer" # For BC, where `transformer` was used instead of `model`
+
+
+__all__ = [
+ "SmolLM3PreTrainedModel",
+ "SmolLM3Model",
+ "SmolLM3ForCausalLM",
+ "SmolLM3ForSequenceClassification",
+ "SmolLM3ForTokenClassification",
+ "SmolLM3ForQuestionAnswering",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/smollm3/modular_smollm3.py b/lib/python3.11/site-packages/transformers/models/smollm3/modular_smollm3.py
new file mode 100644
index 0000000000000000000000000000000000000000..f75017ad264543c11294216b774ee2faf7ab8138
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smollm3/modular_smollm3.py
@@ -0,0 +1,228 @@
+# Copyright 2025 The HuggingFace Inc. 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 collections.abc import Callable
+
+import torch
+from huggingface_hub.dataclasses import strict
+
+from ...cache_utils import Cache
+from ...configuration_utils import PreTrainedConfig
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_rope_utils import RopeParameters
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS
+from ...processing_utils import Unpack
+from ...utils import auto_docstring, logging
+from ..llama.modeling_llama import (
+ LlamaAttention,
+ LlamaDecoderLayer,
+ LlamaForCausalLM,
+ LlamaForQuestionAnswering,
+ LlamaForSequenceClassification,
+ LlamaForTokenClassification,
+ LlamaPreTrainedModel,
+ apply_rotary_pos_emb,
+ eager_attention_forward,
+)
+from ..qwen2.modeling_qwen2 import Qwen2Model, Qwen2RotaryEmbedding
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="HuggingFaceTB/SmolLM3-3B")
+@strict
+class SmolLM3Config(PreTrainedConfig):
+ r"""
+ no_rope_layers (`List[int]`, *optional*):
+ List with at least the same length as the number of layers in the model.
+ A `1` at an index position indicates that the corresponding layer will use RoPE,
+ while a `0` indicates that it's a NoPE layer.
+ no_rope_layer_interval (`int`, *optional*, defaults to 4):
+ If `no_rope_layers` is `None`, it will be created using a NoPE layer every
+ `no_rope_layer_interval` layers.
+
+ ```python
+ >>> from transformers import SmolLM3Model, SmolLM3Config
+
+ >>> # Initializing a SmolLM3 style configuration
+ >>> configuration = SmolLM3Config()
+
+ >>> # Initializing a model from the SmolLM3 style configuration
+ >>> model = SmolLM3Model(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "smollm3"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ default_theta = 2000000.0
+
+ base_model_tp_plan = {
+ "layers.*.self_attn.q_proj": "colwise",
+ "layers.*.self_attn.k_proj": "colwise",
+ "layers.*.self_attn.v_proj": "colwise",
+ "layers.*.self_attn.o_proj": "rowwise",
+ "layers.*.mlp.gate_proj": "colwise",
+ "layers.*.mlp.up_proj": "colwise",
+ "layers.*.mlp.down_proj": "rowwise",
+ }
+ base_model_pp_plan = {
+ "embed_tokens": (["input_ids"], ["inputs_embeds"]),
+ "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
+ "norm": (["hidden_states"], ["hidden_states"]),
+ }
+
+ vocab_size: int = 128256
+ hidden_size: int = 2048
+ intermediate_size: int = 11008
+ num_hidden_layers: int = 36
+ num_attention_heads: int = 16
+ num_key_value_heads: int | None = 4
+ hidden_act: str = "silu"
+ max_position_embeddings: int = 32768
+ initializer_range: float = 0.02
+ rms_norm_eps: float = 1e-6
+ use_cache: bool = True
+ pad_token_id: int | None = 128004
+ bos_token_id: int | None = 128000
+ eos_token_id: int | list[int] | None = 128001
+ rope_parameters: RopeParameters | dict | None = None
+ use_sliding_window: bool = False
+ sliding_window: int | None = None
+ no_rope_layers: list[int] | None = None
+ no_rope_layer_interval: int = 4
+ layer_types: list[str] | None = None
+ attention_bias: bool = False
+ attention_dropout: float | int = 0.0
+ mlp_bias: bool = False
+ tie_word_embeddings: bool = True
+
+ def __post_init__(self, **kwargs):
+ if self.num_key_value_heads is None:
+ self.num_key_value_heads = self.num_attention_heads
+
+ if self.no_rope_layers is None:
+ self.no_rope_layers = [
+ int((layer_idx + 1) % self.no_rope_layer_interval != 0) for layer_idx in range(self.num_hidden_layers)
+ ]
+
+ if self.layer_types is None:
+ self.layer_types = []
+ for layer_idx in range(self.num_hidden_layers):
+ has_rope = self.no_rope_layers[layer_idx]
+ if self.use_sliding_window and self.sliding_window is not None and not has_rope:
+ self.layer_types.append("sliding_attention")
+ else:
+ self.layer_types.append("full_attention")
+
+ super().__post_init__(**kwargs)
+
+
+class SmolLM3RotaryEmbedding(Qwen2RotaryEmbedding):
+ pass
+
+
+class SmolLM3Attention(LlamaAttention):
+ def __init__(self, config: SmolLM3Config, layer_idx: int):
+ super().__init__(config, layer_idx)
+
+ self.use_rope = config.no_rope_layers[layer_idx]
+ self.sliding_window = (
+ config.sliding_window
+ if config.use_sliding_window and config.layer_types[layer_idx] == "sliding_attention"
+ else None
+ )
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ attention_mask: torch.Tensor | None,
+ past_key_values: Cache | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ if self.use_rope:
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ if past_key_values is not None:
+ key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ scaling=self.scaling,
+ sliding_window=self.sliding_window,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+class SmolLM3DecoderLayer(LlamaDecoderLayer):
+ pass
+
+
+class SmolLM3PreTrainedModel(LlamaPreTrainedModel):
+ pass
+
+
+class SmolLM3Model(Qwen2Model):
+ pass
+
+
+class SmolLM3ForCausalLM(LlamaForCausalLM):
+ pass
+
+
+class SmolLM3ForSequenceClassification(LlamaForSequenceClassification):
+ pass
+
+
+class SmolLM3ForTokenClassification(LlamaForTokenClassification):
+ pass
+
+
+class SmolLM3ForQuestionAnswering(LlamaForQuestionAnswering):
+ pass
+
+
+__all__ = [
+ "SmolLM3Config",
+ "SmolLM3PreTrainedModel",
+ "SmolLM3Model",
+ "SmolLM3ForCausalLM",
+ "SmolLM3ForSequenceClassification",
+ "SmolLM3ForTokenClassification",
+ "SmolLM3ForQuestionAnswering",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/__init__.py b/lib/python3.11/site-packages/transformers/models/smolvlm/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ddab5b2b0dbd89521fcadfcd299bd835b4deb1d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smolvlm/__init__.py
@@ -0,0 +1,30 @@
+# Copyright 2025 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_smolvlm import *
+ from .image_processing_pil_smolvlm import *
+ from .image_processing_smolvlm import *
+ from .modeling_smolvlm import *
+ from .processing_smolvlm import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..41646c82cada8a0ca2bd339f1d7be3e4c0728293
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/configuration_smolvlm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/configuration_smolvlm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..75481c83748e091329cdd5aa51a893c617589b2c
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/configuration_smolvlm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/image_processing_pil_smolvlm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/image_processing_pil_smolvlm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..499aaadbf814d9b556dca2a7c800ea702e086e3d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/image_processing_pil_smolvlm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/image_processing_smolvlm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/image_processing_smolvlm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6013b5c1e1089d610801ea658b6bd72059a6b975
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/image_processing_smolvlm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/modeling_smolvlm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/modeling_smolvlm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6efbb29bebdee3f18265e211e511324a90d16373
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/modeling_smolvlm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/modular_smolvlm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/modular_smolvlm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c69ef931fe2cf580662b2a4025e5b0133a45eca5
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/modular_smolvlm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/processing_smolvlm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/processing_smolvlm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f60bef33743dcbce0d4f39d951db14fc3d68cfea
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/processing_smolvlm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/video_processing_smolvlm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/video_processing_smolvlm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9780c1e6c99241399e439e64c3a3e358e13c4251
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/smolvlm/__pycache__/video_processing_smolvlm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/configuration_smolvlm.py b/lib/python3.11/site-packages/transformers/models/smolvlm/configuration_smolvlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..067db68e129eb35ecf742eaabe3b0079704c7508
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smolvlm/configuration_smolvlm.py
@@ -0,0 +1,118 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/smolvlm/modular_smolvlm.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_smolvlm.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 the HuggingFace Inc. team. All rights reserved.
+# Written by Orr Zohar
+#
+# 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring, logging
+from ..auto import CONFIG_MAPPING, AutoConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="HuggingFaceTB/SmolVLM2-2.2B-Instruct")
+@strict
+class SmolVLMVisionConfig(PreTrainedConfig):
+ r"""
+ Example:
+
+ ```python
+ >>> from transformers.models.smolvlm.modeling_smolvlm import SmolVLMVisionTransformer
+ >>> from transformers.models.smolvlm.configuration_smolvlm import SmolVLMVisionConfig
+
+ >>> # Initializing a SmolVLMVisionConfig with google/siglip-so400m-patch14-384 style configuration
+ >>> configuration = SmolVLMVisionConfig()
+
+ >>> # Initializing a SmolVLMVisionTransformer (with random weights) from the google/siglip-so400m-patch14-384 style configuration
+ >>> model = SmolVLMVisionTransformer(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "smolvlm_vision"
+ base_config_key = "vision_config"
+
+ hidden_size: int = 1152
+ intermediate_size: int = 3072
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 16
+ num_channels: int = 3
+ image_size: int | list[int] | tuple[int, int] = 224
+ patch_size: int | list[int] | tuple[int, int] = 32
+ hidden_act: str = "gelu_pytorch_tanh"
+ layer_norm_eps: float = 1e-6
+ attention_dropout: float | int = 0.0
+ initializer_range: float = 0.02
+
+
+@auto_docstring(checkpoint="HuggingFaceTB/SmolVLM2-2.2B-Instruct")
+@strict
+class SmolVLMConfig(PreTrainedConfig):
+ r"""
+ scale_factor (`int`, *optional*, defaults to 2):
+ The scale factor for the image encoder.
+
+ Example:
+ ```python
+ >>> from transformers import SmolVLMModel, SmolVLMConfig
+ >>> # Initializing configuration
+ >>> configuration = SmolVLMConfig()
+ >>> # Initializing a model from the configuration
+ >>> model = SmolVLMModel(configuration)
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "smolvlm"
+ sub_configs = {"text_config": AutoConfig, "vision_config": SmolVLMVisionConfig}
+
+ use_cache: bool = True
+ image_token_id: int = 128257
+ tie_word_embeddings: bool = False
+ vision_config: dict | PreTrainedConfig | None = None
+ text_config: dict | PreTrainedConfig | None = None
+ scale_factor: int = 2
+ pad_token_id: int | None = 128_002
+
+ def __post_init__(self, **kwargs):
+ if self.vision_config is None:
+ self.vision_config = SmolVLMVisionConfig()
+ logger.info("vision_config is None, using default vision config")
+ elif isinstance(self.vision_config, dict):
+ self.vision_config = SmolVLMVisionConfig(**self.vision_config)
+
+ if isinstance(self.text_config, dict):
+ self.text_config["model_type"] = self.text_config.get("model_type", "llama")
+ self.text_config = CONFIG_MAPPING[self.text_config["model_type"]](**self.text_config)
+ elif self.text_config is None:
+ logger.info("text_config is None, using default Llama text config")
+ self.text_config = CONFIG_MAPPING["llama"](
+ rms_norm_eps=1e-5,
+ pad_token_id=self.pad_token_id,
+ )
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["SmolVLMVisionConfig", "SmolVLMConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/image_processing_pil_smolvlm.py b/lib/python3.11/site-packages/transformers/models/smolvlm/image_processing_pil_smolvlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d53ed09c11fd66a4cd1de2d4bd62d7e5ce62f7d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smolvlm/image_processing_pil_smolvlm.py
@@ -0,0 +1,481 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/smolvlm/modular_smolvlm.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_smolvlm.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 the HuggingFace Inc. team. All rights reserved.
+# Written by Orr Zohar
+#
+# 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 math
+
+import numpy as np
+
+from ...image_processing_backends import PilBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import PaddingMode, pad
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+ make_nested_list_of_images,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+class SmolVLMImageProcessorKwargs(ImagesKwargs, total=False):
+ """
+ do_image_splitting (`bool`, *optional*, defaults to `True`):
+ Whether to split the image into sub-images concatenated with the original image. They are split into patches
+ such that each patch has a size of `max_image_size["height"]` x `max_image_size["width"]`.
+ max_image_size (`Dict`, *optional*, defaults to `{"longest_edge": 364}`):
+ Maximum resolution of the patches of images accepted by the model. This is a dictionary containing the key "longest_edge".
+ return_row_col_info (`bool`, *optional*, defaults to `False`):
+ Whether to return the row and column information of the images.
+ """
+
+ do_image_splitting: bool
+ max_image_size: dict[str, int]
+ return_row_col_info: bool
+
+
+def _make_pixel_mask(image: np.ndarray, output_size: tuple[int, int]) -> np.ndarray:
+ """Make pixel mask: 1=valid, 0=padding. Images are CHW."""
+ h, w = image.shape[-2:]
+ mask = np.zeros(output_size, dtype=np.int64)
+ mask[:h, :w] = 1
+ return mask
+
+
+# Adapted from transformers.models.smolvlm.image_processing_smolvlm.MAX_IMAGE_SIZE
+MAX_IMAGE_SIZE = 4096 # 4k resolution as absolute maximum
+
+
+# Adapted from transformers.models.smolvlm.image_processing_smolvlm._resize_output_size_rescale_to_max_len
+def _resize_output_size_rescale_to_max_len(
+ height: int, width: int, min_len: int | None = 1, max_len: int | None = None
+) -> tuple[int, int]:
+ """
+ Get the output size of the image after resizing given a dictionary specifying the max and min sizes.
+ Args:
+ height (`int`):
+ Height of the input image.
+ width (`int`):
+ Width of the input image.
+ min_len (`int`, *optional*, defaults to 1):
+ Minimum size of the output image.
+ max_len (`int`, *optional*, defaults to the maximum size of the image):
+ Maximum size of the output image.
+ Returns:
+ The output size of the image after resizing.
+ """
+ max_len = max(height, width) if max_len is None else max_len
+ aspect_ratio = width / height
+
+ if width >= height:
+ width = max_len
+ height = int(width / aspect_ratio)
+ if height % 2 != 0:
+ height += 1
+ elif height > width:
+ height = max_len
+ width = int(height * aspect_ratio)
+ if width % 2 != 0:
+ width += 1
+
+ # Avoid resizing to a size smaller than min_len
+ height = max(height, min_len)
+ width = max(width, min_len)
+ return height, width
+
+
+# Adapted from transformers.models.smolvlm.image_processing_smolvlm._resize_output_size_scale_below_upper_bound
+def _resize_output_size_scale_below_upper_bound(
+ height: int, width: int, max_len: dict[str, int] | None = None
+) -> tuple[int, int]:
+ """
+ Get the output size of the image after resizing given a dictionary specifying the max and min sizes.
+ Args:
+ height (`int`):
+ Height of the input image.
+ width (`int`):
+ Width of the input image.
+ max_len (`Dict[str, int]`, *optional*, defaults to the maximum size of the image):
+ Defines the maximum dimensions of the image.
+ Returns:
+ The output size of the image after resizing.
+ """
+ max_len = max(height, width) if max_len is None else max_len
+
+ aspect_ratio = width / height
+ if width >= height and width > max_len:
+ width = max_len
+ height = int(width / aspect_ratio)
+ elif height > width and height > max_len:
+ height = max_len
+ width = int(height * aspect_ratio)
+
+ # Avoid resizing to a size smaller than 1
+ height = max(height, 1)
+ width = max(width, 1)
+ return height, width
+
+
+def get_max_height_width(images_list: list[list[np.ndarray]]) -> tuple[int, int]:
+ """
+ Get the maximum height and width across all images in a batch.
+ """
+ image_sizes = []
+ for images in images_list:
+ for image in images:
+ image_sizes.append(image.shape[-2:])
+
+ max_height = max(size[0] for size in image_sizes)
+ max_width = max(size[1] for size in image_sizes)
+ return (max_height, max_width)
+
+
+def get_num_channels(images_list: list[list[np.ndarray]]) -> int:
+ """
+ Get the number of channels across all images in a batch. Handle empty sublists like in [[], [image]].
+ """
+ for images in images_list:
+ if images:
+ return images[0].shape[0]
+
+ raise ValueError("No images found in the batch.")
+
+
+def get_resize_output_image_size(
+ image: np.ndarray,
+ resolution_max_side: int,
+) -> tuple[int, int]:
+ """
+ Get the output size of the image after resizing given a dictionary specifying the max and min sizes.
+ Args:
+ image (`np.ndarray`):
+ Image to resize.
+ resolution_max_side (`int`):
+ The longest edge of the image will be resized to this value. The shortest edge will be resized to keep the
+ input aspect ratio.
+ Returns:
+ The output size of the image after resizing.
+ """
+ height, width = image.shape[-2:]
+
+ # Find the output size, when rescaling the longest edge to max_len and preserving the aspect ratio
+ height, width = _resize_output_size_rescale_to_max_len(height, width, max_len=resolution_max_side)
+ # Find the output size when scaling the image to be below the MAX_IMAGE_SIZE
+ height, width = _resize_output_size_scale_below_upper_bound(height, width, max_len=MAX_IMAGE_SIZE)
+ return height, width
+
+
+@auto_docstring
+class SmolVLMImageProcessorPil(PilBackend):
+ resample = PILImageResampling.LANCZOS
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"longest_edge": 4 * 364}
+ max_image_size = {"longest_edge": 364}
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ do_convert_rgb = True
+ do_image_splitting = True
+ do_pad = True
+ return_row_col_info = False
+ valid_kwargs = SmolVLMImageProcessorKwargs
+ model_input_names = ["pixel_values", "pixel_attention_mask"]
+
+ def __init__(self, **kwargs: Unpack[SmolVLMImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(self, images: ImageInput, **kwargs: Unpack[SmolVLMImageProcessorKwargs]) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def _prepare_images_structure(self, images: ImageInput, expected_ndims: int = 3) -> ImageInput:
+ images = self.fetch_images(images)
+ return make_nested_list_of_images(images, expected_ndims=expected_ndims)
+
+ def resize(
+ self,
+ image: np.ndarray,
+ size: SizeDict,
+ resample: PILImageResampling = PILImageResampling.LANCZOS,
+ **kwargs,
+ ) -> np.ndarray:
+ if size.longest_edge:
+ new_size = get_resize_output_image_size(image, resolution_max_side=size.longest_edge)
+ elif size.height and size.width:
+ new_size = (size.height, size.width)
+ else:
+ raise ValueError("size must be a dictionary with key 'longest_edge' or 'height' and 'width'.")
+ return super().resize(image, SizeDict(height=new_size[0], width=new_size[1]), resample=resample, **kwargs)
+
+ def split_images(
+ self,
+ image: np.ndarray,
+ max_image_size: dict[str, int],
+ resample: "PILImageResampling | None" = None,
+ ):
+ """Split an image into patches (mirrors TorchvisionBackend.split_images). Images are always CHW."""
+ num_channels, height, width = image.shape
+ max_height = max_width = max_image_size["longest_edge"]
+
+ if height > max_height or width > max_width:
+ num_splits_h = (height - max_height) // max_height + 1
+ num_splits_w = (width - max_width) // max_width + 1
+
+ frames = []
+ for r in range(num_splits_h):
+ for c in range(num_splits_w):
+ start_y = r * max_height
+ start_x = c * max_width
+ end_y = start_y + max_height
+ end_x = start_x + max_width
+ crop = image[:, start_y:end_y, start_x:end_x]
+ frames.append(crop)
+
+ global_image_height, global_image_width = max_height, max_width
+ image = self.resize(
+ image, SizeDict(height=global_image_height, width=global_image_width), resample=resample
+ )
+ frames.append(image)
+ else:
+ num_splits_h, num_splits_w = 0, 0
+ frames = [image]
+
+ return frames, num_splits_h, num_splits_w
+
+ def resize_for_vision_encoder(
+ self,
+ image: np.ndarray,
+ vision_encoder_max_size: int,
+ resample: "PILImageResampling | None" = None,
+ ):
+ """Resize images to be multiples of vision_encoder_max_size. Images are always CHW."""
+ height, width = image.shape[-2:]
+ aspect_ratio = width / height
+ if width >= height:
+ width = math.ceil(width / vision_encoder_max_size) * vision_encoder_max_size
+ height = int(width / aspect_ratio)
+ height = math.ceil(height / vision_encoder_max_size) * vision_encoder_max_size
+ elif height > width:
+ height = math.ceil(height / vision_encoder_max_size) * vision_encoder_max_size
+ width = int(height * aspect_ratio)
+ width = math.ceil(width / vision_encoder_max_size) * vision_encoder_max_size
+ new_size = SizeDict(height=height, width=width)
+ return self.resize(image, size=new_size, resample=resample)
+
+ def pad(
+ self,
+ image: np.ndarray,
+ padded_size: tuple[int, int],
+ fill: int = 0,
+ return_pixel_mask: bool = True,
+ ):
+ """Pad image to padded_size. Mirrors TorchvisionBackend.pad. Images are always CHW."""
+ original_size = image.shape[-2:]
+ padding_bottom = padded_size[0] - original_size[0]
+ padding_right = padded_size[1] - original_size[1]
+
+ if padding_bottom < 0 or padding_right < 0:
+ raise ValueError(
+ f"Padding dimensions are negative. Please make sure that the padded size is larger than the "
+ f"original size. Got padded size: {padded_size}, original size: {original_size}."
+ )
+
+ pixel_mask = _make_pixel_mask(image, output_size=padded_size) if return_pixel_mask else None
+
+ if original_size != padded_size:
+ padding = ((0, padding_bottom), (0, padding_right))
+ image = pad(
+ image,
+ padding,
+ mode=PaddingMode.CONSTANT,
+ constant_values=fill,
+ data_format="channels_first",
+ input_data_format="channels_first",
+ )
+
+ return image, pixel_mask
+
+ def _preprocess(
+ self,
+ images: list[list[np.ndarray]],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_pad: bool | None,
+ do_image_splitting: bool | None,
+ max_image_size: dict[str, int] | None,
+ return_row_col_info: bool | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ """Process a batch of images. Mirrors TorchvisionBackend._preprocess with per-image loops instead of batching."""
+ # Resize
+ if do_resize:
+ images = [
+ [self.resize(image=img, size=size, resample=resample) for img in batch_images]
+ for batch_images in images
+ ]
+
+ # Image splitting
+ if do_image_splitting:
+ images = [
+ [
+ self.resize_for_vision_encoder(image, max_image_size["longest_edge"], resample=resample)
+ for image in batch_images
+ ]
+ for batch_images in images
+ ]
+ images_split_arrays = []
+ images_rows = []
+ images_cols = []
+ for batch_images in images:
+ split_image_arrays = []
+ image_rows = []
+ image_cols = []
+ for image in batch_images:
+ split_image_array, rows, cols = self.split_images(
+ image, max_image_size=max_image_size, resample=resample
+ )
+ split_image_arrays.extend(split_image_array)
+ image_rows.append(rows)
+ image_cols.append(cols)
+ images_split_arrays.append(split_image_arrays)
+ images_rows.append(image_rows)
+ images_cols.append(image_cols)
+ images = images_split_arrays
+ rows = images_rows
+ cols = images_cols
+ else:
+ images = [
+ [
+ self.resize(
+ image=image,
+ size=SizeDict(height=max_image_size["longest_edge"], width=max_image_size["longest_edge"]),
+ resample=resample,
+ )
+ for image in batch_images
+ ]
+ for batch_images in images
+ ]
+ rows = [[0] * len(batch_images) for batch_images in images]
+ cols = [[0] * len(batch_images) for batch_images in images]
+
+ # Rescale and normalize
+ if do_rescale:
+ images = [[self.rescale(img, rescale_factor) for img in batch_images] for batch_images in images]
+ if do_normalize:
+ images = [[self.normalize(img, image_mean, image_std) for img in batch_images] for batch_images in images]
+
+ # Pad
+ if do_pad:
+ max_num_images = max(len(images_) for images_ in images)
+ max_height, max_width = get_max_height_width(images)
+ num_channels = get_num_channels(images)
+
+ padded_images_list = [
+ [np.zeros((num_channels, max_height, max_width), dtype=np.float32) for _ in range(max_num_images)]
+ for _ in range(len(images))
+ ]
+ pixel_attention_masks = [
+ [np.zeros((max_height, max_width), dtype=np.int64) for _ in range(max_num_images)]
+ for _ in range(len(images))
+ ]
+
+ for i, batch_images in enumerate(images):
+ for j, image in enumerate(batch_images):
+ padded_images_list[i][j], pixel_attention_masks[i][j] = self.pad(image, (max_height, max_width))
+ images = padded_images_list
+
+ if do_pad:
+ data = {
+ "pixel_values": np.array(images),
+ "pixel_attention_mask": np.array(pixel_attention_masks),
+ }
+ elif return_tensors == "pt":
+ data = {"pixel_values": np.asarray(images)}
+ else:
+ data = {"pixel_values": images}
+
+ encoding = BatchFeature(data=data, tensor_type=return_tensors)
+ if return_row_col_info:
+ encoding["rows"] = rows
+ encoding["cols"] = cols
+
+ return encoding
+
+ def to_dict(self):
+ encoder_dict = super().to_dict()
+ encoder_dict.pop("_valid_processor_keys", None)
+ encoder_dict.pop("return_row_col_info", None)
+ return encoder_dict
+
+ def get_number_of_image_patches(self, height: int, width: int, images_kwargs: dict):
+ """
+ A utility that returns number of image patches for a given image size.
+
+ Args:
+ height (`int`):
+ Height of the input image.
+ width (`int`):
+ Width of the input image.
+ images_kwargs (`dict`)
+ Any kwargs to override defaults of the image processor.
+ Returns:
+ `int`: Number of patches per image.
+ """
+ do_image_splitting = images_kwargs.get("do_image_splitting", self.do_image_splitting)
+ max_image_size = images_kwargs.get("max_image_size", self.max_image_size)
+ size = images_kwargs.get("size", self.size)
+
+ num_patches = num_rows = num_cols = 0
+ if do_image_splitting:
+ height, width = _resize_output_size_rescale_to_max_len(height, width, max_len=size["longest_edge"])
+ height, width = _resize_output_size_scale_below_upper_bound(height, width, max_len=MAX_IMAGE_SIZE)
+ aspect_ratio = width / height
+
+ if width >= height:
+ resized_width = math.ceil(width / max_image_size["longest_edge"]) * max_image_size["longest_edge"]
+ resized_height = int(width / aspect_ratio)
+ resized_height = math.ceil(height / max_image_size["longest_edge"]) * max_image_size["longest_edge"]
+ elif height > width:
+ resized_height = math.ceil(height / max_image_size["longest_edge"]) * max_image_size["longest_edge"]
+ resized_width = int(height * aspect_ratio)
+ resized_width = math.ceil(width / max_image_size["longest_edge"]) * max_image_size["longest_edge"]
+
+ max_height = max_width = max_image_size["longest_edge"]
+ if resized_height > max_height or resized_width > max_width:
+ num_rows = math.ceil(resized_height / max_height)
+ num_cols = math.ceil(resized_width / max_width)
+ num_patches = num_rows * num_cols + 1
+
+ return num_patches, num_rows, num_cols
+
+
+__all__ = ["SmolVLMImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/image_processing_smolvlm.py b/lib/python3.11/site-packages/transformers/models/smolvlm/image_processing_smolvlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c22e496c6697387931240a5c6f2f1222a73cd41
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smolvlm/image_processing_smolvlm.py
@@ -0,0 +1,540 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/smolvlm/modular_smolvlm.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_smolvlm.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 the HuggingFace Inc. team. All rights reserved.
+# Written by Orr Zohar
+#
+# 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 math
+
+import numpy as np
+import torch
+from torchvision.transforms.v2 import functional as tvF
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+ make_nested_list_of_images,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+class SmolVLMImageProcessorKwargs(ImagesKwargs, total=False):
+ """
+ do_image_splitting (`bool`, *optional*, defaults to `True`):
+ Whether to split the image into sub-images concatenated with the original image. They are split into patches
+ such that each patch has a size of `max_image_size["height"]` x `max_image_size["width"]`.
+ max_image_size (`Dict`, *optional*, defaults to `{"longest_edge": 364}`):
+ Maximum resolution of the patches of images accepted by the model. This is a dictionary containing the key "longest_edge".
+ return_row_col_info (`bool`, *optional*, defaults to `False`):
+ Whether to return the row and column information of the images.
+ """
+
+ do_image_splitting: bool
+ max_image_size: dict[str, int]
+ return_row_col_info: bool
+
+
+MAX_IMAGE_SIZE = 4096 # 4k resolution as absolute maximum
+
+
+def _resize_output_size_rescale_to_max_len(
+ height: int, width: int, min_len: int | None = 1, max_len: int | None = None
+) -> tuple[int, int]:
+ """
+ Get the output size of the image after resizing given a dictionary specifying the max and min sizes.
+ Args:
+ height (`int`):
+ Height of the input image.
+ width (`int`):
+ Width of the input image.
+ min_len (`int`, *optional*, defaults to 1):
+ Minimum size of the output image.
+ max_len (`int`, *optional*, defaults to the maximum size of the image):
+ Maximum size of the output image.
+ Returns:
+ The output size of the image after resizing.
+ """
+ max_len = max(height, width) if max_len is None else max_len
+ aspect_ratio = width / height
+
+ if width >= height:
+ width = max_len
+ height = int(width / aspect_ratio)
+ if height % 2 != 0:
+ height += 1
+ elif height > width:
+ height = max_len
+ width = int(height * aspect_ratio)
+ if width % 2 != 0:
+ width += 1
+
+ # Avoid resizing to a size smaller than min_len
+ height = max(height, min_len)
+ width = max(width, min_len)
+ return height, width
+
+
+def _resize_output_size_scale_below_upper_bound(
+ height: int, width: int, max_len: dict[str, int] | None = None
+) -> tuple[int, int]:
+ """
+ Get the output size of the image after resizing given a dictionary specifying the max and min sizes.
+ Args:
+ height (`int`):
+ Height of the input image.
+ width (`int`):
+ Width of the input image.
+ max_len (`Dict[str, int]`, *optional*, defaults to the maximum size of the image):
+ Defines the maximum dimensions of the image.
+ Returns:
+ The output size of the image after resizing.
+ """
+ max_len = max(height, width) if max_len is None else max_len
+
+ aspect_ratio = width / height
+ if width >= height and width > max_len:
+ width = max_len
+ height = int(width / aspect_ratio)
+ elif height > width and height > max_len:
+ height = max_len
+ width = int(height * aspect_ratio)
+
+ # Avoid resizing to a size smaller than 1
+ height = max(height, 1)
+ width = max(width, 1)
+ return height, width
+
+
+def get_resize_output_image_size(
+ image: "torch.Tensor",
+ resolution_max_side: int,
+) -> tuple[int, int]:
+ """
+ Get the output size of the image after resizing given a dictionary specifying the max and min sizes.
+ Args:
+ image (`torch.Tensor`):
+ Image to resize.
+ resolution_max_side (`int`):
+ The longest edge of the image will be resized to this value. The shortest edge will be resized to keep the
+ input aspect ratio.
+ Returns:
+ The output size of the image after resizing.
+ """
+ height, width = image.shape[-2:]
+
+ # Find the output size, when rescaling the longest edge to max_len and preserving the aspect ratio
+ height, width = _resize_output_size_rescale_to_max_len(height, width, max_len=resolution_max_side)
+ # Find the output size when scaling the image to be below the MAX_IMAGE_SIZE
+ height, width = _resize_output_size_scale_below_upper_bound(height, width, max_len=MAX_IMAGE_SIZE)
+ return height, width
+
+
+def get_max_height_width(images_list: list[list["torch.Tensor|np.ndarray"]]) -> tuple[int, int]:
+ """
+ Get the maximum height and width across all images in a batch.
+ """
+ image_sizes = []
+ for images in images_list:
+ for image in images:
+ image_sizes.append(image.shape[-2:])
+
+ max_height = max(size[0] for size in image_sizes)
+ max_width = max(size[1] for size in image_sizes)
+ return (max_height, max_width)
+
+
+def get_num_channels(images_list: list[list["torch.Tensor|np.ndarray"]]) -> int:
+ """
+ Get the number of channels across all images in a batch. Handle empty sublists like in [[], [image]].
+ """
+ for images in images_list:
+ if images:
+ return images[0].shape[0]
+
+ raise ValueError("No images found in the batch.")
+
+
+def get_device_from_images(images_list: list[list["torch.Tensor"]]) -> "torch.device":
+ """
+ Get the device from the first non-empty element in a nested list of images.
+ Handle empty sublists like in [[], [image]].
+ """
+ for images in images_list:
+ if images:
+ return images[0].device
+
+
+@auto_docstring
+class SmolVLMImageProcessor(TorchvisionBackend):
+ resample = PILImageResampling.LANCZOS
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"longest_edge": 4 * 364}
+ max_image_size = {"longest_edge": 364}
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ do_convert_rgb = True
+ do_image_splitting = True
+ do_pad = True
+ return_row_col_info = False
+ valid_kwargs = SmolVLMImageProcessorKwargs
+ model_input_names = ["pixel_values", "pixel_attention_mask"]
+
+ def __init__(self, **kwargs: Unpack[SmolVLMImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(self, images: ImageInput, **kwargs: Unpack[SmolVLMImageProcessorKwargs]) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def _prepare_images_structure(self, images: ImageInput, expected_ndims: int = 3) -> ImageInput:
+ """
+ Prepare a nested images structure for processing.
+ """
+ # Checks for `str` in case of URL/local path and optionally loads images
+ images = self.fetch_images(images)
+ return make_nested_list_of_images(images, expected_ndims=expected_ndims)
+
+ def resize(
+ self,
+ image: "torch.Tensor",
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None" = None,
+ **kwargs,
+ ) -> "torch.Tensor":
+ """
+ Resize an image. The longest edge of the image is resized to size.longest_edge, with the shortest edge
+ resized to keep the input aspect ratio. Can also be used with size.height and size.width.
+ Args:
+ image (`torch.Tensor`):
+ Image to resize.
+ size (`SizeDict`):
+ Size of the output image.
+ resample (`PILImageResampling | tvF.InterpolationMode | int | None`, *optional*):
+ Resampling filter to use when resizing the image.
+ """
+ if size.longest_edge:
+ new_size = get_resize_output_image_size(image, resolution_max_side=size.longest_edge)
+ elif size.height and size.width:
+ new_size = (size.height, size.width)
+ else:
+ raise ValueError("size must be a dictionary with key 'longest_edge' or 'height' and 'width'.")
+
+ return super().resize(image, SizeDict(height=new_size[0], width=new_size[1]), resample=resample, **kwargs)
+
+ def split_images(
+ self,
+ images: torch.Tensor,
+ max_image_size: dict[str, int],
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None" = None,
+ ):
+ """
+ Split an image into squares of side max_image_size and the original image resized to max_image_size.
+ That means that a single image becomes a sequence of images.
+ This is a "trick" to spend more compute on each image with no changes in the vision encoder.
+ 1) If one side of the original image is larger than `max_image_size`, resize it to `max_image_size` while preserving the aspect ratio.
+ 2) Divide the resulting image into `ceil(height / max_image_size)` x `ceil(width / max_image_size)`
+ sub-images of the same size each (image_size, image_size). Typically, 364x364.
+ 3) Returns the list of the crops and the original image, in addition to the number of splits for the height and the width.
+ Args:
+ images (`torch.Tensor`):
+ Images to split.
+ max_image_size (`Dict[str, int]`):
+ Maximum size of the output image. If the image is larger than this size, it will be split into
+ patches of this size, and the original image will be concatenated with the patches, resized to max_size.
+ resample (`PILImageResampling | tvF.InterpolationMode | int | None`, *optional*):
+ Resampling filter to use when resizing the image.
+ """
+ batch_size, num_channels, height, width = images.size()
+ height_dim, width_dim = 2, 3
+
+ max_height = max_width = max_image_size["longest_edge"]
+
+ frames = []
+ if height > max_height or width > max_width:
+ # Calculate the number of splits
+ num_splits_h = math.ceil(height / max_height)
+ num_splits_w = math.ceil(width / max_width)
+
+ # Split the images by height, then by width
+ frames = (
+ images.unfold(height_dim, size=max_height, step=max_height)
+ .unfold(width_dim, size=max_width, step=max_width)
+ .contiguous()
+ .view(batch_size, num_channels, -1, max_height, max_width)
+ .permute(0, 2, 1, 3, 4)
+ ) # batch_size x n_frames x num_channels x height x width
+
+ # For the global image at the end, we resize it to match the max_image_size, for cpu memory efficiency
+ global_image_height, global_image_width = max_height, max_width
+ images = self.resize(
+ images, SizeDict(height=global_image_height, width=global_image_width), resample=resample
+ )
+
+ frames = torch.cat((frames, images.unsqueeze(1)), dim=1)
+ else:
+ num_splits_h, num_splits_w = 0, 0
+ frames = images.unsqueeze(1)
+
+ num_splits_h = [num_splits_h] * batch_size
+ num_splits_w = [num_splits_w] * batch_size
+
+ return frames, num_splits_h, num_splits_w
+
+ def resize_for_vision_encoder(
+ self,
+ image: torch.Tensor,
+ vision_encoder_max_size: int,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None" = None,
+ ):
+ """
+ Resize images to be multiples of `vision_encoder_max_size` while preserving the aspect ratio.
+ Args:
+ image (`torch.Tensor`):
+ Images to resize.
+ vision_encoder_max_size (`int`):
+ Maximum size of the output image. If the image is larger than this size, it will be split into
+ patches of this size, and the original image will be concatenated with the patches, resized to max_size.
+ resample (`PILImageResampling | tvF.InterpolationMode | int | None`, *optional*):
+ Resampling filter to use when resizing the image.
+ """
+ height, width = image.size()[-2:]
+
+ aspect_ratio = width / height
+ if width >= height:
+ width = math.ceil(width / vision_encoder_max_size) * vision_encoder_max_size
+ height = int(width / aspect_ratio)
+ height = math.ceil(height / vision_encoder_max_size) * vision_encoder_max_size
+ elif height > width:
+ height = math.ceil(height / vision_encoder_max_size) * vision_encoder_max_size
+ width = int(height * aspect_ratio)
+ width = math.ceil(width / vision_encoder_max_size) * vision_encoder_max_size
+ new_size = SizeDict(height=height, width=width)
+ return self.resize(image, size=new_size, resample=resample)
+
+ def pad(
+ self,
+ image: torch.Tensor,
+ padded_size: tuple[int, int],
+ fill: int = 0,
+ return_pixel_mask: bool = True,
+ ):
+ original_size = image.shape[-2:]
+ padding_bottom = padded_size[0] - original_size[0]
+ padding_right = padded_size[1] - original_size[1]
+
+ if padding_bottom < 0 or padding_right < 0:
+ raise ValueError(
+ f"Padding dimensions are negative. Please make sure that the padded size is larger than the "
+ f"original size. Got padded size: {padded_size}, original size: {original_size}."
+ )
+
+ # Only pad if necessary
+ if original_size != padded_size:
+ padding = (0, 0, padding_right, padding_bottom)
+ image = tvF.pad(image, padding, fill=fill, padding_mode="constant")
+
+ # Make a pixel mask for the image, where 1 indicates a valid pixel and 0 indicates padding.
+ pixel_mask = None
+ if return_pixel_mask:
+ pixel_mask = torch.zeros_like(image[..., 0, :, :], dtype=torch.int64)
+ pixel_mask[: original_size[0], : original_size[1]] = 1
+
+ return image, pixel_mask
+
+ def _preprocess(
+ self,
+ images: list[list["torch.Tensor"]],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_pad: bool | None,
+ do_image_splitting: bool | None,
+ max_image_size: dict[str, int] | None,
+ return_row_col_info: bool | None,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ """
+ Process a batch of images for the model.
+ """
+
+ grouped_images, grouped_images_index = group_images_by_shape(
+ images, is_nested=True, disable_grouping=disable_grouping
+ )
+ resized_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_resize:
+ stacked_images = self.resize(stacked_images, size, resample=resample)
+ resized_images_grouped[shape] = stacked_images
+ resized_images = reorder_images(resized_images_grouped, grouped_images_index, is_nested=True)
+
+ grouped_images, grouped_images_index = group_images_by_shape(
+ resized_images, is_nested=True, disable_grouping=disable_grouping
+ )
+ split_images_grouped = {}
+ if do_image_splitting:
+ rows_grouped = {}
+ cols_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ stacked_images = self.resize_for_vision_encoder(
+ stacked_images, max_image_size["longest_edge"], resample=resample
+ )
+ stacked_images, rows, cols = self.split_images(
+ stacked_images, max_image_size=max_image_size, resample=resample
+ )
+ split_images_grouped[shape] = stacked_images
+ rows_grouped[shape] = rows
+ cols_grouped[shape] = cols
+ processed_images = reorder_images(split_images_grouped, grouped_images_index, is_nested=True)
+ rows = reorder_images(rows_grouped, grouped_images_index, is_nested=True)
+ cols = reorder_images(cols_grouped, grouped_images_index, is_nested=True)
+ # flattenened the doubly nested list to a nested list
+ for i, group_images in enumerate(processed_images):
+ processed_images[i] = [image for sublist in group_images for image in sublist]
+ else:
+ for shape, stacked_images in grouped_images.items():
+ # We square the images to max_image_size
+ stacked_images = self.resize(
+ image=stacked_images,
+ size=SizeDict(height=max_image_size["longest_edge"], width=max_image_size["longest_edge"]),
+ resample=resample,
+ )
+ split_images_grouped[shape] = stacked_images
+ processed_images = reorder_images(split_images_grouped, grouped_images_index, is_nested=True)
+ rows = [[0] * len(images) for images in processed_images]
+ cols = [[0] * len(images) for images in processed_images]
+ # Group images by size for further processing
+ # Needed in case do_resize is False, or resize returns images with different sizes
+ grouped_images, grouped_images_index = group_images_by_shape(
+ processed_images, is_nested=True, disable_grouping=disable_grouping
+ )
+ processed_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ # Fused rescale and normalize
+ stacked_images = self.rescale_and_normalize(
+ stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ processed_images_grouped[shape] = stacked_images
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index, is_nested=True)
+ if do_pad:
+ # Get max images per batch
+ max_num_images = max(len(images_) for images_ in processed_images)
+ max_height, max_width = get_max_height_width(processed_images)
+ num_channels = get_num_channels(processed_images)
+ device = get_device_from_images(processed_images)
+
+ processed_images_padded = torch.zeros(
+ len(processed_images),
+ max_num_images,
+ *(num_channels, max_height, max_width),
+ device=device,
+ )
+ pixel_attention_masks = torch.zeros(
+ len(processed_images),
+ max_num_images,
+ *(max_height, max_width),
+ device=device,
+ )
+ for i, images in enumerate(processed_images):
+ for j, image in enumerate(images):
+ processed_images_padded[i, j], pixel_attention_masks[i, j] = self.pad(
+ image, (max_height, max_width)
+ )
+ processed_images = processed_images_padded
+
+ if do_pad:
+ data = {"pixel_values": processed_images, "pixel_attention_mask": pixel_attention_masks}
+ elif return_tensors == "pt":
+ data = {"pixel_values": torch.stack([torch.stack(images) for images in processed_images])}
+ else:
+ data = {"pixel_values": processed_images}
+ # This is needed for generating correct text inputs in the processor - we don't pad to the max number of images
+ encoding = BatchFeature(data=data, tensor_type=return_tensors)
+
+ if return_row_col_info:
+ encoding["rows"] = rows
+ encoding["cols"] = cols
+
+ return encoding
+
+ def to_dict(self):
+ encoder_dict = super().to_dict()
+ encoder_dict.pop("_valid_processor_keys", None)
+ encoder_dict.pop("return_row_col_info", None)
+ return encoder_dict
+
+ def get_number_of_image_patches(self, height: int, width: int, images_kwargs: dict):
+ """
+ A utility that returns number of image patches for a given image size.
+
+ Args:
+ height (`int`):
+ Height of the input image.
+ width (`int`):
+ Width of the input image.
+ images_kwargs (`dict`)
+ Any kwargs to override defaults of the image processor.
+ Returns:
+ `int`: Number of patches per image.
+ """
+ do_image_splitting = images_kwargs.get("do_image_splitting", self.do_image_splitting)
+ max_image_size = images_kwargs.get("max_image_size", self.max_image_size)
+ size = images_kwargs.get("size", self.size)
+
+ num_patches = num_rows = num_cols = 0
+ if do_image_splitting:
+ height, width = _resize_output_size_rescale_to_max_len(height, width, max_len=size["longest_edge"])
+ height, width = _resize_output_size_scale_below_upper_bound(height, width, max_len=MAX_IMAGE_SIZE)
+ aspect_ratio = width / height
+
+ if width >= height:
+ resized_width = math.ceil(width / max_image_size["longest_edge"]) * max_image_size["longest_edge"]
+ resized_height = int(width / aspect_ratio)
+ resized_height = math.ceil(height / max_image_size["longest_edge"]) * max_image_size["longest_edge"]
+ elif height > width:
+ resized_height = math.ceil(height / max_image_size["longest_edge"]) * max_image_size["longest_edge"]
+ resized_width = int(height * aspect_ratio)
+ resized_width = math.ceil(width / max_image_size["longest_edge"]) * max_image_size["longest_edge"]
+
+ max_height = max_width = max_image_size["longest_edge"]
+ if resized_height > max_height or resized_width > max_width:
+ # Calculate the number of splits
+ num_rows = math.ceil(resized_height / max_height)
+ num_cols = math.ceil(resized_width / max_width)
+ num_patches = num_rows * num_cols + 1
+
+ return num_patches, num_rows, num_cols
+
+
+__all__ = ["SmolVLMImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/modeling_smolvlm.py b/lib/python3.11/site-packages/transformers/models/smolvlm/modeling_smolvlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..2abafc118006a3b46eefde81e5e098009e42d3b2
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smolvlm/modeling_smolvlm.py
@@ -0,0 +1,871 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/smolvlm/modular_smolvlm.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_smolvlm.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 the HuggingFace Inc. team. All rights reserved.
+# Written by Orr Zohar
+#
+# 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 collections.abc import Callable
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache
+from ...generation import GenerationConfig, GenerationMixin
+from ...masking_utils import create_bidirectional_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling, ModelOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, logging, torch_compilable_check
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from ..auto import AutoModel
+from .configuration_smolvlm import SmolVLMConfig, SmolVLMVisionConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring
+class SmolVLMPreTrainedModel(PreTrainedModel):
+ config: SmolVLMConfig
+ base_model_prefix = "model"
+ input_modalities = ("image", "text")
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["SmolVLMVisionAttention", "SmolVLMDecoderLayer"]
+ _skip_keys_device_placement = ["past_key_values"]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+ _supports_attention_backend = True
+
+
+class SmolVLMVisionEmbeddings(nn.Module):
+ """
+ This is a modified version of `siglip.modelign_siglip.SiglipVisionEmbeddings` to enable images of variable
+ resolution.
+
+ The modifications are adapted from [Patch n' Pack: NaViT, a Vision Transformer for any Aspect Ratio and Resolution](https://huggingface.co/papers/2307.06304)
+ which allows treating images in their native aspect ratio and without the need to resize them to the same
+ fixed size. In particular, we start from the original pre-trained SigLIP model
+ (which uses images of fixed-size square images) and adapt it by training on images of variable resolutions.
+ """
+
+ def __init__(self, config: SmolVLMVisionConfig):
+ super().__init__()
+ self.embed_dim = config.hidden_size
+ self.image_size = config.image_size
+ self.patch_size = config.patch_size
+
+ self.patch_embedding = nn.Conv2d(
+ in_channels=config.num_channels,
+ out_channels=self.embed_dim,
+ kernel_size=self.patch_size,
+ stride=self.patch_size,
+ padding="valid",
+ )
+
+ self.num_patches_per_side = self.image_size // self.patch_size
+ self.num_patches = self.num_patches_per_side**2
+ self.num_positions = self.num_patches
+ self.position_embedding = nn.Embedding(self.num_positions, self.embed_dim)
+
+ def forward(self, pixel_values: torch.FloatTensor, patch_attention_mask: torch.BoolTensor) -> torch.Tensor:
+ batch_size, _, max_im_h, max_im_w = pixel_values.shape
+
+ patch_embeds = self.patch_embedding(pixel_values)
+ embeddings = patch_embeds.flatten(2).transpose(1, 2)
+
+ max_nb_patches_h, max_nb_patches_w = max_im_h // self.patch_size, max_im_w // self.patch_size
+ boundaries = torch.arange(
+ 1 / self.num_patches_per_side, 1.0, 1 / self.num_patches_per_side, device=pixel_values.device
+ )
+ position_ids = torch.full(
+ size=(batch_size, max_nb_patches_h * max_nb_patches_w), fill_value=0, device=pixel_values.device
+ )
+
+ nb_patches_h = patch_attention_mask[:, :, 0].sum(dim=1) # (batch_size,)
+ nb_patches_w = patch_attention_mask[:, 0, :].sum(dim=1) # (batch_size,)
+
+ step_h = 1.0 / nb_patches_h # (batch_size,)
+ step_w = 1.0 / nb_patches_w # (batch_size,)
+
+ max_patches_h = patch_attention_mask.size(1)
+ max_patches_w = patch_attention_mask.size(2)
+ h_indices = torch.arange(max_patches_h, device=position_ids.device, dtype=torch.float32)
+ w_indices = torch.arange(max_patches_w, device=position_ids.device, dtype=torch.float32)
+
+ fractional_coords_h = h_indices[None, :] * step_h[:, None]
+ fractional_coords_w = w_indices[None, :] * step_w[:, None]
+
+ fractional_coords_h = torch.clamp(fractional_coords_h, max=(1.0 - 1e-6))
+ fractional_coords_w = torch.clamp(fractional_coords_w, max=(1.0 - 1e-6))
+
+ fractional_coords_h = fractional_coords_h.to(pixel_values.dtype)
+ fractional_coords_w = fractional_coords_w.to(pixel_values.dtype)
+
+ bucket_coords_h = torch.bucketize(fractional_coords_h, boundaries, right=True)
+ bucket_coords_w = torch.bucketize(fractional_coords_w, boundaries, right=True)
+
+ pos_ids = bucket_coords_h[:, :, None] * self.num_patches_per_side + bucket_coords_w[:, None, :]
+ pos_ids = pos_ids.reshape(batch_size, -1)
+
+ position_ids[patch_attention_mask.view(batch_size, -1)] = pos_ids[patch_attention_mask.view(batch_size, -1)]
+
+ embeddings = embeddings + self.position_embedding(position_ids)
+ return embeddings
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float,
+ dropout: float = 0.0,
+ **kwargs,
+):
+ attn_weights = torch.matmul(query, key.transpose(-1, -2)) * scaling
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+class SmolVLMVisionAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.num_heads = config.num_attention_heads
+ self.head_dim = self.embed_dim // self.num_heads
+ if self.head_dim * self.num_heads != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+ f" {self.num_heads})."
+ )
+ self.scale = self.head_dim**-0.5
+ self.dropout = config.attention_dropout
+
+ self.k_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.v_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.q_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.out_proj = nn.Linear(self.embed_dim, self.embed_dim)
+
+ # Ignore copy
+ self.is_causal = False
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ """Input shape: Batch x Time x Channel"""
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+ queries = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ keys = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ values = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ queries,
+ keys,
+ values,
+ attention_mask,
+ is_causal=self.is_causal,
+ scaling=self.scale,
+ dropout=0.0 if not self.training else self.dropout,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+class SmolVLMVisionMLP(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.activation_fn = ACT2FN[config.hidden_act]
+ self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size)
+ self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.fc1(hidden_states)
+ hidden_states = self.activation_fn(hidden_states)
+ hidden_states = self.fc2(hidden_states)
+ return hidden_states
+
+
+class SmolVLMEncoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: SmolVLMVisionConfig):
+ super().__init__()
+ self.embed_dim = config.hidden_size
+ self.self_attn = SmolVLMVisionAttention(config)
+ self.layer_norm1 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+ self.mlp = SmolVLMVisionMLP(config)
+ self.layer_norm2 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+
+ @auto_docstring
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.FloatTensor:
+ residual = hidden_states
+
+ hidden_states = self.layer_norm1(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.layer_norm2(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = residual + hidden_states
+
+ return hidden_states
+
+
+class SmolVLMEncoder(nn.Module):
+ """
+ Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
+ [`SmolVLMEncoderLayer`].
+
+ Args:
+ config: SmolVLMConfig
+ """
+
+ def __init__(self, config: SmolVLMConfig):
+ super().__init__()
+ self.config = config
+ self.layers = nn.ModuleList([SmolVLMEncoderLayer(config) for _ in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ # Ignore copy
+ @auto_docstring
+ def forward(
+ self,
+ inputs_embeds,
+ attention_mask: torch.Tensor | None = None,
+ ) -> tuple | BaseModelOutput:
+ hidden_states = inputs_embeds
+ for encoder_layer in self.layers:
+ layer_outputs = encoder_layer(
+ hidden_states,
+ attention_mask,
+ )
+
+ hidden_states = layer_outputs
+
+ return BaseModelOutput(last_hidden_state=hidden_states)
+
+
+@auto_docstring(
+ custom_intro="""
+ The SmolVLM Vision Transformer Model outputting raw image embedding.
+ """
+)
+class SmolVLMVisionTransformer(SmolVLMPreTrainedModel):
+ config: SmolVLMVisionConfig
+ input_modalities = ("image",)
+ _can_record_outputs = {
+ "hidden_states": SmolVLMEncoderLayer,
+ "attentions": SmolVLMVisionAttention,
+ }
+
+ def __init__(self, config: SmolVLMVisionConfig):
+ super().__init__(config)
+ embed_dim = config.hidden_size
+
+ self.embeddings = SmolVLMVisionEmbeddings(config)
+ self.encoder = SmolVLMEncoder(config)
+ self.patch_size = config.patch_size
+ self.post_layernorm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings
+
+ def set_input_embeddings(self, value):
+ self.embeddings = value
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ def forward(
+ self,
+ pixel_values,
+ patch_attention_mask: torch.BoolTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutput:
+ batch_size = pixel_values.size(0)
+ if patch_attention_mask is None:
+ patch_size = self.patch_size
+ patch_attention_mask = torch.ones(
+ (
+ batch_size,
+ pixel_values.size(2) // patch_size,
+ pixel_values.size(3) // patch_size,
+ )
+ )
+ patch_attention_mask = patch_attention_mask.to(dtype=torch.bool, device=pixel_values.device)
+
+ hidden_states = self.embeddings(pixel_values=pixel_values, patch_attention_mask=patch_attention_mask)
+
+ patch_attention_mask = patch_attention_mask.view(batch_size, -1)
+ # Create the correct attention mask based on the attention implementation
+ patch_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=patch_attention_mask,
+ )
+
+ encoder_outputs: BaseModelOutput = self.encoder(
+ inputs_embeds=hidden_states,
+ attention_mask=patch_attention_mask,
+ )
+
+ last_hidden_state = encoder_outputs.last_hidden_state
+ last_hidden_state = self.post_layernorm(last_hidden_state)
+
+ return BaseModelOutput(
+ last_hidden_state=last_hidden_state,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for SmolVLM model's outputs that may also contain a past key/values (to speed up sequential decoding).
+ """
+)
+@dataclass
+class SmolVLMBaseModelOutputWithPast(ModelOutput):
+ r"""
+ last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Sequence of hidden-states at the output of the last layer of the model.
+ If `past_key_values` is used only the last hidden-state of the sequences of shape `(batch_size, 1,
+ hidden_size)` is output.
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if
+ `config.is_encoder_decoder=True` in the cross-attention blocks) that can be used (see `past_key_values`
+ input) to speed up sequential decoding.
+ image_hidden_states (`tuple(torch.FloatTensor)`, *optional*):
+ Tuple of `torch.FloatTensor` (one for the output of the image embeddings, `(batch_size, num_images,
+ sequence_length, hidden_size)`.
+ image_hidden_states of the model produced by the vision encoder
+ """
+
+ last_hidden_state: torch.FloatTensor | None = None
+ past_key_values: Cache | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+ image_hidden_states: tuple[torch.FloatTensor] | None = None
+
+
+class SmolVLMSimpleMLP(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ input_size = config.vision_config.hidden_size * (config.scale_factor**2)
+ output_size = config.text_config.hidden_size
+ self.proj = nn.Linear(input_size, output_size, bias=False)
+
+ def forward(self, x):
+ return self.proj(x)
+
+
+class SmolVLMConnector(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.scale_factor = config.scale_factor
+ self.modality_projection = SmolVLMSimpleMLP(config)
+
+ def pixel_shuffle(self, x, scale_factor=2):
+ bsz, seq, embed_dim = x.size()
+ height = width = int(seq**0.5)
+ x = x.view(bsz, height, width, embed_dim)
+ x = x.view(bsz, height, int(width / scale_factor), embed_dim * scale_factor)
+ x = x.permute(0, 2, 1, 3)
+ x = x.reshape(bsz, int(width / scale_factor), int(height / scale_factor), embed_dim * (scale_factor**2))
+ x = x.permute(0, 2, 1, 3)
+ x = x.reshape(bsz, int(seq / (scale_factor**2)), embed_dim * (scale_factor**2))
+ return x
+
+ def forward(self, image_hidden_states):
+ image_hidden_states = self.pixel_shuffle(image_hidden_states, self.scale_factor)
+ image_hidden_states = self.modality_projection(image_hidden_states)
+ return image_hidden_states
+
+
+@auto_docstring(
+ custom_intro="""
+ SmolVLM model consisting of a SIGLIP vision encoder and Llama3 language decoder
+ """
+)
+class SmolVLMModel(SmolVLMPreTrainedModel):
+ """
+ A subclass of Idefics3Model. We do *not* remove or block the call to inputs_merger
+ in forward. Instead, we override inputs_merger here with custom logic.
+ """
+
+ def __init__(self, config: SmolVLMConfig):
+ super().__init__(config)
+ self.padding_idx = self.config.text_config.pad_token_id
+ self.vocab_size = self.config.text_config.vocab_size
+
+ self.vision_model = SmolVLMVisionTransformer._from_config(config.vision_config)
+ self.connector = SmolVLMConnector(config)
+ self.text_model = AutoModel.from_config(config.text_config)
+
+ self.image_seq_len = int(
+ ((config.vision_config.image_size // config.vision_config.patch_size) ** 2) / (config.scale_factor**2)
+ )
+ self.image_token_id = self.config.image_token_id
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.text_model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.text_model.set_input_embeddings(value)
+
+ def inputs_merger(
+ self, input_ids: torch.LongTensor, inputs_embeds: torch.Tensor, image_hidden_states: torch.Tensor
+ ):
+ """
+ This method aims at merging the token embeddings with the image hidden states into one single sequence of vectors that are fed to the transformer LM.
+ The merging happens as follows:
+ - The text token sequence is: `tok_1 tok_2 tok_3 <fake_token_around_image> <image> <image> ... <image> <fake_token_around_image> tok_4`.
+ - We get the image hidden states for the image through the vision encoder and that hidden state, after a pixel shuffle operation, is then projected into the text embedding space.
+ We thus have a sequence of image hidden states of size (1, image_seq_len, hidden_dim), where 1 is for batch_size of 1 image and hidden_dim is the hidden_dim of the LM transformer.
+ - The merging happens so that we obtain the following sequence: `vector_tok_1 vector_tok_2 vector_tok_3 vector_fake_tok_around_image {sequence of image_seq_len image hidden states} vector_fake_toke_around_image vector_tok_4`. That sequence is fed to the LM.
+ - To fit the format of that sequence, `input_ids`, `inputs_embeds`, `attention_mask` are all 3 adapted to insert the image hidden states.
+ """
+ _, patch_size, _ = image_hidden_states.shape
+
+ if input_ids is None:
+ image_mask = inputs_embeds == self.get_input_embeddings()(
+ torch.tensor(self.config.image_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ image_mask = image_mask[..., 0] # slice off the hidden dim
+ else:
+ image_mask = input_ids == self.config.image_token_id
+
+ num_image_tokens = image_mask.sum(dim=1)
+ torch_compilable_check(
+ torch.all(num_image_tokens % patch_size == 0),
+ "At least one sample has <image> tokens not divisible by patch_size.",
+ )
+ blocks_per_sample = num_image_tokens // patch_size
+
+ offsets = torch.nn.functional.pad(blocks_per_sample.cumsum(dim=0), (1, 0), value=0)
+ block_offset = offsets[:-1]
+ row_cum = image_mask.cumsum(dim=-1)
+ chunk_idx = (row_cum - 1) // patch_size
+ local_idx = (row_cum - 1) % patch_size
+ block_idx = block_offset.unsqueeze(1) + chunk_idx
+
+ image_embeds = torch.zeros_like(inputs_embeds)
+ image_embeds[image_mask] = image_hidden_states[block_idx[image_mask], local_idx[image_mask], :]
+
+ merged_embeds = torch.where(image_mask.unsqueeze(-1), image_embeds, inputs_embeds)
+ return merged_embeds
+
+ @can_return_tuple
+ @auto_docstring(
+ custom_intro="Encodes images into continuous embeddings that can be forwarded to the language model."
+ )
+ def get_image_features(
+ self,
+ pixel_values: torch.FloatTensor,
+ pixel_attention_mask: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input images.
+ pixel_attention_mask (`torch.LongTensor`, *optional*):
+ The attention mask indicating padded regions in the image.
+ """
+ batch_size, num_images, num_channels, height, width = pixel_values.shape
+ pixel_values = pixel_values.to(dtype=self.dtype) # fp16 compatibility
+ pixel_values = pixel_values.view(batch_size * num_images, *pixel_values.shape[2:])
+
+ # Remove padding images - padding images are full 0.
+ nb_values_per_image = pixel_values.shape[1:].numel()
+ real_images_inds = (pixel_values == 0.0).sum(dim=(-1, -2, -3)) != nb_values_per_image
+
+ # If no images, leave one empty image.
+ real_images_inds[0] |= ~torch.any(real_images_inds)
+
+ pixel_values = pixel_values[real_images_inds].contiguous()
+ # Handle the vision attention mask
+ if pixel_attention_mask is None:
+ pixel_attention_mask = torch.ones(
+ size=[pixel_values.shape[i] for i in (0, 2, 3)],
+ dtype=torch.bool,
+ device=pixel_values.device,
+ )
+ else:
+ # Remove padding images from the mask
+ pixel_attention_mask = pixel_attention_mask.view(batch_size * num_images, *pixel_attention_mask.shape[2:])
+ pixel_attention_mask = pixel_attention_mask[real_images_inds].contiguous()
+ patch_size = self.config.vision_config.patch_size
+ patches_subgrid = pixel_attention_mask.unfold(dimension=1, size=patch_size, step=patch_size)
+ patches_subgrid = patches_subgrid.unfold(dimension=2, size=patch_size, step=patch_size)
+ patch_attention_mask = (patches_subgrid.sum(dim=(-1, -2)) > 0).bool()
+
+ # Get sequence from the vision encoder
+ image_outputs = self.vision_model(
+ pixel_values=pixel_values, patch_attention_mask=patch_attention_mask, return_dict=True, **kwargs
+ )
+ image_hidden_states = image_outputs.last_hidden_state
+
+ # Modality projection & resampling
+ image_features = self.connector(image_hidden_states)
+ image_outputs.pooler_output = image_features
+
+ return image_outputs
+
+ @can_return_tuple
+ @auto_docstring(
+ custom_intro="""
+ Inputs fed to the model can have an arbitrary number of images. To account for this, pixel_values fed to
+ the model have image padding -> (batch_size, max_num_images, 3, max_heights, max_widths) where
+ max_num_images is the maximum number of images among the batch_size samples in the batch.
+ Padding images are not needed beyond padding the pixel_values at the entrance of the model.
+ For efficiency, we only pass through the vision_model's forward the real images by
+ discarding the padding images i.e. pixel_values of size (image_batch_size, 3, height, width) where
+ image_batch_size would be 7 when num_images_per_sample=[1, 3, 1, 2] and max_num_images would be 3.
+ """
+ )
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ pixel_attention_mask: torch.BoolTensor | None = None,
+ image_hidden_states: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple | SmolVLMBaseModelOutputWithPast:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ image_hidden_states (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The hidden states of the image encoder after modality projection.
+ """
+ if self.training and self.text_model.gradient_checkpointing and use_cache:
+ logger.warning_once(
+ "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+ )
+ use_cache = False
+
+ if input_ids is not None:
+ batch_size, seq_length = input_ids.shape
+ elif inputs_embeds is not None:
+ batch_size, seq_length, _ = inputs_embeds.shape
+ else:
+ raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+ if use_cache and past_key_values is None:
+ past_key_values = DynamicCache(config=self.config)
+
+ if inputs_embeds is None:
+ inputs_embeds = self.text_model.get_input_embeddings()(input_ids).to(input_ids.device)
+
+ if pixel_values is not None and image_hidden_states is not None:
+ raise ValueError("You cannot specify both pixel_values and image_hidden_states at the same time")
+
+ if pixel_values is not None:
+ image_hidden_states = self.get_image_features(
+ pixel_values, pixel_attention_mask, return_dict=True
+ ).pooler_output
+ image_hidden_states = image_hidden_states.to(inputs_embeds.device)
+ elif image_hidden_states is not None:
+ image_hidden_states = image_hidden_states.to(dtype=self.dtype, device=inputs_embeds.device)
+
+ if image_hidden_states is not None:
+ inputs_embeds = self.inputs_merger(
+ input_ids=input_ids,
+ inputs_embeds=inputs_embeds,
+ image_hidden_states=image_hidden_states,
+ )
+
+ outputs = self.text_model(
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return SmolVLMBaseModelOutputWithPast(
+ last_hidden_state=outputs.last_hidden_state,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ image_hidden_states=image_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for Idefics causal language model (or autoregressive) outputs.
+ """
+)
+@dataclass
+class SmolVLMCausalLMOutputWithPast(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+ Language modeling loss (for next-token prediction).
+ logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
+ Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
+ `past_key_values` input) to speed up sequential decoding.
+ image_hidden_states (`tuple(torch.FloatTensor)`, *optional*):
+ Tuple of `torch.FloatTensor` (one for the output of the image embeddings, `(batch_size, num_images,
+ sequence_length, hidden_size)`.
+ image_hidden_states of the model produced by the vision encoder
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ past_key_values: Cache | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+ image_hidden_states: tuple[torch.FloatTensor] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ The SmolVLM Model with a language modeling head. It is made up a SigLIP vision encoder, with a language modeling head on top.
+ """
+)
+class SmolVLMForConditionalGeneration(SmolVLMPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"lm_head.weight": "model.text_model.embed_tokens.weight"}
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.model = SmolVLMModel(config)
+ self.image_token_id = self.config.image_token_id
+ self.lm_head = nn.Linear(config.text_config.hidden_size, config.text_config.vocab_size, bias=False)
+ self.vocab_size = config.text_config.vocab_size
+ self.model.text_model.generation_config = GenerationConfig.from_model_config(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.text_model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.text_model.set_input_embeddings(value)
+
+ @auto_docstring
+ def get_image_features(
+ self,
+ pixel_values: torch.FloatTensor,
+ pixel_attention_mask: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input images.
+ pixel_attention_mask (`torch.LongTensor`, *optional*):
+ The attention mask indicating padded regions in the image.
+ """
+ return self.model.get_image_features(
+ pixel_values=pixel_values, pixel_attention_mask=pixel_attention_mask, **kwargs
+ )
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ pixel_attention_mask: torch.BoolTensor | None = None,
+ image_hidden_states: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ logits_to_keep: int | torch.Tensor = 0,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | SmolVLMCausalLMOutputWithPast:
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ image_hidden_states (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The hidden states of the image encoder after modality projection.
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or `model.image_token_id`. Tokens with indices set to `model.image_token_id` are
+ ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+ Example:
+
+ ```python
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> import torch
+ >>> from PIL import Image
+ >>> from io import BytesIO
+
+ >>> from transformers import AutoProcessor, AutoModelForImageTextToText
+ >>> from transformers.image_utils import load_image
+
+ >>> # Note that passing the image urls (instead of the actual pil images) to the processor is also possible
+ >>> image1 = load_image("https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg")
+ >>> image2 = load_image("https://cdn.britannica.com/59/94459-050-DBA42467/Skyline-Chicago.jpg")
+ >>> image3 = load_image("https://cdn.britannica.com/68/170868-050-8DDE8263/Golden-Gate-Bridge-San-Francisco.jpg")
+
+ >>> processor = AutoProcessor.from_pretrained("HuggingFaceTB/SmolVLM2-2.2B-Instruct")
+ >>> model = AutoModelForImageTextToText.from_pretrained("HuggingFaceTB/SmolVLM2-2.2B-Instruct", dtype=torch.bfloat16, device_map="auto")
+
+ >>> # Create inputs
+ >>> messages = [
+ ... {
+ ... "role": "user",
+ ... "content": [
+ ... {"type": "video", "path": path/to/video},
+ ... {"type": "text", "text": "What is happening in this video?"},
+ ... ]
+ ... }
+ ... ]
+
+ >>> inputs = processor.apply_chat_template([messages], add_generation_prompt=True)
+
+ >>> # Generate
+ >>> generated_ids = model.generate(**inputs, max_new_tokens=256)
+ >>> generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
+
+ >>> print(generated_texts)
+ ```"""
+ # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
+ outputs = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ pixel_values=pixel_values,
+ pixel_attention_mask=pixel_attention_mask,
+ image_hidden_states=image_hidden_states,
+ use_cache=use_cache,
+ return_dict=True,
+ **kwargs,
+ )
+
+ hidden_states = outputs[0]
+ # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+ slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+ logits = self.lm_head(hidden_states[:, slice_indices, :])
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(
+ logits=logits, labels=labels, vocab_size=self.config.text_config.vocab_size, **kwargs
+ )
+
+ return SmolVLMCausalLMOutputWithPast(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ image_hidden_states=outputs.image_hidden_states,
+ )
+
+ def prepare_inputs_for_generation(
+ self,
+ input_ids,
+ past_key_values=None,
+ attention_mask=None,
+ inputs_embeds=None,
+ pixel_values=None,
+ pixel_attention_mask=None,
+ image_hidden_states=None,
+ logits_to_keep=None,
+ is_first_iteration=False,
+ use_cache=False,
+ **kwargs,
+ ):
+ # Overwritten -- there are mutually exclusive inputs (if the logic to make `image_hidden_states` take
+ # precedence is moved to the model, we can remove this fn)
+
+ model_inputs = super().prepare_inputs_for_generation(
+ input_ids,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ pixel_values=pixel_values,
+ pixel_attention_mask=pixel_attention_mask,
+ image_hidden_states=image_hidden_states,
+ logits_to_keep=logits_to_keep,
+ is_first_iteration=is_first_iteration,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ if image_hidden_states is not None or (use_cache and not is_first_iteration):
+ model_inputs["pixel_values"] = None
+ model_inputs["pixel_attention_mask"] = None
+
+ return model_inputs
+
+
+__all__ = ["SmolVLMForConditionalGeneration", "SmolVLMPreTrainedModel", "SmolVLMModel", "SmolVLMVisionTransformer"]
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/modular_smolvlm.py b/lib/python3.11/site-packages/transformers/models/smolvlm/modular_smolvlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf91863c56a7c00bb72c9eafd2e876afacae9be8
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smolvlm/modular_smolvlm.py
@@ -0,0 +1,354 @@
+# Copyright 2025 the HuggingFace Inc. team. All rights reserved.
+# Written by Orr Zohar
+#
+# 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 torch
+from huggingface_hub.dataclasses import strict
+from torch import nn
+
+from ...cache_utils import Cache, DynamicCache
+from ...generation import GenerationConfig
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_outputs import BaseModelOutputWithPooling
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, logging, torch_compilable_check
+from ..idefics3.configuration_idefics3 import Idefics3Config, Idefics3VisionConfig
+from ..idefics3.image_processing_idefics3 import Idefics3ImageProcessor
+from ..idefics3.image_processing_pil_idefics3 import Idefics3ImageProcessorPil
+from ..idefics3.modeling_idefics3 import (
+ Idefics3BaseModelOutputWithPast,
+ Idefics3ForConditionalGeneration,
+ Idefics3Model,
+ Idefics3PreTrainedModel,
+ Idefics3VisionTransformer,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="HuggingFaceTB/SmolVLM2-2.2B-Instruct")
+@strict
+class SmolVLMVisionConfig(Idefics3VisionConfig):
+ r"""
+ Example:
+
+ ```python
+ >>> from transformers.models.smolvlm.modeling_smolvlm import SmolVLMVisionTransformer
+ >>> from transformers.models.smolvlm.configuration_smolvlm import SmolVLMVisionConfig
+
+ >>> # Initializing a SmolVLMVisionConfig with google/siglip-so400m-patch14-384 style configuration
+ >>> configuration = SmolVLMVisionConfig()
+
+ >>> # Initializing a SmolVLMVisionTransformer (with random weights) from the google/siglip-so400m-patch14-384 style configuration
+ >>> model = SmolVLMVisionTransformer(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "smolvlm_vision"
+
+
+class SmolVLMPreTrainedModel(Idefics3PreTrainedModel):
+ pass
+
+
+class SmolVLMVisionTransformer(Idefics3VisionTransformer):
+ pass
+
+
+@auto_docstring(checkpoint="HuggingFaceTB/SmolVLM2-2.2B-Instruct")
+@strict
+class SmolVLMConfig(Idefics3Config):
+ r"""
+ scale_factor (`int`, *optional*, defaults to 2):
+ The scale factor for the image encoder.
+
+ Example:
+ ```python
+ >>> from transformers import SmolVLMModel, SmolVLMConfig
+ >>> # Initializing configuration
+ >>> configuration = SmolVLMConfig()
+ >>> # Initializing a model from the configuration
+ >>> model = SmolVLMModel(configuration)
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "smolvlm"
+
+
+class SmolVLMImageProcessor(Idefics3ImageProcessor):
+ pass
+
+
+class SmolVLMImageProcessorPil(Idefics3ImageProcessorPil):
+ pass
+
+
+class SmolVLMBaseModelOutputWithPast(Idefics3BaseModelOutputWithPast):
+ pass
+
+
+class SmolVLMModel(Idefics3Model):
+ """
+ A subclass of Idefics3Model. We do *not* remove or block the call to inputs_merger
+ in forward. Instead, we override inputs_merger here with custom logic.
+ """
+
+ def inputs_merger(
+ self, input_ids: torch.LongTensor, inputs_embeds: torch.Tensor, image_hidden_states: torch.Tensor
+ ):
+ _, patch_size, _ = image_hidden_states.shape
+
+ if input_ids is None:
+ image_mask = inputs_embeds == self.get_input_embeddings()(
+ torch.tensor(self.config.image_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ image_mask = image_mask[..., 0] # slice off the hidden dim
+ else:
+ image_mask = input_ids == self.config.image_token_id
+
+ num_image_tokens = image_mask.sum(dim=1)
+ torch_compilable_check(
+ torch.all(num_image_tokens % patch_size == 0),
+ "At least one sample has <image> tokens not divisible by patch_size.",
+ )
+ blocks_per_sample = num_image_tokens // patch_size
+
+ offsets = torch.nn.functional.pad(blocks_per_sample.cumsum(dim=0), (1, 0), value=0)
+ block_offset = offsets[:-1]
+ row_cum = image_mask.cumsum(dim=-1)
+ chunk_idx = (row_cum - 1) // patch_size
+ local_idx = (row_cum - 1) % patch_size
+ block_idx = block_offset.unsqueeze(1) + chunk_idx
+
+ image_embeds = torch.zeros_like(inputs_embeds)
+ image_embeds[image_mask] = image_hidden_states[block_idx[image_mask], local_idx[image_mask], :]
+
+ merged_embeds = torch.where(image_mask.unsqueeze(-1), image_embeds, inputs_embeds)
+ return merged_embeds
+
+ @can_return_tuple
+ @auto_docstring(
+ custom_intro="Encodes images into continuous embeddings that can be forwarded to the language model."
+ )
+ def get_image_features(
+ self,
+ pixel_values: torch.FloatTensor,
+ pixel_attention_mask: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input images.
+ pixel_attention_mask (`torch.LongTensor`, *optional*):
+ The attention mask indicating padded regions in the image.
+ """
+ batch_size, num_images, num_channels, height, width = pixel_values.shape
+ pixel_values = pixel_values.to(dtype=self.dtype) # fp16 compatibility
+ pixel_values = pixel_values.view(batch_size * num_images, *pixel_values.shape[2:])
+
+ # Remove padding images - padding images are full 0.
+ nb_values_per_image = pixel_values.shape[1:].numel()
+ real_images_inds = (pixel_values == 0.0).sum(dim=(-1, -2, -3)) != nb_values_per_image
+
+ # If no images, leave one empty image.
+ real_images_inds[0] |= ~torch.any(real_images_inds)
+
+ pixel_values = pixel_values[real_images_inds].contiguous()
+ # Handle the vision attention mask
+ if pixel_attention_mask is None:
+ pixel_attention_mask = torch.ones(
+ size=[pixel_values.shape[i] for i in (0, 2, 3)],
+ dtype=torch.bool,
+ device=pixel_values.device,
+ )
+ else:
+ # Remove padding images from the mask
+ pixel_attention_mask = pixel_attention_mask.view(batch_size * num_images, *pixel_attention_mask.shape[2:])
+ pixel_attention_mask = pixel_attention_mask[real_images_inds].contiguous()
+ patch_size = self.config.vision_config.patch_size
+ patches_subgrid = pixel_attention_mask.unfold(dimension=1, size=patch_size, step=patch_size)
+ patches_subgrid = patches_subgrid.unfold(dimension=2, size=patch_size, step=patch_size)
+ patch_attention_mask = (patches_subgrid.sum(dim=(-1, -2)) > 0).bool()
+
+ # Get sequence from the vision encoder
+ image_outputs = self.vision_model(
+ pixel_values=pixel_values, patch_attention_mask=patch_attention_mask, return_dict=True, **kwargs
+ )
+ image_hidden_states = image_outputs.last_hidden_state
+
+ # Modality projection & resampling
+ image_features = self.connector(image_hidden_states)
+ image_outputs.pooler_output = image_features
+
+ return image_outputs
+
+ @can_return_tuple
+ @auto_docstring(
+ custom_intro="""
+ Inputs fed to the model can have an arbitrary number of images. To account for this, pixel_values fed to
+ the model have image padding -> (batch_size, max_num_images, 3, max_heights, max_widths) where
+ max_num_images is the maximum number of images among the batch_size samples in the batch.
+ Padding images are not needed beyond padding the pixel_values at the entrance of the model.
+ For efficiency, we only pass through the vision_model's forward the real images by
+ discarding the padding images i.e. pixel_values of size (image_batch_size, 3, height, width) where
+ image_batch_size would be 7 when num_images_per_sample=[1, 3, 1, 2] and max_num_images would be 3.
+ """
+ )
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ pixel_attention_mask: torch.BoolTensor | None = None,
+ image_hidden_states: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple | SmolVLMBaseModelOutputWithPast:
+ if self.training and self.text_model.gradient_checkpointing and use_cache:
+ logger.warning_once(
+ "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+ )
+ use_cache = False
+
+ if input_ids is not None:
+ batch_size, seq_length = input_ids.shape
+ elif inputs_embeds is not None:
+ batch_size, seq_length, _ = inputs_embeds.shape
+ else:
+ raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+ if use_cache and past_key_values is None:
+ past_key_values = DynamicCache(config=self.config)
+
+ if inputs_embeds is None:
+ inputs_embeds = self.text_model.get_input_embeddings()(input_ids).to(input_ids.device)
+
+ if pixel_values is not None and image_hidden_states is not None:
+ raise ValueError("You cannot specify both pixel_values and image_hidden_states at the same time")
+
+ if pixel_values is not None:
+ image_hidden_states = self.get_image_features(
+ pixel_values, pixel_attention_mask, return_dict=True
+ ).pooler_output
+ image_hidden_states = image_hidden_states.to(inputs_embeds.device)
+ elif image_hidden_states is not None:
+ image_hidden_states = image_hidden_states.to(dtype=self.dtype, device=inputs_embeds.device)
+
+ if image_hidden_states is not None:
+ inputs_embeds = self.inputs_merger(
+ input_ids=input_ids,
+ inputs_embeds=inputs_embeds,
+ image_hidden_states=image_hidden_states,
+ )
+
+ outputs = self.text_model(
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return SmolVLMBaseModelOutputWithPast(
+ last_hidden_state=outputs.last_hidden_state,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ image_hidden_states=image_hidden_states,
+ )
+
+
+class SmolVLMForConditionalGeneration(Idefics3ForConditionalGeneration):
+ _tied_weights_keys = {"lm_head.weight": "model.text_model.embed_tokens.weight"}
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.model = SmolVLMModel(config)
+ self.model.text_model.generation_config = GenerationConfig.from_model_config(config)
+ self.lm_head = nn.Linear(config.text_config.hidden_size, config.text_config.vocab_size, bias=False)
+ self.post_init()
+
+ def forward(self, **super_kwargs):
+ r"""
+ pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
+ Mask to avoid performing attention on padding pixel indices.
+ image_hidden_states (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The hidden states of the image encoder after modality projection.
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or `model.image_token_id`. Tokens with indices set to `model.image_token_id` are
+ ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+ Example:
+
+ ```python
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> import torch
+ >>> from PIL import Image
+ >>> from io import BytesIO
+
+ >>> from transformers import AutoProcessor, AutoModelForImageTextToText
+ >>> from transformers.image_utils import load_image
+
+ >>> # Note that passing the image urls (instead of the actual pil images) to the processor is also possible
+ >>> image1 = load_image("https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg")
+ >>> image2 = load_image("https://cdn.britannica.com/59/94459-050-DBA42467/Skyline-Chicago.jpg")
+ >>> image3 = load_image("https://cdn.britannica.com/68/170868-050-8DDE8263/Golden-Gate-Bridge-San-Francisco.jpg")
+
+ >>> processor = AutoProcessor.from_pretrained("HuggingFaceTB/SmolVLM2-2.2B-Instruct")
+ >>> model = AutoModelForImageTextToText.from_pretrained("HuggingFaceTB/SmolVLM2-2.2B-Instruct", dtype=torch.bfloat16, device_map="auto")
+
+ >>> # Create inputs
+ >>> messages = [
+ ... {
+ ... "role": "user",
+ ... "content": [
+ ... {"type": "video", "path": path/to/video},
+ ... {"type": "text", "text": "What is happening in this video?"},
+ ... ]
+ ... }
+ ... ]
+
+ >>> inputs = processor.apply_chat_template([messages], add_generation_prompt=True)
+
+ >>> # Generate
+ >>> generated_ids = model.generate(**inputs, max_new_tokens=256)
+ >>> generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
+
+ >>> print(generated_texts)
+ ```"""
+ super().forward(**super_kwargs)
+
+
+__all__ = [
+ "SmolVLMVisionConfig",
+ "SmolVLMConfig",
+ "SmolVLMImageProcessor",
+ "SmolVLMImageProcessorPil",
+ "SmolVLMForConditionalGeneration",
+ "SmolVLMPreTrainedModel",
+ "SmolVLMModel",
+ "SmolVLMVisionTransformer",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/processing_smolvlm.py b/lib/python3.11/site-packages/transformers/models/smolvlm/processing_smolvlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..0107ae31cbfe7ae81c16adf42ed1b7745f03d9e9
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smolvlm/processing_smolvlm.py
@@ -0,0 +1,353 @@
+# Copyright 2025 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.
+"""
+Processor class for SmolVLM.
+"""
+
+from datetime import timedelta
+from typing import TYPE_CHECKING, Union
+
+from ...feature_extraction_utils import BatchFeature
+from ...image_utils import ImageInput, make_nested_list_of_images
+from ...processing_utils import ProcessingKwargs, ProcessorMixin, Unpack
+from ...tokenization_utils_base import BatchEncoding, TextInput
+from ...utils import auto_docstring, is_num2words_available, logging
+from ...video_utils import VideoInput
+
+
+# Adapted from transformers.models.smolvlm.video_processing_smolvlm.DEFAULT_VIDEO_INTRO
+DEFAULT_VIDEO_INTRO = (
+ "You are provided the following series of {frame_count} frames from a {video_duration} [H:MM:SS] video.\n"
+)
+# Adapted from transformers.models.smolvlm.video_processing_smolvlm.DEFAULT_MEDIA_OUTTRO
+DEFAULT_MEDIA_OUTTRO = "\n\n"
+# Adapted from transformers.models.smolvlm.video_processing_smolvlm.FRAME_TIMESTAMP_MESSAGE
+FRAME_TIMESTAMP_MESSAGE = "\nFrame from {timestamp}:"
+
+if TYPE_CHECKING:
+ from ...tokenization_utils_base import PreTokenizedInput
+
+logger = logging.get_logger(__name__)
+
+
+if is_num2words_available():
+ from num2words import num2words
+else:
+ num2words = None
+
+
+# The correct chat template to be used for videos after #38105
+DEFAULT_CHAT_TEMPLATE = "<|im_start|>{% for message in messages %}{{message['role'] | capitalize}}{% if message['content'][0]['type'] == 'image' %}{{':'}}{% else %}{{': '}}{% endif %}{% for line in message['content'] %}{% if line['type'] == 'text' %}{{line['text']}}{% elif line['type'] == 'image' %}{{ '<image>' }}{% elif line['type'] == 'video' %}{{ '<video>' }}{% endif %}{% endfor %}<end_of_utterance>\n{% endfor %}{% if add_generation_prompt %}{{ 'Assistant:' }}{% endif %}"
+
+
+def _prompt_split_image(
+ image_seq_len, image_rows, image_cols, fake_token_around_image, image_token, global_image_token
+):
+ """Prompt with expanded image tokens for when the image is split into patches."""
+ text_split_images = ""
+ for n_h in range(image_rows):
+ for n_w in range(image_cols):
+ text_split_images += (
+ f"{fake_token_around_image}" + f"<row_{n_h + 1}_col_{n_w + 1}>" + f"{image_token}" * image_seq_len
+ )
+ text_split_images += "\n"
+
+ text_split_images += (
+ f"\n{fake_token_around_image}"
+ + f"{global_image_token}"
+ + f"{image_token}" * image_seq_len
+ + f"{fake_token_around_image}"
+ )
+ return text_split_images
+
+
+def _prompt_single_image(image_seq_len, fake_token_around_image, image_token, global_image_token):
+ """Prompt with expanded image tokens for a single image."""
+ return (
+ f"{fake_token_around_image}"
+ + f"{global_image_token}"
+ + f"{image_token}" * image_seq_len
+ + f"{fake_token_around_image}"
+ )
+
+
+def get_image_prompt_string(
+ image_rows, image_cols, image_seq_len, fake_token_around_image, image_token, global_image_token
+):
+ if image_rows == 0 and image_cols == 0:
+ return _prompt_single_image(
+ image_seq_len,
+ fake_token_around_image=fake_token_around_image,
+ image_token=image_token,
+ global_image_token=global_image_token,
+ )
+ return _prompt_split_image(
+ image_seq_len, image_rows, image_cols, fake_token_around_image, image_token, global_image_token
+ )
+
+
+class SmolVLMProcessorKwargs(ProcessingKwargs, total=False):
+ _defaults = {
+ "text_kwargs": {
+ "add_special_tokens": True,
+ "padding": False,
+ "is_split_into_words": False,
+ },
+ "images_kwargs": {
+ "return_row_col_info": True,
+ },
+ "videos_kwargs": {
+ "return_metadata": True,
+ },
+ }
+
+
+@auto_docstring
+class SmolVLMProcessor(ProcessorMixin):
+ def __init__(
+ self,
+ image_processor,
+ tokenizer,
+ video_processor,
+ image_seq_len: int = 169,
+ chat_template: str | None = None,
+ **kwargs,
+ ):
+ r"""
+ image_seq_len (`int`, *optional*, defaults to 169):
+ The length of the image sequence i.e. the number of <image> tokens per image in the input.
+ This parameter is used to build the string from the input prompt and image tokens and should match the
+ value the model used. It is computed as: image_seq_len = int(((image_size // patch_size) ** 2) / (scale_factor**2))
+ """
+ self.fake_image_token = getattr(tokenizer, "fake_image_token", "<fake_token_around_image>")
+ self.image_token = getattr(tokenizer, "image_token", "<image>")
+ self.image_token_id = tokenizer.convert_tokens_to_ids(self.image_token)
+ self.end_of_utterance_token = getattr(tokenizer, "end_of_utterance_token", "<end_of_utterance>")
+ self.global_image_token = getattr(tokenizer, "global_image_token", "<global-img>")
+ self.image_seq_len = image_seq_len
+ self.video_token = getattr(tokenizer, "video_token", "<video>")
+
+ if not num2words:
+ raise ImportError(
+ "Package `num2words` is required to run SmolVLM processor. Install it with `pip install num2words`."
+ )
+
+ super().__init__(image_processor, tokenizer, video_processor, chat_template=chat_template, **kwargs)
+
+ def expand_text_with_image_tokens(self, text, image_rows, image_cols):
+ prompt_strings = []
+ for sample, sample_rows, sample_cols in zip(text, image_rows, image_cols):
+ # Replace the image token with fake tokens around the expanded image token sequence of length `image_seq_len`
+ image_prompt_strings = []
+ for n_rows, n_cols in zip(sample_rows, sample_cols):
+ image_prompt_string = get_image_prompt_string(
+ n_rows,
+ n_cols,
+ self.image_seq_len,
+ image_token=self.image_token,
+ fake_token_around_image=self.fake_image_token,
+ global_image_token=self.global_image_token,
+ )
+ image_prompt_strings.append(image_prompt_string)
+
+ split_sample = sample.split(self.image_token)
+ if len(split_sample) == 0:
+ raise ValueError("The image token should be present in the text.")
+
+ # Place in the image prompt strings where the image tokens are
+ sample = split_sample[0]
+ for i, image_prompt_string in enumerate(image_prompt_strings):
+ sample += image_prompt_string + split_sample[i + 1]
+ prompt_strings.append(sample)
+
+ return prompt_strings
+
+ def expand_text_with_video_tokens(self, text, video_inputs):
+ num_frames = video_inputs["pixel_values"].shape[1]
+ video_metadata = iter(video_inputs["video_metadata"])
+
+ prompt_strings = []
+ for sample in text:
+ while self.video_token in sample:
+ metadata = next(video_metadata)
+ if metadata.fps is None:
+ logger.warning_once(
+ "SmolVLM requires frame timestamps to construct prompts, but the `fps` of the input video could not be inferred. "
+ "Probably `video_metadata` was missing from inputs and you passed pre-sampled frames. "
+ "Defaulting to `fps=24`. Please provide `video_metadata` for more accurate results."
+ )
+ metadata.fps = 24 # Set the default fps to 24 for BC, otherwise `timestamps` can't be inferred
+ timestamps = [(int(second // 60), int(second % 60)) for second in metadata.timestamps]
+ duration = int(metadata.duration) if metadata.duration is not None else int(metadata.timestamps[-1])
+ duration_td = timedelta(seconds=int(duration))
+ image_prompt_strings = DEFAULT_VIDEO_INTRO.format(
+ frame_count=num2words(num_frames), video_duration=str(duration_td)
+ )
+ for timestamp in timestamps:
+ image_prompt_string = _prompt_single_image(
+ self.image_seq_len,
+ image_token=self.image_token,
+ fake_token_around_image=self.fake_image_token,
+ global_image_token=self.global_image_token,
+ )
+ timestamp = f"{timestamp[0]:02d}:{timestamp[1]:02d}"
+ image_prompt_string = FRAME_TIMESTAMP_MESSAGE.format(timestamp=timestamp) + image_prompt_string
+ image_prompt_strings += image_prompt_string
+
+ image_prompt_strings += DEFAULT_MEDIA_OUTTRO
+ sample = sample.replace(self.video_token, image_prompt_strings, 1)
+ prompt_strings.append(sample)
+ return prompt_strings
+
+ @auto_docstring
+ def __call__(
+ self,
+ images: ImageInput | list[ImageInput] | list[list[ImageInput]] = None,
+ text: Union[TextInput, "PreTokenizedInput", list[TextInput], list["PreTokenizedInput"]] = None,
+ videos: VideoInput | None = None,
+ **kwargs: Unpack[SmolVLMProcessorKwargs],
+ ) -> BatchEncoding:
+ if text is None and images is None and videos is None:
+ raise ValueError("You must provide one of `text`, `images` or `videos'.")
+
+ if text is None and ((images is None) ^ (videos is not None)):
+ raise ValueError("You must specify exactly one of `images` or `videos`")
+
+ output_kwargs = self._merge_kwargs(
+ SmolVLMProcessorKwargs,
+ tokenizer_init_kwargs=self.tokenizer.init_kwargs,
+ **kwargs,
+ )
+
+ if text is not None:
+ if isinstance(text, str):
+ text = [text]
+ elif not isinstance(text, list) and not isinstance(text[0], str):
+ raise ValueError("Invalid input text. Please provide a string, or a list of strings")
+ n_images_in_text = sum(sample.count(self.image_token) for sample in text)
+ if n_images_in_text > 0 and (images is None and videos is None):
+ raise ValueError(f"We detected {n_images_in_text} tokens in the text but no images/videos were passed")
+
+ inputs = {}
+ # Images and videos are mutually exclusive, so process one which is present
+ if images is not None:
+ images = self.image_processor.fetch_images(images)
+ images = make_nested_list_of_images(images)
+ vision_inputs = self.image_processor(images, **output_kwargs["images_kwargs"])
+
+ image_rows = vision_inputs.pop("rows", None)
+ image_cols = vision_inputs.pop("cols", None)
+ inputs.update(vision_inputs)
+
+ if text is not None:
+ n_images_in_text = [sample.count(self.image_token) for sample in text]
+ n_images_in_images = [len(sublist) for sublist in images]
+ if n_images_in_images != n_images_in_text:
+ raise ValueError(
+ f"The number of images in the text {n_images_in_text} and images {n_images_in_images} should be the same."
+ )
+ # Set default values for image_rows and image_cols if not provided
+ if image_rows is None:
+ image_rows = [[0] * n_images for n_images in n_images_in_text]
+ if image_cols is None:
+ image_cols = [[0] * n_images for n_images in n_images_in_text]
+ text = self.expand_text_with_image_tokens(text, image_rows=image_rows, image_cols=image_cols)
+
+ elif videos is not None:
+ vision_inputs = self.video_processor(videos, **output_kwargs["videos_kwargs"])
+ if text is not None:
+ n_videos_in_text = [sample.count(self.video_token) for sample in text]
+ n_videos_in_videos = [len(sublist) for sublist in videos]
+ if n_videos_in_videos != n_videos_in_text:
+ raise ValueError(
+ f"The number of videos in the text {n_videos_in_text} and videos {n_videos_in_videos} should be the same."
+ )
+ text = self.expand_text_with_video_tokens(text, vision_inputs)
+
+ # If user has not requested video metadata, pop it. By default metadata
+ # is always returned to expand video tokens correctly
+ if not kwargs.get("return_metadata"):
+ vision_inputs.pop("video_metadata")
+ inputs.update(vision_inputs)
+
+ return_tensors = output_kwargs["text_kwargs"].pop("return_tensors", None)
+
+ if text is not None:
+ text_inputs = self.tokenizer(text, **output_kwargs["text_kwargs"])
+ self._check_special_mm_tokens(text, text_inputs, modalities=["image"])
+ inputs.update(text_inputs)
+
+ return BatchFeature(inputs, tensor_type=return_tensors)
+
+ def apply_chat_template(
+ self,
+ conversation: list[dict[str, str]] | list[list[dict[str, str]]],
+ chat_template: str | None = None,
+ processor_kwargs: dict | None = None,
+ **kwargs,
+ ) -> str:
+ """
+ Similar to the `apply_chat_template` method on tokenizers, this method applies a Jinja template to input
+ conversations to turn them into a single tokenizable string.
+
+ The input is expected to be in the following format, where each message content is a list consisting of text and
+ optionally image or video inputs. One can also provide an image, video, URL or local path which will be used to form
+ `pixel_values` when `return_dict=True`. If not provided, one will get only the formatted text, optionally tokenized text.
+
+ conversation = [
+ {
+ "role": "user",
+ "content": [
+ {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"},
+ {"type": "text", "text": "Please describe this image in detail."},
+ ],
+ },
+ ]
+
+ Args:
+ conversation (`Union[list[Dict, [str, str]], list[list[dict[str, str]]]]`):
+ The conversation to format.
+ chat_template (`Optional[str]`, *optional*):
+ The Jinja template to use for formatting the conversation. If not provided, the tokenizer's
+ chat template is used.
+ """
+ if isinstance(conversation, (list, tuple)) and (
+ isinstance(conversation[0], (list, tuple)) or hasattr(conversation[0], "content")
+ ):
+ conversations = conversation
+ else:
+ conversations = [conversation]
+
+ has_video = any(
+ (isinstance(content, dict) and content["type"] == "video")
+ for conversation in conversations
+ for message in conversation
+ for content in (message.get("content") or [])
+ )
+ if chat_template is None and has_video:
+ # re-assign to the correct default template for BC, if user is not requesting their own template
+ chat_template = DEFAULT_CHAT_TEMPLATE
+
+ # Users might be passing processor kwargs simply as `**kwargs`
+ if processor_kwargs:
+ processor_kwargs.setdefault("num_frames", self.video_processor.num_frames)
+ processor_kwargs.setdefault("fps", self.video_processor.fps)
+ else:
+ kwargs.setdefault("num_frames", self.video_processor.num_frames)
+ kwargs.setdefault("fps", self.video_processor.fps)
+
+ return super().apply_chat_template(conversation, chat_template, processor_kwargs=processor_kwargs, **kwargs)
+
+
+__all__ = ["SmolVLMProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/smolvlm/video_processing_smolvlm.py b/lib/python3.11/site-packages/transformers/models/smolvlm/video_processing_smolvlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..76fd97f859edf8e1e007c03bb4b9166f0e090894
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/smolvlm/video_processing_smolvlm.py
@@ -0,0 +1,344 @@
+# Copyright 2025 The HuggingFace Inc. 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 numpy as np
+import torch
+
+from ...image_processing_utils import BatchFeature, get_size_dict
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ PILImageResampling,
+ SizeDict,
+)
+from ...processing_utils import Unpack, VideosKwargs
+from ...utils import TensorType, is_torchvision_available, logging
+from ...video_processing_utils import BaseVideoProcessor
+from ...video_utils import VideoMetadata, group_videos_by_shape, reorder_videos
+
+
+if is_torchvision_available():
+ from torchvision.transforms.v2 import functional as tvF
+
+
+logger = logging.get_logger(__name__)
+
+DEFAULT_SYSTEM_MESSAGE = "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language."
+DEFAULT_VIDEO_INTRO = (
+ "You are provided the following series of {frame_count} frames from a {video_duration} [H:MM:SS] video.\n"
+)
+DEFAULT_MEDIA_OUTTRO = "\n\n"
+FRAME_TIMESTAMP_MESSAGE = "\nFrame from {timestamp}:"
+MAX_IMAGE_SIZE = 4096 # 4k resolution as absolute maximum
+
+
+def get_max_height_width(videos: list["torch.Tensor"]) -> list[int]:
+ """
+ Get the maximum height and width across all videos in a batch.
+ """
+ max_height = max_width = float("-inf")
+ for video in videos:
+ height, width = video.size()[-2:]
+ max_height = max(height, max_height)
+ max_width = max(width, max_width)
+ return (max_height, max_width)
+
+
+def get_resize_output_image_size(
+ video,
+ resolution_max_side: int,
+) -> tuple[int, int]:
+ """
+ Get the output size of the video after resizing given a dictionary specifying the max and min sizes.
+ Args:
+ video (`np.ndarray`):
+ Video to resize.
+ resolution_max_side (`int`):
+ The longest edge of the video will be resized to this value. The shortest edge will be resized to keep the
+ input aspect ratio.
+ Returns:
+ The output size of the video after resizing.
+ """
+ height, width = video.size()[-2:]
+
+ # Find the output size, when rescaling the longest edge to max_len and preserving the aspect ratio
+ # The output size must be below the MAX_IMAGE_SIZE
+ resolution_max_side = min(MAX_IMAGE_SIZE, resolution_max_side)
+ resolution_max_side = max(height, width) if resolution_max_side is None else resolution_max_side
+ aspect_ratio = width / height
+
+ if width >= height:
+ width = resolution_max_side
+ height = int(width / aspect_ratio)
+ if height % 2 != 0:
+ height += 1
+ elif height > width:
+ height = resolution_max_side
+ width = int(height * aspect_ratio)
+ if width % 2 != 0:
+ width += 1
+
+ height = max(height, 1)
+ width = max(width, 1)
+
+ return height, width
+
+
+class SmolVLMVideoProcessorInitKwargs(VideosKwargs, total=False):
+ max_image_size: dict[str, int]
+
+
+class SmolVLMVideoProcessor(BaseVideoProcessor):
+ resample = PILImageResampling.LANCZOS
+ size = {"longest_edge": 4 * 364}
+ max_image_size = {"longest_edge": 364}
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ do_convert_rgb = True
+ do_pad = True
+ do_sample_frames = False # Set to False for BC, recommended to set `True` in new models
+ valid_kwargs = SmolVLMVideoProcessorInitKwargs
+ model_input_names = ["pixel_values", "pixel_attention_mask"]
+
+ def __init__(self, **kwargs: Unpack[SmolVLMVideoProcessorInitKwargs]):
+ super().__init__(**kwargs)
+ # For BC pop values from `config.video_sampling`. In official config `video_sampling` is guaranteed to be present
+ # We check for `Noneness` only for certain tests such as `test_init_without_params`
+ if "size" in kwargs and "video_sampling" in kwargs:
+ kwargs["video_sampling"]["video_size"] = kwargs["size"]
+
+ if "video_sampling" in kwargs:
+ self.num_frames = kwargs["video_sampling"]["max_frames"]
+ self.fps = kwargs["video_sampling"]["fps"]
+ self.size = get_size_dict(kwargs["video_sampling"]["video_size"], default_to_square=self.default_to_square)
+
+ def resize(
+ self,
+ video: "torch.Tensor",
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None" = None,
+ antialias: bool = True,
+ **kwargs,
+ ) -> "torch.Tensor":
+ """
+ Resize an video to `(size["height"], size["width"])`.
+ Args:
+ video (`torch.Tensor`):
+ Video to resize.
+ size (`SizeDict`):
+ Dictionary in the format `{"height": int, "width": int}` specifying the size of the output video.
+ resample (`PILImageResampling` or `InterpolationMode`, *optional*, defaults to `InterpolationMode.BILINEAR`):
+ Resampling filter to use when resizing the video.
+ Returns:
+ `torch.Tensor`: The resized video.
+ """
+ if size.longest_edge:
+ # Resize the image so that the shortest edge or the longest edge is of the given size
+ # while maintaining the aspect ratio of the original image.
+ new_size = get_resize_output_image_size(
+ video,
+ resolution_max_side=size.longest_edge,
+ )
+ elif size.height and size.width:
+ new_size = (size.height, size.width)
+ else:
+ raise ValueError(f"Size must contain 'height' and 'width' keys, or 'longest_edge' key. Got {size}.")
+
+ video = super().resize(
+ video, SizeDict(height=new_size[0], width=new_size[1]), resample=resample, antialias=antialias
+ )
+
+ # Resize again to match image processor when `do_image_splitting=False`. Frames have to be squared to `max_image_size`
+ # NOTE: videos are always processed without image splitting
+ max_size = SizeDict(height=self.max_image_size["longest_edge"], width=self.max_image_size["longest_edge"])
+ video = super().resize(video, max_size, resample=resample, antialias=antialias)
+ return video
+
+ def pad(
+ self,
+ video: "torch.Tensor",
+ padded_size: tuple[int, int],
+ max_num_frames: int,
+ fill: int = 0,
+ return_pixel_mask: bool = True,
+ ):
+ """Pads the sample with empty video to the padded_size
+ Args:
+ video (`torch.Tensor`):
+ Video to pad.
+ padded_size (`tuple[int, int]`):
+ Height and width to pad.
+ max_num_frames (`int`):
+ The maximum number of frames to which video will be padded.
+ fill (`int`, *optional*):
+ The value to use for the padding.
+ return_pixel_mask (`bool`, *optional*, defaults to `True`):
+ Whether to return a pixel mask.
+ """
+ original_size = video.size()[-2:]
+ padding_height = padded_size[0] - original_size[0]
+ padding_width = padded_size[1] - original_size[1]
+ padding_frame = max_num_frames - video.shape[0]
+ if padding_width < 0 or padding_height < 0:
+ raise ValueError(
+ f"Padding dimensions are negative. Please make sure that the padded size is larger than the "
+ f"original size. Got padded size: {padded_size}, original size: {original_size}."
+ )
+ if original_size != padded_size:
+ padding = [0, padding_width, 0, padding_height, 0, 0, 0, padding_frame]
+ video = tvF.pad(video, padding, fill=fill)
+
+ # Make a pixel mask for the video, where 1 indicates a valid pixel and 0 indicates padding.
+ # Mask shape is (num_frames, height, width) so we omit the channel dim
+ pixel_mask = None
+ if return_pixel_mask:
+ pixel_mask = torch.zeros_like(video[..., 0, :, :], dtype=torch.int64)
+ pixel_mask[..., : original_size[0], : original_size[1]] = 1
+
+ return video, pixel_mask
+
+ def sample_frames(
+ self,
+ metadata: VideoMetadata,
+ num_frames: int | None = None,
+ fps: int | float | None = None,
+ skip_secs: int | None = 1,
+ **kwargs,
+ ):
+ """
+ Video sampling function which:
+ - Uses `num_frames` (if provided) or calculates it from `fps` and metadata.
+ - Applies a basic center-skip if fewer frames than available, otherwise
+ optionally skips `skip_secs` from both the start and end.
+ - Uniformly samples the desired number of frames between the start and end indices.
+
+ Args:
+ metadata (`VideoMetadata`):
+ Metadata of the video containing information about total duration, fps and total number of frames.
+ num_frames (`int`, *optional*):
+ Maximum number of frames to sample. Defaults to `self.num_frames`.
+ fps (`int` or `float`, *optional*):
+ Target frames to sample per second. Defaults to `self.fps`.
+ skip_secs (`float`, *optional*, defaults to `1`):
+ Number of seconds to skip from the start and end if the video is long enough.
+
+ Returns:
+ np.ndarray:
+ Indices to sample video frames.
+ """
+ if metadata is None or getattr(metadata, "fps", None) is None:
+ raise ValueError(
+ "Asked to sample frames per second but no video metadata was provided which is required when sampling in SmolVLM. "
+ "Please pass in `VideoMetadata` object or set `do_sample_frames=False`"
+ )
+
+ num_frames = num_frames if num_frames is not None else self.num_frames
+ fps = fps if fps is not None else self.fps
+ total_num_frames = metadata.total_num_frames
+
+ # Step 1) Estimate how many frames we'd sample at `target_fps`, fallback if target_fps <= 0
+ estimated_frames = int(round(fps * metadata["duration"]))
+
+ # Step 2) desired_frames
+ desired_frames = min(estimated_frames, num_frames)
+ if desired_frames < 1:
+ desired_frames = 1
+
+ # Step 3) center skip logic
+ start_idx = 0
+ end_idx = total_num_frames - 1
+
+ if skip_secs > 0 and (metadata["duration"] - 2 * skip_secs) > (num_frames * fps):
+ start_idx = int(skip_secs * metadata["fps"])
+ end_idx = int(total_num_frames - skip_secs * metadata["fps"])
+
+ start_idx = max(0, start_idx)
+ end_idx = min(end_idx, total_num_frames - 1)
+ if start_idx >= end_idx:
+ start_idx, end_idx = 0, total_num_frames - 1
+
+ indices = np.linspace(start_idx, end_idx, desired_frames, dtype=int)
+ indices = np.unique(indices)
+
+ return indices
+
+ def _preprocess(
+ self,
+ videos: list["torch.Tensor"],
+ do_convert_rgb: bool,
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ do_pad: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ return_tensors: str | TensorType | None = None,
+ **kwargs,
+ ):
+ grouped_videos, grouped_videos_index = group_videos_by_shape(videos)
+ resized_videos_grouped = {}
+ for shape, stacked_videos in grouped_videos.items():
+ if do_convert_rgb:
+ stacked_videos = self.convert_to_rgb(stacked_videos)
+ if do_resize:
+ stacked_videos = self.resize(stacked_videos, size=size, resample=resample)
+ resized_videos_grouped[shape] = stacked_videos
+ resized_videos = reorder_videos(resized_videos_grouped, grouped_videos_index)
+
+ grouped_videos, grouped_videos_index = group_videos_by_shape(resized_videos)
+ processed_videos_grouped = {}
+ for shape, stacked_videos in grouped_videos.items():
+ stacked_videos = self.rescale_and_normalize(
+ stacked_videos, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ processed_videos_grouped[shape] = stacked_videos
+
+ processed_videos = reorder_videos(processed_videos_grouped, grouped_videos_index)
+
+ if do_pad:
+ pad_size = get_max_height_width(processed_videos)
+ max_num_frames = max(len(video) for video in processed_videos)
+ grouped_videos, grouped_videos_index = group_videos_by_shape(processed_videos)
+ processed_padded_mask_grouped = {}
+ processed_videos_grouped = {}
+
+ for shape, stacked_videos in grouped_videos.items():
+ stacked_videos, padded_masks = self.pad(
+ stacked_videos, padded_size=pad_size, max_num_frames=max_num_frames
+ )
+ processed_videos_grouped[shape] = stacked_videos
+ processed_padded_mask_grouped[shape] = padded_masks
+
+ processed_videos = reorder_videos(processed_videos_grouped, grouped_videos_index)
+ pixel_attention_mask = reorder_videos(processed_padded_mask_grouped, grouped_videos_index)
+
+ data = {"pixel_values": processed_videos}
+
+ if do_pad:
+ data["pixel_attention_mask"] = (
+ torch.stack(pixel_attention_mask, dim=0)
+ if do_pad and return_tensors is not None
+ else pixel_attention_mask
+ )
+ return BatchFeature(data, tensor_type=return_tensors)
+
+
+__all__ = ["SmolVLMVideoProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/solar_open/__init__.py b/lib/python3.11/site-packages/transformers/models/solar_open/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..52ca7575697a58c9ed27fef2b214a70380d4a7cb
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/solar_open/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2026 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_solar_open import *
+ from .modeling_solar_open import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7bb26175e2284c972f6299da09c53d21ef378b24
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/configuration_solar_open.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/configuration_solar_open.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e76fc51a1c092768b6c674466e4a92506a3a9a3a
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/configuration_solar_open.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/modeling_solar_open.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/modeling_solar_open.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e3662d071c5f9f3a6d07721b3c396e783673bd5
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/modeling_solar_open.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/modular_solar_open.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/modular_solar_open.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3d538e1b7b6ec02b961bd88881719f93a8df169
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/solar_open/__pycache__/modular_solar_open.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/solar_open/configuration_solar_open.py b/lib/python3.11/site-packages/transformers/models/solar_open/configuration_solar_open.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac0016aa77910ea448db537a3a1c076c5f27406c
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/solar_open/configuration_solar_open.py
@@ -0,0 +1,92 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/solar_open/modular_solar_open.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_solar_open.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 Upstage and 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.
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...modeling_rope_utils import RopeParameters
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="upstage/Solar-Open-100B")
+@strict
+class SolarOpenConfig(PreTrainedConfig):
+ r"""
+ n_group (`int`, *optional*, defaults to 1):
+ Number of groups for routed experts.
+ """
+
+ model_type = "solar_open"
+ keys_to_ignore_at_inference = ["past_key_values"]
+
+ # Default tensor parallel plan for base model `SolarOpenModel`
+ base_model_tp_plan = {
+ "layers.*.self_attn.q_proj": "colwise",
+ "layers.*.self_attn.k_proj": "colwise",
+ "layers.*.self_attn.v_proj": "colwise",
+ "layers.*.self_attn.o_proj": "rowwise",
+ "layers.*.mlp.experts.gate_up_proj": "packed_colwise",
+ "layers.*.mlp.experts.down_proj": "rowwise",
+ "layers.*.mlp.experts": "moe_tp_experts",
+ }
+ base_model_pp_plan = {
+ "embed_tokens": (["input_ids"], ["inputs_embeds"]),
+ "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
+ "norm": (["hidden_states"], ["hidden_states"]),
+ }
+ attribute_map = {
+ "num_local_experts": "n_routed_experts",
+ }
+
+ vocab_size: int = 196608
+ hidden_size: int = 4096
+ num_hidden_layers: int = 48
+ num_attention_heads: int = 64
+ num_key_value_heads: int = 8
+ hidden_act: str = "silu"
+ max_position_embeddings: int = 131072
+ initializer_range: float = 0.02
+ rms_norm_eps: float = 1e-5
+ use_cache: bool = True
+ tie_word_embeddings: bool = False
+ rope_parameters: RopeParameters | dict | None = None
+ attention_bias: bool = False
+ attention_dropout: float | int = 0.0
+ moe_intermediate_size: int = 1280
+ num_experts_per_tok: int = 8
+ n_shared_experts: int = 1
+ n_routed_experts: int = 128
+ routed_scaling_factor: float = 1.0
+ n_group: int = 1
+ topk_group: int = 1
+ norm_topk_prob: bool = True
+ bos_token_id: int | None = None
+ eos_token_id: int | list[int] | None = None
+ pad_token_id: int | None = None
+ default_theta = 1_000_000.0
+ head_dim: int = 128
+
+ def __post_init__(self, **kwargs):
+ kwargs.setdefault("partial_rotary_factor", 1.0)
+ kwargs.setdefault("partial_rotary_factor", 0.5) # assign default for BC
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["SolarOpenConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/solar_open/modeling_solar_open.py b/lib/python3.11/site-packages/transformers/models/solar_open/modeling_solar_open.py
new file mode 100644
index 0000000000000000000000000000000000000000..0eb50021ecd63a9a515c67d65728f13a4eb07eac
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/solar_open/modeling_solar_open.py
@@ -0,0 +1,626 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/solar_open/modular_solar_open.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_solar_open.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 Upstage and 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.
+from collections.abc import Callable
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache
+from ...generation import GenerationMixin
+from ...integrations import (
+ use_experts_implementation,
+ use_kernel_forward_from_hub,
+ use_kernel_func_from_hub,
+ use_kernelized_func,
+)
+from ...masking_utils import create_causal_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
+from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ...utils.generic import maybe_autocast, merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_solar_open import SolarOpenConfig
+
+
+class SolarOpenDecoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: SolarOpenConfig, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+
+ self.self_attn = SolarOpenAttention(config=config, layer_idx=layer_idx)
+ self.mlp = SolarOpenMoE(config)
+ self.input_layernorm = SolarOpenRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_attention_layernorm = SolarOpenRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = False,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ residual = hidden_states
+ hidden_states = self.input_layernorm(hidden_states)
+ # Self Attention
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ position_embeddings=position_embeddings,
+ **kwargs,
+ )
+ hidden_states = residual + hidden_states
+
+ # Fully Connected
+ residual = hidden_states
+ hidden_states = self.post_attention_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = residual + hidden_states
+ return hidden_states
+
+
+class SolarOpenMLP(nn.Module):
+ def __init__(self, config, intermediate_size=None):
+ super().__init__()
+ self.config = config
+ self.hidden_size = config.hidden_size
+ self.intermediate_size = config.intermediate_size if intermediate_size is None else intermediate_size
+ self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+ self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+ self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
+ self.act_fn = ACT2FN[config.hidden_act]
+
+ def forward(self, x):
+ down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+ return down_proj
+
+
+class SolarOpenTopkRouter(nn.Module):
+ def __init__(self, config: SolarOpenConfig):
+ super().__init__()
+ self.config = config
+ self.top_k = config.num_experts_per_tok
+ self.n_routed_experts = config.n_routed_experts
+ self.routed_scaling_factor = config.routed_scaling_factor
+ self.n_group = config.n_group
+ self.topk_group = config.topk_group
+ self.norm_topk_prob = config.norm_topk_prob
+
+ self.weight = nn.Parameter(torch.empty((self.n_routed_experts, config.hidden_size)))
+ self.register_buffer("e_score_correction_bias", torch.zeros((self.n_routed_experts), dtype=torch.float32))
+
+ def forward(self, hidden_states):
+ hidden_states = hidden_states.view(-1, self.config.hidden_size)
+ router_logits = F.linear(hidden_states.type(torch.float32), self.weight.type(torch.float32))
+ return router_logits
+
+
+@use_experts_implementation
+class SolarOpenNaiveMoe(nn.Module):
+ """Collection of expert weights stored as 3D tensors."""
+
+ def __init__(self, config):
+ super().__init__()
+ self.num_experts = config.num_local_experts
+ self.hidden_dim = config.hidden_size
+ self.intermediate_dim = config.moe_intermediate_size
+ self.gate_up_proj = nn.Parameter(torch.empty(self.num_experts, 2 * self.intermediate_dim, self.hidden_dim))
+ self.down_proj = nn.Parameter(torch.empty(self.num_experts, self.hidden_dim, self.intermediate_dim))
+ self.act_fn = ACT2FN[config.hidden_act]
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ top_k_index: torch.Tensor,
+ top_k_weights: torch.Tensor,
+ ) -> torch.Tensor:
+ final_hidden_states = torch.zeros_like(hidden_states)
+ with torch.no_grad():
+ expert_mask = torch.nn.functional.one_hot(top_k_index, num_classes=self.num_experts)
+ expert_mask = expert_mask.permute(2, 1, 0)
+ expert_hit = torch.greater(expert_mask.sum(dim=(-1, -2)), 0).nonzero()
+
+ for expert_idx in expert_hit:
+ expert_idx = expert_idx[0]
+ if expert_idx == self.num_experts:
+ continue
+ top_k_pos, token_idx = torch.where(expert_mask[expert_idx])
+ current_state = hidden_states[token_idx]
+ gate, up = nn.functional.linear(current_state, self.gate_up_proj[expert_idx]).chunk(2, dim=-1)
+ current_hidden_states = self.act_fn(gate) * up
+ current_hidden_states = nn.functional.linear(current_hidden_states, self.down_proj[expert_idx])
+ current_hidden_states = current_hidden_states * top_k_weights[token_idx, top_k_pos, None]
+ final_hidden_states.index_add_(0, token_idx, current_hidden_states.to(final_hidden_states.dtype))
+
+ return final_hidden_states
+
+
+class SolarOpenMoE(nn.Module):
+ """
+ A mixed expert module containing shared experts.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.experts = SolarOpenNaiveMoe(config)
+ self.gate = SolarOpenTopkRouter(config)
+ self.shared_experts = SolarOpenMLP(
+ config=config, intermediate_size=config.moe_intermediate_size * config.n_shared_experts
+ )
+ self.n_routed_experts = config.n_routed_experts
+ self.n_group = config.n_group
+ self.topk_group = config.topk_group
+ self.norm_topk_prob = config.norm_topk_prob
+ self.routed_scaling_factor = config.routed_scaling_factor
+ self.top_k = config.num_experts_per_tok
+
+ def route_tokens_to_experts(self, router_logits):
+ router_logits = router_logits.sigmoid()
+ router_logits_for_choice = router_logits + self.gate.e_score_correction_bias
+ group_scores = (
+ router_logits_for_choice.view(-1, self.n_group, self.n_routed_experts // self.n_group)
+ .topk(2, dim=-1)[0]
+ .sum(dim=-1)
+ )
+ group_idx = torch.topk(group_scores, k=self.topk_group, dim=-1, sorted=False)[1]
+ group_mask = torch.zeros_like(group_scores)
+ group_mask.scatter_(1, group_idx, 1)
+ score_mask = (
+ group_mask.unsqueeze(-1)
+ .expand(-1, self.n_group, self.n_routed_experts // self.n_group)
+ .reshape(-1, self.n_routed_experts)
+ )
+ scores_for_choice = router_logits_for_choice.masked_fill(~score_mask.bool(), float("-inf"))
+ topk_indices = torch.topk(scores_for_choice, k=self.top_k, dim=-1, sorted=False)[1]
+ topk_weights = router_logits.gather(1, topk_indices)
+ if self.norm_topk_prob:
+ denominator = topk_weights.sum(dim=-1, keepdim=True) + 1e-20
+ topk_weights /= denominator
+ topk_weights = topk_weights * self.routed_scaling_factor
+ return topk_indices, topk_weights
+
+ def forward(self, hidden_states):
+ residuals = hidden_states
+ orig_shape = hidden_states.shape
+ router_logits = self.gate(hidden_states)
+ topk_indices, topk_weights = self.route_tokens_to_experts(router_logits)
+ hidden_states = hidden_states.view(-1, hidden_states.shape[-1])
+ hidden_states = self.experts(hidden_states, topk_indices, topk_weights).view(*orig_shape)
+ hidden_states = hidden_states + self.shared_experts(residuals)
+ return hidden_states
+
+
+def rotate_half(x):
+ """Rotates half the hidden dims of the input."""
+ x1 = x[..., : x.shape[-1] // 2]
+ x2 = x[..., x.shape[-1] // 2 :]
+ return torch.cat((-x2, x1), dim=-1)
+
+
+@use_kernel_func_from_hub("rotary_pos_emb")
+def apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1):
+ """Applies Rotary Position Embedding to the query and key tensors.
+
+ Args:
+ q (`torch.Tensor`): The query tensor.
+ k (`torch.Tensor`): The key tensor.
+ cos (`torch.Tensor`): The cosine part of the rotary embedding.
+ sin (`torch.Tensor`): The sine part of the rotary embedding.
+ unsqueeze_dim (`int`, *optional*, defaults to 1):
+ The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+ sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+ that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+ k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+ cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+ the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+ Returns:
+ `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+ """
+ cos = cos.unsqueeze(unsqueeze_dim)
+ sin = sin.unsqueeze(unsqueeze_dim)
+ q_embed = (q * cos) + (rotate_half(q) * sin)
+ k_embed = (k * cos) + (rotate_half(k) * sin)
+ return q_embed, k_embed
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+ """
+ This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+ num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+ """
+ batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+ if n_rep == 1:
+ return hidden_states
+ hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+ return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float,
+ dropout: float = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ key_states = repeat_kv(key, module.num_key_value_groups)
+ value_states = repeat_kv(value, module.num_key_value_groups)
+
+ attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value_states)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+@use_kernelized_func(apply_rotary_pos_emb)
+class SolarOpenAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config: SolarOpenConfig, layer_idx: int):
+ super().__init__()
+ self.config = config
+ self.layer_idx = layer_idx
+ self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+ self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
+ self.scaling = self.head_dim**-0.5
+ self.attention_dropout = config.attention_dropout
+ self.is_causal = True
+
+ self.q_proj = nn.Linear(
+ config.hidden_size, config.num_attention_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.k_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.v_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.o_proj = nn.Linear(config.num_attention_heads * self.head_dim, config.hidden_size, bias=False)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ if past_key_values is not None:
+ key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ scaling=self.scaling,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+@use_kernel_forward_from_hub("RMSNorm")
+class SolarOpenRMSNorm(nn.Module):
+ def __init__(self, hidden_size, eps: float = 1e-6) -> None:
+ """
+ SolarOpenRMSNorm is equivalent to T5LayerNorm
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ input_dtype = hidden_states.dtype
+ hidden_states = hidden_states.to(torch.float32)
+ variance = hidden_states.pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+ return self.weight * hidden_states.to(input_dtype)
+
+ def extra_repr(self):
+ return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"
+
+
+@auto_docstring
+class SolarOpenPreTrainedModel(PreTrainedModel):
+ config: SolarOpenConfig
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["SolarOpenDecoderLayer"]
+ _skip_keys_device_placement = ["past_key_values"]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+
+ _can_compile_fullgraph = True
+ _supports_attention_backend = True
+ _can_record_outputs = {
+ "hidden_states": SolarOpenDecoderLayer,
+ "attentions": SolarOpenAttention,
+ }
+ _keep_in_fp32_modules_strict = ["e_score_correction_bias"]
+ _keys_to_ignore_on_load_unexpected = None
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, SolarOpenTopkRouter):
+ init.normal_(module.weight, mean=0.0, std=self.config.initializer_range)
+ init.zeros_(module.e_score_correction_bias)
+ elif isinstance(module, SolarOpenNaiveMoe):
+ init.normal_(module.gate_up_proj, mean=0.0, std=self.config.initializer_range)
+ init.normal_(module.down_proj, mean=0.0, std=self.config.initializer_range)
+
+
+class SolarOpenRotaryEmbedding(nn.Module):
+ inv_freq: torch.Tensor # fix linting for `register_buffer`
+
+ def __init__(self, config: SolarOpenConfig, device=None):
+ super().__init__()
+ self.max_seq_len_cached = config.max_position_embeddings
+ self.original_max_seq_len = config.max_position_embeddings
+
+ self.config = config
+
+ self.rope_type = self.config.rope_parameters["rope_type"]
+ rope_init_fn: Callable = self.compute_default_rope_parameters
+ if self.rope_type != "default":
+ rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
+ inv_freq, self.attention_scaling = rope_init_fn(self.config, device)
+
+ self.register_buffer("inv_freq", inv_freq, persistent=False)
+ self.register_buffer("original_inv_freq", inv_freq.clone(), persistent=False)
+
+ @staticmethod
+ def compute_default_rope_parameters(
+ config: SolarOpenConfig | None = None,
+ device: Optional["torch.device"] = None,
+ seq_len: int | None = None,
+ ) -> tuple["torch.Tensor", float]:
+ """
+ Computes the inverse frequencies according to the original RoPE implementation
+ Args:
+ config ([`~transformers.PreTrainedConfig`]):
+ The model configuration.
+ device (`torch.device`):
+ The device to use for initialization of the inverse frequencies.
+ seq_len (`int`, *optional*):
+ The current sequence length. Unused for this type of RoPE.
+ Returns:
+ Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
+ post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
+ """
+ base = config.rope_parameters["rope_theta"]
+ partial_rotary_factor = config.rope_parameters.get("partial_rotary_factor", 1.0)
+ head_dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
+ dim = int(head_dim * partial_rotary_factor)
+
+ attention_factor = 1.0 # Unused in this type of RoPE
+
+ # Compute the inverse frequencies
+ inv_freq = 1.0 / (
+ base ** (torch.arange(0, dim, 2, dtype=torch.int64).to(device=device, dtype=torch.float) / dim)
+ )
+ return inv_freq, attention_factor
+
+ @torch.no_grad()
+ @dynamic_rope_update # power user: used with advanced RoPE types (e.g. dynamic rope)
+ def forward(self, x, position_ids):
+ inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)
+ position_ids_expanded = position_ids[:, None, :].float()
+
+ device_type = x.device.type if isinstance(x.device.type, str) and x.device.type != "mps" else "cpu"
+ with maybe_autocast(device_type=device_type, enabled=False): # Force float32
+ freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2)
+ emb = torch.cat((freqs, freqs), dim=-1)
+ cos = emb.cos() * self.attention_scaling
+ sin = emb.sin() * self.attention_scaling
+
+ return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+@auto_docstring
+class SolarOpenModel(SolarOpenPreTrainedModel):
+ def __init__(self, config: SolarOpenConfig):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+ self.layers = nn.ModuleList(
+ [SolarOpenDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.norm = SolarOpenRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.rotary_emb = SolarOpenRotaryEmbedding(config=config)
+ self.gradient_checkpointing = False
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPast:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ if inputs_embeds is None:
+ inputs_embeds: torch.Tensor = self.embed_tokens(input_ids)
+
+ if use_cache and past_key_values is None:
+ past_key_values = DynamicCache(config=self.config)
+
+ if position_ids is None:
+ past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+ position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens
+ position_ids = position_ids.unsqueeze(0)
+
+ causal_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ position_ids=position_ids,
+ )
+
+ hidden_states = inputs_embeds
+ position_embeddings = self.rotary_emb(hidden_states, position_ids=position_ids)
+
+ for decoder_layer in self.layers[: self.config.num_hidden_layers]:
+ hidden_states = decoder_layer(
+ hidden_states,
+ attention_mask=causal_mask,
+ position_embeddings=position_embeddings,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = self.norm(hidden_states)
+ return BaseModelOutputWithPast(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class SolarOpenForCausalLM(SolarOpenPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}
+ _tp_plan = {"lm_head": "colwise_gather_output"}
+ _pp_plan = {"lm_head": (["hidden_states"], ["logits"])}
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.model = SolarOpenModel(config)
+ self.vocab_size = config.vocab_size
+ self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ logits_to_keep: int | torch.Tensor = 0,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> CausalLMOutputWithPast:
+ r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, SolarOpenForCausalLM
+
+ >>> model = SolarOpenForCausalLM.from_pretrained("meta-solar_open/SolarOpen-2-7b-hf")
+ >>> tokenizer = AutoTokenizer.from_pretrained("meta-solar_open/SolarOpen-2-7b-hf")
+
+ >>> prompt = "Hey, are you conscious? Can you talk to me?"
+ >>> inputs = tokenizer(prompt, return_tensors="pt")
+
+ >>> # Generate
+ >>> generate_ids = model.generate(inputs.input_ids, max_length=30)
+ >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+ "Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."
+ ```"""
+ outputs: BaseModelOutputWithPast = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = outputs.last_hidden_state
+ # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+ slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+ logits = self.lm_head(hidden_states[:, slice_indices, :])
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits=logits, labels=labels, vocab_size=self.config.vocab_size, **kwargs)
+
+ return CausalLMOutputWithPast(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = ["SolarOpenPreTrainedModel", "SolarOpenModel", "SolarOpenForCausalLM"]
diff --git a/lib/python3.11/site-packages/transformers/models/solar_open/modular_solar_open.py b/lib/python3.11/site-packages/transformers/models/solar_open/modular_solar_open.py
new file mode 100644
index 0000000000000000000000000000000000000000..90d4f0c389c086743e75cde217627ea839a001a5
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/solar_open/modular_solar_open.py
@@ -0,0 +1,108 @@
+# Copyright 2026 Upstage and 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.
+"""PyTorch SolarOpen model."""
+
+from huggingface_hub.dataclasses import strict
+from torch import nn
+
+from ...utils import auto_docstring, logging
+from ..glm4_moe.configuration_glm4_moe import Glm4MoeConfig
+from ..glm4_moe.modeling_glm4_moe import (
+ Glm4MoeForCausalLM,
+ Glm4MoeModel,
+ Glm4MoeMoE,
+ Glm4MoePreTrainedModel,
+ Glm4MoeRMSNorm,
+)
+from ..llama.modeling_llama import LlamaAttention, LlamaDecoderLayer
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="upstage/Solar-Open-100B")
+@strict
+class SolarOpenConfig(Glm4MoeConfig):
+ r"""
+ n_group (`int`, *optional*, defaults to 1):
+ Number of groups for routed experts.
+ """
+
+ model_type = "solar_open"
+ default_theta = 1_000_000.0
+
+ # Default tensor parallel plan for base model `SolarOpenModel`
+ base_model_tp_plan = {
+ "layers.*.self_attn.q_proj": "colwise",
+ "layers.*.self_attn.k_proj": "colwise",
+ "layers.*.self_attn.v_proj": "colwise",
+ "layers.*.self_attn.o_proj": "rowwise",
+ "layers.*.mlp.experts.gate_up_proj": "packed_colwise",
+ "layers.*.mlp.experts.down_proj": "rowwise",
+ "layers.*.mlp.experts": "moe_tp_experts",
+ }
+
+ vocab_size: int = 196608
+ moe_intermediate_size: int = 1280
+ num_hidden_layers: int = 48
+ num_attention_heads: int = 64
+ head_dim: int = 128
+ num_experts_per_tok: int = 8
+ intermediate_size = AttributeError()
+ first_k_dense_replace = AttributeError()
+ use_qk_norm = AttributeError()
+
+ def __post_init__(self, **kwargs):
+ kwargs.setdefault("partial_rotary_factor", 1.0)
+ super().__post_init__(**kwargs)
+
+
+class SolarOpenDecoderLayer(LlamaDecoderLayer):
+ def __init__(self, config: SolarOpenConfig, layer_idx: int):
+ super().__init__(config, layer_idx)
+ self.mlp = SolarOpenMoE(config)
+
+
+class SolarOpenMoE(Glm4MoeMoE):
+ pass
+
+
+class SolarOpenAttention(LlamaAttention):
+ def __init__(self, config: SolarOpenConfig, layer_idx: int):
+ super().__init__(config, layer_idx)
+ self.o_proj = nn.Linear(config.num_attention_heads * self.head_dim, config.hidden_size, bias=False)
+
+
+class SolarOpenRMSNorm(Glm4MoeRMSNorm):
+ pass
+
+
+class SolarOpenPreTrainedModel(Glm4MoePreTrainedModel):
+ _keys_to_ignore_on_load_unexpected = None
+
+
+class SolarOpenModel(Glm4MoeModel):
+ pass
+
+
+class SolarOpenForCausalLM(Glm4MoeForCausalLM):
+ pass
+
+
+__all__ = [
+ "SolarOpenConfig",
+ "SolarOpenPreTrainedModel",
+ "SolarOpenModel",
+ "SolarOpenForCausalLM",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__init__.py b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..40f66540c9636692195470762c060cef301d9458
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_speech_encoder_decoder import *
+ from .modeling_speech_encoder_decoder import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf9836472117896a07acd18cf00d363bbd0eb58d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__pycache__/configuration_speech_encoder_decoder.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__pycache__/configuration_speech_encoder_decoder.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aee9ae2a37439944f36db8f2b96557ae24ef86ee
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__pycache__/configuration_speech_encoder_decoder.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__pycache__/modeling_speech_encoder_decoder.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__pycache__/modeling_speech_encoder_decoder.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d076ef488ceaaa6d011ebaea6b7638811be2dfdc
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/__pycache__/modeling_speech_encoder_decoder.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/configuration_speech_encoder_decoder.py b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/configuration_speech_encoder_decoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0f62827e875535375d96779c5fa7c4824379a5e
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/configuration_speech_encoder_decoder.py
@@ -0,0 +1,100 @@
+# Copyright 2021 The HuggingFace Inc. team.
+# Copyright (c) 2018, NVIDIA CORPORATION. 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring, logging
+from ..auto.configuration_auto import AutoConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="")
+@strict
+class SpeechEncoderDecoderConfig(PreTrainedConfig):
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import BertConfig, Wav2Vec2Config, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel
+
+ >>> # Initializing a Wav2Vec2 & BERT style configuration
+ >>> config_encoder = Wav2Vec2Config()
+ >>> config_decoder = BertConfig()
+
+ >>> config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
+
+ >>> # Initializing a Wav2Vec2Bert model from a Wav2Vec2 & google-bert/bert-base-uncased style configurations
+ >>> model = SpeechEncoderDecoderModel(config=config)
+
+ >>> # Accessing the model configuration
+ >>> config_encoder = model.config.encoder
+ >>> config_decoder = model.config.decoder
+ >>> # set decoder config to causal lm
+ >>> config_decoder.is_decoder = True
+ >>> config_decoder.add_cross_attention = True
+
+ >>> # Saving the model, including its configuration
+ >>> model.save_pretrained("my-model")
+
+ >>> # loading model and config from pretrained folder
+ >>> encoder_decoder_config = SpeechEncoderDecoderConfig.from_pretrained("my-model")
+ >>> model = SpeechEncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)
+ ```"""
+
+ model_type = "speech-encoder-decoder"
+ sub_configs = {"encoder": AutoConfig, "decoder": AutoConfig}
+ has_no_defaults_at_init = True
+
+ is_encoder_decoder: bool | None = True
+
+ def __post_init__(self, **kwargs):
+ if "encoder" not in kwargs or "decoder" not in kwargs:
+ raise ValueError(
+ f"A configuration of type {self.model_type} cannot be instantiated because not both `encoder` and"
+ f" `decoder` sub-configurations are passed, but only {kwargs}"
+ )
+
+ encoder_config = kwargs.pop("encoder")
+ encoder_model_type = encoder_config.pop("model_type")
+ decoder_config = kwargs.pop("decoder")
+ decoder_model_type = decoder_config.pop("model_type")
+
+ self.encoder = AutoConfig.for_model(encoder_model_type, **encoder_config)
+ self.decoder = AutoConfig.for_model(decoder_model_type, **decoder_config)
+ super().__post_init__(**kwargs)
+
+ @classmethod
+ def from_encoder_decoder_configs(
+ cls, encoder_config: PreTrainedConfig, decoder_config: PreTrainedConfig, **kwargs
+ ) -> PreTrainedConfig:
+ r"""
+ Instantiate a [`SpeechEncoderDecoderConfig`] (or a derived class) from a pre-trained encoder model
+ configuration and decoder model configuration.
+
+ Returns:
+ [`SpeechEncoderDecoderConfig`]: An instance of a configuration object
+ """
+ logger.info("Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config")
+ decoder_config.is_decoder = True
+ decoder_config.add_cross_attention = True
+
+ return cls(encoder=encoder_config.to_dict(), decoder=decoder_config.to_dict(), **kwargs)
+
+
+__all__ = ["SpeechEncoderDecoderConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..638c1f7e838c0a2038a7b7eb3d31e5693e16b8a0
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py
@@ -0,0 +1,495 @@
+# Copyright 2021 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.
+"""Classes to support Speech-Encoder-Text-Decoder architectures"""
+
+import torch
+from torch import nn
+from torch.nn import CrossEntropyLoss
+
+from ...cache_utils import Cache
+from ...configuration_utils import PreTrainedConfig
+from ...generation import GenerationMixin
+from ...modeling_outputs import BaseModelOutput, Seq2SeqLMOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring, logging
+from ..auto.configuration_auto import AutoConfig
+from ..auto.modeling_auto import AutoModel, AutoModelForCausalLM
+from .configuration_speech_encoder_decoder import SpeechEncoderDecoderConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+# Copied from transformers.models.encoder_decoder.modeling_encoder_decoder.shift_tokens_right
+def shift_tokens_right(input_ids: torch.Tensor, pad_token_id: int, decoder_start_token_id: int):
+ """
+ Shift input ids one token to the right.
+ """
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[:, 1:] = input_ids[:, :-1].clone()
+ if decoder_start_token_id is None:
+ raise ValueError("Make sure to set the decoder_start_token_id attribute of the model's configuration.")
+ shifted_input_ids[:, 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("Make sure to set the pad_token_id attribute of the model's configuration.")
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+@auto_docstring
+class SpeechEncoderDecoderModel(PreTrainedModel, GenerationMixin):
+ r"""
+ [`SpeechEncoderDecoderModel`] is a generic model class that will be instantiated as a transformer architecture with
+ one of the base model classes of the library as encoder and another one as decoder when created with the
+ :meth*~transformers.AutoModel.from_pretrained* class method for the encoder and
+ :meth*~transformers.AutoModelForCausalLM.from_pretrained* class method for the decoder.
+ """
+
+ config: SpeechEncoderDecoderConfig
+ base_model_prefix = "speech_encoder_decoder"
+ main_input_name = "inputs"
+ input_modalities = "audio"
+ supports_gradient_checkpointing = True
+ _supports_flash_attn = True
+ _supports_sdpa = True
+
+ def __init__(
+ self,
+ config: PreTrainedConfig | None = None,
+ encoder: PreTrainedModel | None = None,
+ decoder: PreTrainedModel | None = None,
+ ):
+ r"""
+ encoder (`PreTrainedModel`, *optional*):
+ The encoder model to use.
+ decoder (`PreTrainedModel`, *optional*):
+ The decoder model to use.
+ """
+ if config is None and (encoder is None or decoder is None):
+ raise ValueError("Either a configuration or an encoder and a decoder has to be provided.")
+ if config is None:
+ config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(encoder.config, decoder.config)
+ else:
+ if not isinstance(config, self.config_class):
+ raise ValueError(f"Config: {config} has to be of type {self.config_class}")
+
+ if getattr(config.decoder, "cross_attention_hidden_size", None) is not None:
+ if config.decoder.cross_attention_hidden_size != config.encoder.hidden_size:
+ raise ValueError(
+ "If `cross_attention_hidden_size` is specified in the decoder's configuration, it has to be equal"
+ f" to the encoder's `hidden_size`. Got {config.decoder.cross_attention_hidden_size} for"
+ f" `config.decoder.cross_attention_hidden_size` and {config.encoder.hidden_size} for"
+ " `config.encoder.hidden_size`."
+ )
+
+ # initialize with config
+ # make sure input & output embeddings is not tied
+ config.tie_word_embeddings = False
+ super().__init__(config)
+
+ if encoder is None:
+ encoder = AutoModel.from_config(config.encoder)
+
+ if decoder is None:
+ decoder = AutoModelForCausalLM.from_config(config.decoder)
+
+ self.encoder = encoder
+ self.decoder = decoder
+
+ if self.encoder.config.to_dict() != self.config.encoder.to_dict():
+ logger.warning(
+ f"Config of the encoder: {self.encoder.__class__} is overwritten by shared encoder config:"
+ f" {self.config.encoder}"
+ )
+ if self.decoder.config.to_dict() != self.config.decoder.to_dict():
+ logger.warning(
+ f"Config of the decoder: {self.decoder.__class__} is overwritten by shared decoder config:"
+ f" {self.config.decoder}"
+ )
+
+ # make sure that the individual model's config refers to the shared config
+ # so that the updates to the config will be synced
+ self.config.encoder._attn_implementation = self.encoder.config._attn_implementation
+ self.config.decoder._attn_implementation = self.decoder.config._attn_implementation
+ self.encoder.config = self.config.encoder
+ self.decoder.config = self.config.decoder
+
+ # get encoder output hidden size
+ self.encoder_output_dim = getattr(config.encoder, "output_hidden_size", config.encoder.hidden_size)
+ if (
+ self.encoder_output_dim != self.decoder.config.hidden_size
+ and getattr(self.decoder.config, "cross_attention_hidden_size", None) is None
+ ):
+ # encoder outputs might need to be projected to different dimension for decoder
+ self.enc_to_dec_proj = nn.Linear(self.encoder.config.hidden_size, self.decoder.config.hidden_size)
+
+ if self.encoder.get_output_embeddings() is not None:
+ raise ValueError(
+ f"The encoder {self.encoder} should not have a LM Head. Please use a model without LM Head"
+ )
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.decoder.get_input_embeddings()
+
+ def get_output_embeddings(self):
+ return self.decoder.get_output_embeddings()
+
+ def set_output_embeddings(self, new_embeddings):
+ return self.decoder.set_output_embeddings(new_embeddings)
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder of the speech encoder so
+ that its parameters will not be updated during training.
+ """
+ self.encoder.freeze_feature_encoder()
+
+ @classmethod
+ def from_encoder_decoder_pretrained(
+ cls,
+ encoder_pretrained_model_name_or_path: str | None = None,
+ decoder_pretrained_model_name_or_path: str | None = None,
+ *model_args,
+ **kwargs,
+ ) -> PreTrainedModel:
+ r"""
+ Instantiate an encoder and a decoder from one or two base classes of the library from pretrained model
+ checkpoints.
+
+
+ The model is set in evaluation mode by default using `model.eval()` (Dropout modules are deactivated). To train
+ the model, you need to first set it back in training mode with `model.train()`.
+
+ Params:
+ encoder_pretrained_model_name_or_path (`str`, *optional*):
+ Information necessary to initiate the encoder. Can be either:
+
+ - A string, the *model id* of a pretrained model hosted inside a model repo on huggingface.co.
+ - A path to a *directory* containing model weights saved using
+ [`~PreTrainedModel.save_pretrained`], e.g., `./my_model_directory/`.
+
+ decoder_pretrained_model_name_or_path (`str`, *optional*, defaults to `None`):
+ Information necessary to initiate the decoder. Can be either:
+
+ - A string, the *model id* of a pretrained model hosted inside a model repo on huggingface.co.
+ - A path to a *directory* containing model weights saved using
+ [`~PreTrainedModel.save_pretrained`], e.g., `./my_model_directory/`.
+
+ model_args (remaining positional arguments, *optional*):
+ All remaining positional arguments will be passed to the underlying model's `__init__` method.
+
+ kwargs (remaining dictionary of keyword arguments, *optional*):
+ Can be used to update the configuration object (after it being loaded) and initiate the model (e.g.,
+ `output_attentions=True`).
+
+ - To update the encoder configuration, use the prefix *encoder_* for each configuration parameter.
+ - To update the decoder configuration, use the prefix *decoder_* for each configuration parameter.
+ - To update the parent model configuration, do not use a prefix for each configuration parameter.
+
+ Behaves differently depending on whether a `config` is provided or automatically loaded.
+
+ Example:
+
+ ```python
+ >>> from transformers import SpeechEncoderDecoderModel
+
+ >>> # initialize a wav2vec2bert from a pretrained Wav2Vec2 and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
+ >>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
+ ... "facebook/wav2vec2-base-960h", "google-bert/bert-base-uncased"
+ ... )
+ >>> # saving model after fine-tuning
+ >>> model.save_pretrained("./wav2vec2bert")
+ >>> # load fine-tuned model
+ >>> model = SpeechEncoderDecoderModel.from_pretrained("./wav2vec2bert")
+ ```"""
+
+ kwargs_encoder = {
+ argument[len("encoder_") :]: value for argument, value in kwargs.items() if argument.startswith("encoder_")
+ }
+
+ kwargs_decoder = {
+ argument[len("decoder_") :]: value for argument, value in kwargs.items() if argument.startswith("decoder_")
+ }
+
+ # remove encoder, decoder kwargs from kwargs
+ for key in kwargs_encoder:
+ del kwargs["encoder_" + key]
+ for key in kwargs_decoder:
+ del kwargs["decoder_" + key]
+
+ # Load and initialize the encoder and decoder
+ # The distinction between encoder and decoder at the model level is made
+ # by the value of the flag `is_decoder` that we need to set correctly.
+ encoder = kwargs_encoder.pop("model", None)
+ if encoder is None:
+ if encoder_pretrained_model_name_or_path is None:
+ raise ValueError(
+ "If `encoder_model` is not defined as an argument, a `encoder_pretrained_model_name_or_path` has "
+ "to be defined."
+ )
+
+ if "config" not in kwargs_encoder:
+ encoder_config, kwargs_encoder = AutoConfig.from_pretrained(
+ encoder_pretrained_model_name_or_path, **kwargs_encoder, return_unused_kwargs=True
+ )
+
+ if getattr(encoder_config, "is_decoder", False) or getattr(
+ encoder_config, "add_cross_attention", False
+ ):
+ logger.info(
+ f"Initializing {encoder_pretrained_model_name_or_path} as a encoder model "
+ "from a decoder model. Cross-attention and causal mask are disabled."
+ )
+ encoder_config.is_decoder = False
+ encoder_config.add_cross_attention = False
+
+ kwargs_encoder["config"] = encoder_config
+
+ encoder = AutoModel.from_pretrained(encoder_pretrained_model_name_or_path, *model_args, **kwargs_encoder)
+
+ decoder = kwargs_decoder.pop("model", None)
+ if decoder is None:
+ if decoder_pretrained_model_name_or_path is None:
+ raise ValueError(
+ "If `decoder_model` is not defined as an argument, a `decoder_pretrained_model_name_or_path` has "
+ "to be defined."
+ )
+
+ if "config" not in kwargs_decoder:
+ decoder_config, kwargs_decoder = AutoConfig.from_pretrained(
+ decoder_pretrained_model_name_or_path, **kwargs_decoder, return_unused_kwargs=True
+ )
+
+ if decoder_config.is_decoder is False or decoder_config.add_cross_attention is False:
+ logger.info(
+ f"Initializing {decoder_pretrained_model_name_or_path} as a decoder model. Cross attention"
+ f" layers are added to {decoder_pretrained_model_name_or_path} and randomly initialized if"
+ f" {decoder_pretrained_model_name_or_path}'s architecture allows for cross attention layers."
+ )
+ decoder_config.is_decoder = True
+ decoder_config.add_cross_attention = True
+
+ kwargs_decoder["config"] = decoder_config
+
+ if kwargs_decoder["config"].is_decoder is False or kwargs_decoder["config"].add_cross_attention is False:
+ logger.warning(
+ f"Decoder model {decoder_pretrained_model_name_or_path} is not initialized as a decoder. "
+ f"In order to initialize {decoder_pretrained_model_name_or_path} as a decoder, "
+ "make sure that the attributes `is_decoder` and `add_cross_attention` of `decoder_config` "
+ "passed to `.from_encoder_decoder_pretrained(...)` are set to `True` or do not pass a "
+ "`decoder_config` to `.from_encoder_decoder_pretrained(...)`"
+ )
+
+ decoder = AutoModelForCausalLM.from_pretrained(decoder_pretrained_model_name_or_path, **kwargs_decoder)
+
+ # instantiate config with corresponding kwargs
+ config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(encoder.config, decoder.config, **kwargs)
+
+ # make sure input & output embeddings is not tied
+ config.tie_word_embeddings = False
+ return cls(encoder=encoder, decoder=decoder, config=config)
+
+ @auto_docstring
+ def forward(
+ self,
+ inputs: torch.FloatTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[torch.FloatTensor] | None = None,
+ past_key_values: Cache | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ input_values: torch.FloatTensor | None = None,
+ input_features: torch.FloatTensor | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | Seq2SeqLMOutput:
+ r"""
+ inputs (`torch.FloatTensor` of shape `(batch_size, sequence_length)` or `(batch_size, sequence_length, feature_dim)`, *optional*):
+ Float values of input raw speech waveform or speech features. Values can be obtained by loading a `.flac`
+ or `.wav` audio file into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.*
+ via the torchcodec library (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
+ To prepare the array into `inputs`, either the [`Wav2Vec2Processor`] or
+ [`Speech2TextProcessor`] should be used for padding and conversion into a tensor of type
+ `torch.FloatTensor`.
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
+ `past_key_values`).
+
+ For training, `decoder_input_ids` are automatically created by the model by shifting the `labels` to the
+ right, replacing -100 by the `pad_token_id` and prepending them with the `decoder_start_token_id`.
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+ decoder_inputs_embeds (`torch.FloatTensor` of shape `(batch_size, target_sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing `decoder_input_ids` you can choose to directly pass an embedded
+ representation. This is useful if you want more control over how to convert `decoder_input_ids` indices
+ into associated vectors than the model's internal embedding lookup matrix.
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss for the decoder. Indices should be in `[-100, 0,
+ ..., config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
+ input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Float values of input raw speech waveform. Values can be obtained by loading a *.flac* or *.wav* audio file
+ into an array of type *list[float]* or a *numpy.ndarray*, *e.g.* via the torchcodec library
+ (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
+ To prepare the array into *input_values*, the [`Wav2Vec2Processor`] should be used for padding and conversion
+ into a tensor of type *torch.FloatTensor*. See [`Wav2Vec2Processor.__call__`] for details.
+
+ Examples:
+
+ ```python
+ >>> from transformers import SpeechEncoderDecoderModel, AutoProcessor
+ >>> from datasets import load_dataset
+ >>> import torch
+
+ >>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
+ >>> model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
+
+ >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
+
+ >>> input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").input_values
+ >>> # Inference: Translate English speech to German
+ >>> generated = model.generate(input_values)
+ >>> decoded = processor.batch_decode(generated, skip_special_tokens=True)[0]
+ >>> decoded
+ 'Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heißen zu können.'
+
+ >>> # Training: Train model on English transcription
+ >>> labels = processor(text=ds[0]["text"], return_tensors="pt").input_ids
+
+ >>> loss = model(input_values, labels=labels).loss
+ >>> loss.backward()
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ kwargs_encoder = {argument: value for argument, value in kwargs.items() if not argument.startswith("decoder_")}
+
+ kwargs_decoder = {
+ argument[len("decoder_") :]: value for argument, value in kwargs.items() if argument.startswith("decoder_")
+ }
+ if "num_items_in_batch" in kwargs_encoder:
+ kwargs_decoder["num_items_in_batch"] = kwargs_encoder.pop("num_items_in_batch", None)
+
+ if encoder_outputs is None:
+ if inputs is None:
+ if input_values is not None and input_features is not None:
+ raise ValueError("You cannot specify both input_values and input_features at the same time")
+ elif input_values is not None:
+ inputs = input_values
+ elif input_features is not None:
+ inputs = input_features
+ else:
+ raise ValueError("You have to specify either input_values or input_features")
+
+ encoder_outputs = self.encoder(
+ inputs,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ **kwargs_encoder,
+ )
+ elif isinstance(encoder_outputs, tuple):
+ encoder_outputs = BaseModelOutput(*encoder_outputs)
+
+ encoder_hidden_states = encoder_outputs[0]
+
+ # optionally project encoder_hidden_states
+ if (
+ self.encoder_output_dim != self.decoder.config.hidden_size
+ and getattr(self.decoder.config, "cross_attention_hidden_size", None) is None
+ ):
+ encoder_hidden_states = self.enc_to_dec_proj(encoder_hidden_states)
+
+ # compute correct encoder attention mask
+ if attention_mask is not None:
+ encoder_attention_mask = self.encoder._get_feature_vector_attention_mask(
+ encoder_hidden_states.shape[1], attention_mask
+ )
+ else:
+ encoder_attention_mask = None
+
+ if (labels is not None) and (decoder_input_ids is None and decoder_inputs_embeds is None):
+ decoder_input_ids = shift_tokens_right(
+ labels, self.config.pad_token_id, self.config.decoder_start_token_id
+ )
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ use_cache=use_cache,
+ past_key_values=past_key_values,
+ return_dict=return_dict,
+ **kwargs_decoder,
+ )
+
+ # Compute loss independent from decoder (as some shift the logits inside them)
+ loss = None
+ if labels is not None:
+ logits = decoder_outputs.logits if return_dict else decoder_outputs[0]
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.reshape(-1, self.decoder.config.vocab_size), labels.reshape(-1))
+
+ if not return_dict:
+ if loss is not None:
+ return (loss,) + decoder_outputs + encoder_outputs
+ else:
+ return decoder_outputs + encoder_outputs
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=decoder_outputs.logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_hidden_states,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+ return shift_tokens_right(labels, self.config.pad_token_id, self.config.decoder_start_token_id)
+
+ def resize_token_embeddings(self, *args, **kwargs):
+ raise NotImplementedError(
+ "Resizing the embedding layers via the SpeechEncoderDecoderModel directly is not supported. Please use the"
+ " respective methods of the wrapped decoder object (model.decoder.resize_token_embeddings(...))"
+ )
+
+
+__all__ = ["SpeechEncoderDecoderModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/__init__.py b/lib/python3.11/site-packages/transformers/models/speech_to_text/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4dce9e2cc611046a08cb796f1f74ceb68efb0fa
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speech_to_text/__init__.py
@@ -0,0 +1,30 @@
+# Copyright 2024 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_speech_to_text import *
+ from .feature_extraction_speech_to_text import *
+ from .modeling_speech_to_text import *
+ from .processing_speech_to_text import *
+ from .tokenization_speech_to_text import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..81461a0953ba4e4c72e084f344819cc7393a315c
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/configuration_speech_to_text.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/configuration_speech_to_text.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..079120e7059e789609845e5fd1801fd8749f8925
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/configuration_speech_to_text.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/feature_extraction_speech_to_text.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/feature_extraction_speech_to_text.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fa6c2bbead29766f253f4c7b299355ef0702428a
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/feature_extraction_speech_to_text.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/modeling_speech_to_text.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/modeling_speech_to_text.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1d3c45bf3917c327ec2379f4da5ea006504ab2e4
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/modeling_speech_to_text.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/processing_speech_to_text.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/processing_speech_to_text.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dab5c0df2e4bccfbd75b5bef4472bf60790adf7a
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/processing_speech_to_text.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/tokenization_speech_to_text.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/tokenization_speech_to_text.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc22d3a6bc6ef778fcd76aa3ad2af84a32c51cc9
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/speech_to_text/__pycache__/tokenization_speech_to_text.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/configuration_speech_to_text.py b/lib/python3.11/site-packages/transformers/models/speech_to_text/configuration_speech_to_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dbc7884338ae67dafe8ee644dfabd5f1a700e74
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speech_to_text/configuration_speech_to_text.py
@@ -0,0 +1,108 @@
+# Copyright 2021 The HuggingFace Inc. 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.
+"""Speech2Text model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="facebook/s2t-small-librispeech-asr")
+@strict
+class Speech2TextConfig(PreTrainedConfig):
+ r"""
+ max_source_positions (`int`, *optional*, defaults to 6000):
+ The maximum sequence length of log-mel filter-bank features that this model might ever be used with.
+ max_target_positions (`int`, *optional*, defaults to 1024):
+ The maximum sequence length that this model might ever be used with. Typically, set this to something large
+ just in case (e.g., 512 or 1024 or 2048).
+ num_conv_layers (`int`, *optional*, defaults to 2):
+ Number of 1D convolutional layers in the conv module.
+ conv_kernel_sizes (`tuple[int]`, *optional*, defaults to `(5, 5)`):
+ A tuple of integers defining the kernel size of each 1D convolutional layer in the conv module. The length
+ of `conv_kernel_sizes` has to match `num_conv_layers`.
+ conv_channels (`int`, *optional*, defaults to 1024):
+ An integer defining the number of output channels of each convolution layers except the final one in the
+ conv module.
+ input_feat_per_channel (`int`, *optional*, defaults to 80):
+ An integer specifying the size of feature vector. This is also the dimensions of log-mel filter-bank
+ features.
+
+ Example:
+
+ ```python
+ >>> from transformers import Speech2TextConfig, Speech2TextModel
+
+ >>> # Initializing a Speech2Text s2t_transformer_s style configuration
+ >>> configuration = Speech2TextConfig()
+
+ >>> # Initializing a model (with random weights) from the s2t_transformer_s style configuration
+ >>> model = Speech2TextModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "speech_to_text"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ attribute_map = {
+ "num_attention_heads": "encoder_attention_heads",
+ "hidden_size": "d_model",
+ "num_hidden_layers": "encoder_layers",
+ }
+
+ vocab_size: int = 10000
+ encoder_layers: int = 12
+ encoder_ffn_dim: int = 2048
+ encoder_attention_heads: int = 4
+ decoder_layers: int = 6
+ decoder_ffn_dim: int = 2048
+ decoder_attention_heads: int = 4
+ encoder_layerdrop: float | int = 0.0
+ decoder_layerdrop: float | int = 0.0
+ use_cache: bool = True
+ is_encoder_decoder: bool = True
+ activation_function: str = "relu"
+ d_model: int = 256
+ dropout: float | int = 0.1
+ attention_dropout: float | int = 0.0
+ activation_dropout: float | int = 0.0
+ init_std: float = 0.02
+ decoder_start_token_id: int = 2
+ scale_embedding: bool = True
+ pad_token_id: int | None = 1
+ bos_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 2
+ max_source_positions: int = 6000
+ max_target_positions: int = 1024
+ num_conv_layers: int = 2
+ conv_kernel_sizes: list[int] | tuple[int, ...] = (5, 5)
+ conv_channels: int = 1024
+ input_feat_per_channel: int = 80
+ input_channels: int = 1
+ tie_word_embeddings: bool = True
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if len(self.conv_kernel_sizes) != self.num_conv_layers:
+ raise ValueError(
+ "Configuration for convolutional module is incorrect. "
+ "It is required that `len(config.conv_kernel_sizes)` == `config.num_conv_layers` "
+ f"but is `len(config.conv_kernel_sizes) = {len(self.conv_kernel_sizes)}`, "
+ f"`config.num_conv_layers = {self.num_conv_layers}`."
+ )
+
+
+__all__ = ["Speech2TextConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/feature_extraction_speech_to_text.py b/lib/python3.11/site-packages/transformers/models/speech_to_text/feature_extraction_speech_to_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..9685e9be01348784ea4f7c7a7b84dd71db04a49f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speech_to_text/feature_extraction_speech_to_text.py
@@ -0,0 +1,311 @@
+# Copyright 2021 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.
+"""
+Feature extractor class for Speech2Text
+"""
+
+import numpy as np
+
+from ...audio_utils import mel_filter_bank, spectrogram, window_function
+from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
+from ...feature_extraction_utils import BatchFeature
+from ...utils import PaddingStrategy, TensorType, is_speech_available, logging
+
+
+if is_speech_available():
+ import torch
+ import torchaudio.compliance.kaldi as ta_kaldi
+
+logger = logging.get_logger(__name__)
+
+
+class Speech2TextFeatureExtractor(SequenceFeatureExtractor):
+ r"""
+ Constructs a Speech2Text feature extractor.
+
+ This feature extractor inherits from [`Speech2TextFeatureExtractor`] which contains most of the main methods. Users
+ should refer to this superclass for more information regarding those methods.
+
+ This class extracts mel-filter bank features from raw speech using TorchAudio if installed or using numpy
+ otherwise, and applies utterance-level cepstral mean and variance normalization to the extracted features.
+
+ Args:
+ feature_size (`int`, *optional*, defaults to 80):
+ The feature dimension of the extracted features.
+ sampling_rate (`int`, *optional*, defaults to 16000):
+ The sampling rate at which the audio files should be digitalized expressed in hertz (Hz).
+ num_mel_bins (`int`, *optional*, defaults to 80):
+ Number of Mel-frequency bins.
+ padding_value (`float`, *optional*, defaults to 0.0):
+ The value that is used to fill the padding vectors.
+ dither (`float`, *optional*, defaults to 0.0):
+ Adds dithering. In other words, adds a small Gaussian noise to each frame.
+ E.g. use 4.0 to add dithering with a normal distribution centered
+ around 0.0 with standard deviation 4.0 (assuming [-32k,+32k] range of kaldi waveform).
+ The value 0.0 means no dithering.
+ Dithering has similar effect as `mel_floor`. It reduces the high log_mel_fbank
+ values for signals with hard-zero sections, when VAD cutoff is present in the signal.
+ do_ceptral_normalize (`bool`, *optional*, defaults to `True`):
+ Whether or not to apply utterance-level cepstral mean and variance normalization to extracted features.
+ normalize_means (`bool`, *optional*, defaults to `True`):
+ Whether or not to zero-mean normalize the extracted features.
+ normalize_vars (`bool`, *optional*, defaults to `True`):
+ Whether or not to unit-variance normalize the extracted features.
+ """
+
+ model_input_names = ["input_features", "attention_mask"]
+
+ def __init__(
+ self,
+ feature_size=80,
+ sampling_rate=16000,
+ num_mel_bins=80,
+ padding_value=0.0,
+ dither=0.0,
+ do_ceptral_normalize=True,
+ normalize_means=True,
+ normalize_vars=True,
+ **kwargs,
+ ):
+ super().__init__(feature_size=feature_size, sampling_rate=sampling_rate, padding_value=padding_value, **kwargs)
+ self.num_mel_bins = num_mel_bins
+ self.dither = dither
+ self.do_ceptral_normalize = do_ceptral_normalize
+ self.normalize_means = normalize_means
+ self.normalize_vars = normalize_vars
+ self.return_attention_mask = True
+
+ if not is_speech_available():
+ mel_filters = mel_filter_bank(
+ num_frequency_bins=257,
+ num_mel_filters=self.num_mel_bins,
+ min_frequency=20,
+ max_frequency=sampling_rate // 2,
+ sampling_rate=sampling_rate,
+ norm=None,
+ mel_scale="kaldi",
+ triangularize_in_mel_space=True,
+ )
+
+ self.mel_filters = mel_filters
+ self.window = window_function(400, "povey", periodic=False)
+
+ def _extract_fbank_features(
+ self,
+ waveform: np.ndarray,
+ ) -> np.ndarray:
+ """
+ Get mel-filter bank features using TorchAudio. Note that TorchAudio requires 16-bit signed integers as inputs
+ and hence the waveform should not be normalized before feature extraction.
+ """
+ waveform = waveform * (2**15) # Kaldi compliance: 16-bit signed integers
+ if is_speech_available():
+ waveform = torch.from_numpy(waveform).unsqueeze(0)
+ features = ta_kaldi.fbank(
+ waveform,
+ dither=self.dither,
+ num_mel_bins=self.num_mel_bins,
+ sample_frequency=self.sampling_rate,
+ )
+ features = features.numpy()
+ else:
+ waveform = np.squeeze(waveform)
+ features = spectrogram(
+ waveform,
+ self.window,
+ frame_length=400,
+ hop_length=160,
+ fft_length=512,
+ power=2.0,
+ center=False,
+ dither=self.dither,
+ preemphasis=0.97,
+ mel_filters=self.mel_filters,
+ log_mel="log",
+ mel_floor=1.192092955078125e-07,
+ remove_dc_offset=True,
+ ).T
+ return features
+
+ @staticmethod
+ def utterance_cmvn(
+ x: np.ndarray,
+ input_length: int,
+ normalize_means: bool | None = True,
+ normalize_vars: bool | None = True,
+ padding_value: float = 0.0,
+ ) -> np.ndarray:
+ # make sure we normalize float32 arrays
+ if normalize_means:
+ mean = x[:input_length].mean(axis=0)
+ x = np.subtract(x, mean)
+ if normalize_vars:
+ std = x[:input_length].std(axis=0)
+ x = np.divide(x, std)
+
+ if input_length < x.shape[0]:
+ x[input_length:] = padding_value
+
+ # make sure array is in float32
+ x = x.astype(np.float32)
+
+ return x
+
+ def normalize(
+ self, input_features: list[np.ndarray], attention_mask: np.ndarray | None = None
+ ) -> list[np.ndarray]:
+ lengths = attention_mask.sum(-1) if attention_mask is not None else [x.shape[0] for x in input_features]
+ return [
+ self.utterance_cmvn(x, n, self.normalize_means, self.normalize_vars, self.padding_value)
+ for x, n in zip(input_features, lengths)
+ ]
+
+ def __call__(
+ self,
+ raw_speech: np.ndarray | list[float] | list[np.ndarray] | list[list[float]],
+ padding: bool | str | PaddingStrategy = False,
+ max_length: int | None = None,
+ truncation: bool = False,
+ pad_to_multiple_of: int | None = None,
+ return_tensors: str | TensorType | None = None,
+ sampling_rate: int | None = None,
+ return_attention_mask: bool | None = None,
+ **kwargs,
+ ) -> BatchFeature:
+ """
+ Main method to featurize and prepare for the model one or several sequence(s).
+
+ Args:
+ raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`):
+ The sequence or batch of sequences to be padded. Each sequence can be a numpy array, a list of float
+ values, a list of numpy arrays or a list of list of float values. Must be mono channel audio, not
+ stereo, i.e. single float per timestep.
+ padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `True`):
+ Select a strategy to pad the returned sequences (according to the model's padding side and padding
+ index) among:
+
+ - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+ sequence if provided).
+ - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
+ acceptable input length for the model if that argument is not provided.
+ - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
+ lengths).
+ max_length (`int`, *optional*):
+ Maximum length of the returned list and optionally padding length (see above).
+ truncation (`bool`):
+ Activates truncation to cut input sequences longer than *max_length* to *max_length*.
+ pad_to_multiple_of (`int`, *optional*):
+ If set will pad the sequence to a multiple of the provided value.
+
+ This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability
+ `>= 7.5` (Volta), or on TPUs which benefit from having sequence lengths be a multiple of 128.
+ return_attention_mask (`bool`, *optional*):
+ Whether to return the attention mask. If left to the default, will return the attention mask according
+ to the specific feature_extractor's default.
+
+ [What are attention masks?](../glossary#attention-mask)
+
+ <Tip>
+
+ For Speech2TextTransformer models, `attention_mask` should always be passed for batched inference, to
+ avoid subtle bugs.
+
+ </Tip>
+
+ return_tensors (`str` or [`~utils.TensorType`], *optional*):
+ If set, will return tensors instead of list of python integers. Acceptable values are:
+
+ - `'pt'`: Return PyTorch `torch.Tensor` objects.
+ - `'np'`: Return Numpy `np.ndarray` objects.
+ sampling_rate (`int`, *optional*):
+ The sampling rate at which the `raw_speech` input was sampled. It is strongly recommended to pass
+ `sampling_rate` at the forward call to prevent silent errors.
+ padding_value (`float`, *optional*, defaults to 0.0):
+ The value that is used to fill the padding values / vectors.
+ """
+
+ if sampling_rate is not None:
+ if sampling_rate != self.sampling_rate:
+ raise ValueError(
+ f"The model corresponding to this feature extractor: {self} was trained using a sampling rate of"
+ f" {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with"
+ f" {self.sampling_rate} and not {sampling_rate}."
+ )
+ else:
+ logger.warning(
+ f"It is strongly recommended to pass the `sampling_rate` argument to `{self.__class__.__name__}()`. "
+ "Failing to do so can result in silent errors that might be hard to debug."
+ )
+
+ is_batched_numpy = isinstance(raw_speech, np.ndarray) and len(raw_speech.shape) > 1
+ if is_batched_numpy and len(raw_speech.shape) > 2:
+ raise ValueError(f"Only mono-channel audio is supported for input to {self}")
+ is_batched = is_batched_numpy or (
+ isinstance(raw_speech, (list, tuple)) and (isinstance(raw_speech[0], (np.ndarray, tuple, list)))
+ )
+
+ if is_batched:
+ raw_speech = [np.asarray(speech, dtype=np.float32) for speech in raw_speech]
+ elif not is_batched and not isinstance(raw_speech, np.ndarray):
+ raw_speech = np.asarray(raw_speech, dtype=np.float32)
+ elif isinstance(raw_speech, np.ndarray) and raw_speech.dtype is np.dtype(np.float64):
+ raw_speech = raw_speech.astype(np.float32)
+
+ # always return batch
+ if not is_batched:
+ raw_speech = [raw_speech]
+
+ # extract fbank features
+ features = [self._extract_fbank_features(waveform) for waveform in raw_speech]
+
+ # convert into correct format for padding
+ encoded_inputs = BatchFeature({"input_features": features})
+
+ padded_inputs = self.pad(
+ encoded_inputs,
+ padding=padding,
+ max_length=max_length,
+ truncation=truncation,
+ pad_to_multiple_of=pad_to_multiple_of,
+ return_attention_mask=return_attention_mask,
+ **kwargs,
+ )
+
+ # make sure list is in array format
+ input_features = padded_inputs.get("input_features")
+ if isinstance(input_features[0], list):
+ padded_inputs["input_features"] = [np.asarray(feature, dtype=np.float32) for feature in input_features]
+
+ attention_mask = padded_inputs.get("attention_mask")
+ if attention_mask is not None:
+ padded_inputs["attention_mask"] = [np.asarray(array, dtype=np.int32) for array in attention_mask]
+
+ # Utterance-level cepstral mean and variance normalization
+ if self.do_ceptral_normalize:
+ attention_mask = (
+ np.array(attention_mask, dtype=np.int32)
+ if self._get_padding_strategies(padding, max_length=max_length) is not PaddingStrategy.DO_NOT_PAD
+ else None
+ )
+ padded_inputs["input_features"] = self.normalize(
+ padded_inputs["input_features"], attention_mask=attention_mask
+ )
+
+ if return_tensors is not None:
+ padded_inputs = padded_inputs.convert_to_tensors(return_tensors)
+
+ return padded_inputs
+
+
+__all__ = ["Speech2TextFeatureExtractor"]
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/modeling_speech_to_text.py b/lib/python3.11/site-packages/transformers/models/speech_to_text/modeling_speech_to_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..3111cc6d0b837519a23be039e1dbca6f338d42f1
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speech_to_text/modeling_speech_to_text.py
@@ -0,0 +1,956 @@
+# Copyright 2021 The Fairseq Authors and The HuggingFace Inc. 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.
+"""PyTorch Speech2Text model."""
+
+import math
+from collections.abc import Callable
+
+import torch
+from torch import nn
+from torch.nn import CrossEntropyLoss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ BaseModelOutputWithPastAndCrossAttentions,
+ Seq2SeqLMOutput,
+ Seq2SeqModelOutput,
+)
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import (
+ TransformersKwargs,
+ auto_docstring,
+ logging,
+)
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from .configuration_speech_to_text import Speech2TextConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+# Copied from transformers.models.bart.modeling_bart.shift_tokens_right
+def shift_tokens_right(input_ids: torch.Tensor, pad_token_id: int, decoder_start_token_id: int):
+ """
+ Shift input ids one token to the right.
+ """
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[:, 1:] = input_ids[:, :-1].clone()
+ shifted_input_ids[:, 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.pad_token_id has to be defined.")
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+class Conv1dSubsampler(nn.Module):
+ """
+ Convolutional subsampler: a stack of 1D convolution (along temporal dimension) followed by non-linear activation
+ via gated linear units (https://huggingface.co/papers/1911.08460)
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.num_layers = config.num_conv_layers
+ self.in_channels = config.input_feat_per_channel * config.input_channels
+ self.mid_channels = config.conv_channels
+ self.out_channels = config.d_model
+ self.kernel_sizes = config.conv_kernel_sizes
+
+ self.conv_layers = nn.ModuleList(
+ nn.Conv1d(
+ self.in_channels if i == 0 else self.mid_channels // 2,
+ self.mid_channels if i < self.num_layers - 1 else self.out_channels * 2,
+ kernel_size=k,
+ stride=2,
+ padding=k // 2,
+ )
+ for i, k in enumerate(self.kernel_sizes)
+ )
+
+ def forward(self, input_features):
+ hidden_states = input_features.transpose(1, 2).contiguous() # -> B x (C x D) x T
+ for conv in self.conv_layers:
+ hidden_states = conv(hidden_states)
+ hidden_states = nn.functional.glu(hidden_states, dim=1)
+ hidden_states = hidden_states.transpose(1, 2).contiguous() # -> T x B x (C x D)
+ return hidden_states
+
+
+class Speech2TextSinusoidalPositionalEmbedding(nn.Module):
+ """This module produces sinusoidal positional embeddings of any length."""
+
+ def __init__(self, num_positions: int, embedding_dim: int, padding_idx: int | None = None):
+ super().__init__()
+ self.offset = 2
+ self.num_positions = num_positions
+ self.embedding_dim = embedding_dim
+ self.padding_idx = padding_idx
+ self.make_weights(num_positions + self.offset, embedding_dim, padding_idx)
+
+ def make_weights(self, num_embeddings: int, embedding_dim: int, padding_idx: int | None = None):
+ emb_weights = self.get_embedding(num_embeddings, embedding_dim, padding_idx)
+ if hasattr(self, "weights"):
+ # in forward put the weights on the correct dtype and device of the param
+ emb_weights = emb_weights.to(dtype=self.weights.dtype, device=self.weights.device)
+
+ self.register_buffer("weights", emb_weights, persistent=False)
+
+ @staticmethod
+ def get_embedding(num_embeddings: int, embedding_dim: int, padding_idx: int | None = None):
+ """
+ Build sinusoidal embeddings. This matches the implementation in tensor2tensor, but differs slightly from the
+ description in Section 3.5 of "Attention Is All You Need".
+ """
+ half_dim = embedding_dim // 2
+ emb = math.log(10000) / (half_dim - 1)
+ emb = torch.exp(torch.arange(half_dim, dtype=torch.int64).float() * -emb)
+ emb = torch.arange(num_embeddings, dtype=torch.int64).float().unsqueeze(1) * emb.unsqueeze(0)
+ emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1).view(num_embeddings, -1)
+ if embedding_dim % 2 == 1:
+ # zero pad
+ emb = torch.cat([emb, torch.zeros(num_embeddings, 1)], dim=1)
+ if padding_idx is not None:
+ emb[padding_idx, :] = 0
+ return emb.to(torch.get_default_dtype())
+
+ @torch.no_grad()
+ def forward(self, input_ids: torch.Tensor, past_key_values_length: int = 0):
+ bsz, seq_len = input_ids.size()
+ # Create the position ids from the input token ids. Any padded tokens remain padded.
+ position_ids = self.create_position_ids_from_input_ids(input_ids, self.padding_idx, past_key_values_length).to(
+ input_ids.device
+ )
+
+ # expand embeddings if needed
+ max_pos = self.padding_idx + 1 + seq_len
+ if max_pos > self.weights.size(0):
+ self.make_weights(max_pos + self.offset, self.embedding_dim, self.padding_idx)
+
+ return self.weights.index_select(0, position_ids.view(-1)).view(bsz, seq_len, -1).detach()
+
+ def create_position_ids_from_input_ids(
+ self, input_ids: torch.Tensor, padding_idx: int, past_key_values_length: int | None = 0
+ ):
+ """
+ Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding
+ symbols are ignored. This is modified from fairseq's `utils.make_positions`.
+
+ Args:
+ x: torch.Tensor x:
+ Returns: torch.Tensor
+ """
+ # The series of casts and type-conversions here are carefully balanced to both work with ONNX export and XLA.
+ mask = input_ids.ne(padding_idx).int()
+ incremental_indices = (torch.cumsum(mask, dim=1).type_as(mask) + past_key_values_length) * mask
+ return incremental_indices.long() + padding_idx
+
+
+# Copied from transformers.models.bert.modeling_bert.eager_attention_forward
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float | None = None,
+ dropout: float = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ if scaling is None:
+ scaling = query.size(-1) ** -0.5
+
+ # Take the dot product between "query" and "key" to get the raw attention scores.
+ attn_weights = torch.matmul(query, key.transpose(2, 3)) * scaling
+
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+# Copied from transformers.models.musicgen.modeling_musicgen.MusicgenAttention with Musicgen->Speech2Text
+class Speech2TextAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(
+ self,
+ embed_dim: int,
+ num_heads: int,
+ dropout: float | None = 0.0,
+ is_decoder: bool | None = False,
+ bias: bool | None = True,
+ is_causal: bool | None = False,
+ config: Speech2TextConfig | None = None,
+ layer_idx: int | None = None,
+ ):
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.num_heads = num_heads
+ self.dropout = dropout
+ self.head_dim = embed_dim // num_heads
+ self.config = config
+
+ if (self.head_dim * num_heads) != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}"
+ f" and `num_heads`: {num_heads})."
+ )
+ self.scaling = self.head_dim**-0.5
+ self.is_decoder = is_decoder
+ self.is_causal = is_causal
+ self.layer_idx = layer_idx
+
+ self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ key_value_states: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = False,
+ # TODO: we need a refactor so that the different attention modules can get their specific kwargs
+ # ATM, we have mixed things encoder, decoder, and encoder-decoder attn
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ """Input shape: Batch x Time x Channel"""
+
+ # if key_value_states are provided this layer is used as a cross-attention layer
+ # for the decoder
+ is_cross_attention = key_value_states is not None
+
+ # determine input shapes
+ input_shape = hidden_states.shape[:-1]
+
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ # get query proj
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ is_updated = False
+ if past_key_values is not None:
+ if isinstance(past_key_values, EncoderDecoderCache):
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ if is_cross_attention:
+ # after the first generated id, we can subsequently re-use all key/value_layer from cache
+ curr_past_key_values = past_key_values.cross_attention_cache
+ else:
+ curr_past_key_values = past_key_values.self_attention_cache
+ else:
+ curr_past_key_values = past_key_values
+
+ current_states = key_value_states if is_cross_attention else hidden_states
+ if is_cross_attention and past_key_values is not None and is_updated:
+ # reuse k,v, cross_attentions
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+ else:
+ kv_shape = (*current_states.shape[:-1], -1, self.head_dim)
+ key_states = self.k_proj(current_states).view(kv_shape).transpose(1, 2)
+ value_states = self.v_proj(current_states).view(kv_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ # save all key/value_states to cache to be re-used for fast auto-regressive generation
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+ if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+ past_key_values.is_updated[self.layer_idx] = True
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=0.0 if not self.training else self.dropout,
+ scaling=self.scaling,
+ output_attentions=output_attentions,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+# Copied from transformers.models.mbart.modeling_mbart.MBartEncoderLayer with MBart->Speech2Text, MBART->SPEECH_TO_TEXT
+class Speech2TextEncoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: Speech2TextConfig):
+ super().__init__()
+ self.embed_dim = config.d_model
+
+ self.self_attn = Speech2TextAttention(
+ embed_dim=self.embed_dim,
+ num_heads=config.encoder_attention_heads,
+ dropout=config.attention_dropout,
+ config=config,
+ )
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.dropout = config.dropout
+ self.activation_fn = ACT2FN[config.activation_function]
+ self.activation_dropout = config.activation_dropout
+ self.fc1 = nn.Linear(self.embed_dim, config.encoder_ffn_dim)
+ self.fc2 = nn.Linear(config.encoder_ffn_dim, self.embed_dim)
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ """
+ Args:
+ hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+ attention_mask (`torch.FloatTensor`): attention mask of size
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+ """
+ residual = hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.final_layer_norm(hidden_states)
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+
+ if hidden_states.dtype == torch.float16:
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ return hidden_states
+
+
+# copied from transformers.models.mbart.modeling_mbart.MBartDecoderLayer with MBart->Speech2Text, MBART->SPEECH_TO_TEXT
+# TODO: change copy when applying cache class
+class Speech2TextDecoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: Speech2TextConfig, layer_idx=None):
+ super().__init__()
+ self.embed_dim = config.d_model
+
+ self.self_attn = Speech2TextAttention(
+ embed_dim=self.embed_dim,
+ num_heads=config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=True,
+ is_causal=True,
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.dropout = config.dropout
+ self.activation_fn = ACT2FN[config.activation_function]
+ self.activation_dropout = config.activation_dropout
+
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.encoder_attn = Speech2TextAttention(
+ self.embed_dim,
+ config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=True,
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.encoder_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.fc1 = nn.Linear(self.embed_dim, config.decoder_ffn_dim)
+ self.fc2 = nn.Linear(config.decoder_ffn_dim, self.embed_dim)
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ # Copied from transformers.models.musicgen.modeling_musicgen.MusicgenDecoderLayer.forward
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = True,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ """
+ Args:
+ hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+ attention_mask (`torch.FloatTensor`): attention mask of size
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+ encoder_hidden_states (`torch.FloatTensor`):
+ cross attention input to the layer of shape `(batch, seq_len, embed_dim)`
+ encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+ past_key_values (`Cache`): cached past key and value projection states
+ """
+ residual = hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+
+ # Self Attention
+ hidden_states, _ = self.self_attn(
+ hidden_states,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+
+ # Cross-Attention Block
+ if encoder_hidden_states is not None:
+ residual = hidden_states
+ hidden_states = self.encoder_attn_layer_norm(hidden_states)
+
+ hidden_states, _ = self.encoder_attn(
+ hidden_states,
+ key_value_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ **kwargs,
+ )
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+
+ # Fully Connected
+ residual = hidden_states
+ hidden_states = self.final_layer_norm(hidden_states)
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+
+ return hidden_states
+
+
+@auto_docstring
+class Speech2TextPreTrainedModel(PreTrainedModel):
+ config: Speech2TextConfig
+ base_model_prefix = "model"
+ main_input_name = "input_features"
+ input_modalities = ("text", "audio")
+ supports_gradient_checkpointing = True
+ # TODO: tests would need a rewrite to check for correct implementation
+ # Current tests always assume certain inputs to be passed
+ _supports_flash_attn = False
+ _supports_sdpa = False
+ _supports_flex_attn = False
+
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, Speech2TextSinusoidalPositionalEmbedding):
+ emb_weights = module.get_embedding(
+ module.num_positions + module.offset, module.embedding_dim, module.padding_idx
+ )
+ init.copy_(module.weights, emb_weights)
+
+ def _get_feat_extract_output_lengths(self, input_lengths: torch.LongTensor):
+ """
+ Computes the output length of the convolutional layers
+ """
+ for i in range(self.config.num_conv_layers):
+ input_lengths = (input_lengths - 1) // 2 + 1
+
+ return input_lengths
+
+ def _get_feature_vector_attention_mask(self, feature_vector_length, attention_mask):
+ # generate creates 3D attention mask, because of the shape of input_features
+ # convert it to 2D if that's the case
+ if len(attention_mask.shape) > 2:
+ attention_mask = attention_mask[:, :, -1]
+
+ subsampled_lengths = self._get_feat_extract_output_lengths(attention_mask.sum(-1))
+ bsz = attention_mask.size()[0]
+ attention_mask = torch.zeros(
+ (bsz, feature_vector_length), dtype=attention_mask.dtype, device=attention_mask.device
+ )
+
+ # these two operations makes sure that all values
+ # before the output lengths indices are attended to
+ attention_mask[(torch.arange(bsz, device=attention_mask.device), subsampled_lengths - 1)] = 1
+ attention_mask = attention_mask.flip([-1]).cumsum(-1).flip([-1]).long()
+ return attention_mask
+
+
+class Speech2TextEncoder(Speech2TextPreTrainedModel):
+ """
+ Transformer encoder consisting of *config.encoder_layers* self attention layers. Each layer is a
+ [`Speech2TextEncoderLayer`].
+
+ Args:
+ config: Speech2TextConfig
+ embed_tokens (nn.Embedding): output embedding
+ """
+
+ _no_split_modules = ["Speech2TextEncoderLayer"]
+ _can_record_outputs = {
+ "hidden_states": Speech2TextEncoderLayer,
+ "attentions": Speech2TextAttention,
+ }
+
+ def __init__(self, config: Speech2TextConfig):
+ super().__init__(config)
+
+ self.dropout = config.dropout
+ self.layerdrop = config.encoder_layerdrop
+
+ embed_dim = config.d_model
+ self.padding_idx = config.pad_token_id
+ self.max_source_positions = config.max_source_positions
+ self.embed_scale = math.sqrt(embed_dim) if config.scale_embedding else 1.0
+
+ self.conv = Conv1dSubsampler(config)
+
+ self.embed_positions = Speech2TextSinusoidalPositionalEmbedding(
+ self.max_source_positions,
+ embed_dim,
+ self.padding_idx,
+ )
+ self.layers = nn.ModuleList([Speech2TextEncoderLayer(config) for _ in range(config.encoder_layers)])
+ self.layer_norm = nn.LayerNorm(config.d_model)
+
+ self.gradient_checkpointing = False
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_features,
+ attention_mask=None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ inputs_embeds = self.conv(input_features)
+ inputs_embeds = self.embed_scale * inputs_embeds
+
+ # subsample attention mask if necessary
+ if attention_mask is not None:
+ attention_mask = self._get_feature_vector_attention_mask(inputs_embeds.shape[1], attention_mask)
+ padding_mask = attention_mask.ne(1).long()
+ else:
+ padding_mask = torch.zeros(inputs_embeds.shape[:2], dtype=torch.long, device=inputs_embeds.device)
+
+ embed_pos = self.embed_positions(padding_mask)
+
+ hidden_states = inputs_embeds + embed_pos
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ )
+
+ for idx, encoder_layer in enumerate(self.layers):
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ to_drop = False
+ if self.training:
+ dropout_probability = torch.rand([])
+ if dropout_probability < self.layerdrop: # skip the layer
+ to_drop = True
+
+ if not to_drop:
+ hidden_states = encoder_layer(
+ hidden_states,
+ attention_mask,
+ **kwargs,
+ )
+
+ hidden_states = self.layer_norm(hidden_states)
+
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ )
+
+
+class Speech2TextDecoder(Speech2TextPreTrainedModel):
+ """
+ Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`Speech2TextDecoderLayer`]
+
+ Args:
+ config: Speech2TextConfig
+ embed_tokens (nn.Embedding): output embedding
+ """
+
+ _can_record_outputs = {
+ "hidden_states": Speech2TextDecoderLayer,
+ "attentions": OutputRecorder(Speech2TextAttention, index=1, layer_name="self_attn"),
+ "cross_attentions": OutputRecorder(Speech2TextAttention, index=1, layer_name="encoder_attn"),
+ }
+
+ def __init__(self, config: Speech2TextConfig):
+ super().__init__(config)
+ self.dropout = config.dropout
+ self.layerdrop = config.decoder_layerdrop
+ self.padding_idx = config.pad_token_id
+ self.max_target_positions = config.max_target_positions
+ self.embed_scale = math.sqrt(config.d_model) if config.scale_embedding else 1.0
+
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.d_model, self.padding_idx)
+
+ self.embed_positions = Speech2TextSinusoidalPositionalEmbedding(
+ self.max_target_positions,
+ config.d_model,
+ self.padding_idx,
+ )
+
+ self.layers = nn.ModuleList(
+ [Speech2TextDecoderLayer(config, layer_idx=i) for i in range(config.decoder_layers)]
+ )
+
+ self.layer_norm = nn.LayerNorm(config.d_model)
+
+ self.gradient_checkpointing = False
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_ids=None,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ past_key_values=None,
+ inputs_embeds=None,
+ use_cache=None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPastAndCrossAttentions:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids) * self.embed_scale
+
+ if use_cache and past_key_values is None:
+ past_key_values = EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache(config=self.config))
+
+ past_key_values_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+
+ attention_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+
+ # embed positions
+ positions = self.embed_positions(input_ids, past_key_values_length=past_key_values_length)
+
+ hidden_states = inputs_embeds + positions
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+ for idx, decoder_layer in enumerate(self.layers):
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ if self.training:
+ dropout_probability = torch.rand([])
+ if dropout_probability < self.layerdrop:
+ continue
+
+ hidden_states = decoder_layer(
+ hidden_states,
+ attention_mask,
+ encoder_hidden_states, # as a positional argument for gradient checkpointing
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = self.layer_norm(hidden_states)
+
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class Speech2TextModel(Speech2TextPreTrainedModel):
+ def __init__(self, config: Speech2TextConfig):
+ super().__init__(config)
+
+ self.encoder = Speech2TextEncoder(config)
+ self.decoder = Speech2TextDecoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.decoder.embed_tokens
+
+ def set_input_embeddings(self, value):
+ self.decoder.embed_tokens = value
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_features: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqLMOutput:
+ r"""
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`SpeechToTextTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ SpeechToText uses the `eos_token_id` as the starting token for `decoder_input_ids` generation. If
+ `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
+ `past_key_values`).
+ decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+
+ If you want to change padding behavior, you should read
+ [`modeling_speech_to_text._prepare_decoder_attention_mask`] and modify to your needs. See diagram 1 in [the
+ paper](https://huggingface.co/papers/1910.13461) for more information on the default strategy.
+
+ Example:
+
+ ```python
+ >>> import torch
+ >>> from transformers import Speech2TextModel, AutoFeatureExtractor
+ >>> from datasets import load_dataset
+
+ >>> model = Speech2TextModel.from_pretrained("facebook/s2t-small-librispeech-asr")
+ >>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/s2t-small-librispeech-asr")
+ >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
+ >>> inputs = feature_extractor(
+ ... ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
+ ... )
+ >>> input_features = inputs.input_features
+ >>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
+ >>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
+ >>> list(last_hidden_state.shape)
+ [1, 2, 256]
+ ```"""
+
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_features,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+ # If the user passed a tuple for encoder_outputs, we wrap it in a BaseModelOutput
+ elif not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ # downsample encoder attention mask
+ if attention_mask is not None:
+ encoder_attention_mask = self._get_feature_vector_attention_mask(
+ encoder_outputs[0].shape[1], attention_mask
+ )
+ else:
+ encoder_attention_mask = None
+
+ # decoder outputs consists of (dec_features, past_key_values, dec_hidden, dec_attn)
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ encoder_hidden_states=encoder_outputs[0],
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ inputs_embeds=decoder_inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return Seq2SeqModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ The Speech2Text Model with a language modeling head. Can be used for summarization.
+ """
+)
+class Speech2TextForConditionalGeneration(Speech2TextPreTrainedModel, GenerationMixin):
+ input_modalities = ("audio", "text")
+ base_model_prefix = "model"
+ _tied_weights_keys = {"lm_head.weight": "model.decoder.embed_tokens.weight"}
+
+ def __init__(self, config: Speech2TextConfig):
+ super().__init__(config)
+ self.model = Speech2TextModel(config)
+ self.lm_head = nn.Linear(config.d_model, self.config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_features: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqLMOutput:
+ r"""
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`SpeechToTextTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ SpeechToText uses the `eos_token_id` as the starting token for `decoder_input_ids` generation. If
+ `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
+ `past_key_values`).
+ decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+
+ If you want to change padding behavior, you should read
+ [`modeling_speech_to_text._prepare_decoder_attention_mask`] and modify to your needs. See diagram 1 in [the
+ paper](https://huggingface.co/papers/1910.13461) for more information on the default strategy.
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the language modeling loss. Indices should either be in `[0, ..., config.vocab_size]`
+ or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored (masked), the loss is
+ only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+ Example:
+
+ ```python
+ >>> import torch
+ >>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
+ >>> from datasets import load_dataset
+
+ >>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr")
+ >>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")
+
+
+ >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
+
+ >>> inputs = processor(
+ ... ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
+ ... )
+ >>> input_features = inputs.input_features
+
+ >>> generated_ids = model.generate(inputs=input_features)
+
+ >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+ >>> transcription
+ 'mister quilter is the apostle of the middle classes and we are glad to welcome his gospel'
+ ```"""
+ if labels is not None:
+ if decoder_input_ids is None and decoder_inputs_embeds is None:
+ decoder_input_ids = shift_tokens_right(
+ labels, self.config.pad_token_id, self.config.decoder_start_token_id
+ )
+
+ outputs: Seq2SeqModelOutput = self.model(
+ input_features,
+ attention_mask=attention_mask,
+ decoder_input_ids=decoder_input_ids,
+ encoder_outputs=encoder_outputs,
+ decoder_attention_mask=decoder_attention_mask,
+ past_key_values=past_key_values,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+ lm_logits = self.lm_head(outputs.last_hidden_state)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(lm_logits.view(-1, self.config.vocab_size), labels.view(-1))
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=lm_logits,
+ past_key_values=outputs.past_key_values,
+ decoder_hidden_states=outputs.decoder_hidden_states,
+ decoder_attentions=outputs.decoder_attentions,
+ cross_attentions=outputs.cross_attentions,
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+ encoder_hidden_states=outputs.encoder_hidden_states,
+ encoder_attentions=outputs.encoder_attentions,
+ )
+
+
+__all__ = ["Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/processing_speech_to_text.py b/lib/python3.11/site-packages/transformers/models/speech_to_text/processing_speech_to_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb381c942338d0e772db78afd49444c809ff647f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speech_to_text/processing_speech_to_text.py
@@ -0,0 +1,53 @@
+# Copyright 2021 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.
+"""
+Speech processor class for Speech2Text
+"""
+
+from ...processing_utils import ProcessorMixin
+from ...utils import auto_docstring
+
+
+@auto_docstring
+class Speech2TextProcessor(ProcessorMixin):
+ def __init__(self, feature_extractor, tokenizer):
+ super().__init__(feature_extractor, tokenizer)
+
+ @auto_docstring
+ def __call__(self, *args, **kwargs):
+ audio = kwargs.pop("audio", None)
+ sampling_rate = kwargs.pop("sampling_rate", None)
+ text = kwargs.pop("text", None)
+ if len(args) > 0:
+ audio = args[0]
+ args = args[1:]
+
+ if audio is None and text is None:
+ raise ValueError("You need to specify either an `audio` or `text` input to process.")
+
+ if audio is not None:
+ inputs = self.feature_extractor(audio, *args, sampling_rate=sampling_rate, **kwargs)
+ if text is not None:
+ encodings = self.tokenizer(text, **kwargs)
+
+ if text is None:
+ return inputs
+ elif audio is None:
+ return encodings
+ else:
+ inputs["labels"] = encodings["input_ids"]
+ return inputs
+
+
+__all__ = ["Speech2TextProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/speech_to_text/tokenization_speech_to_text.py b/lib/python3.11/site-packages/transformers/models/speech_to_text/tokenization_speech_to_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..9babee22fed6b6539e3818071fae32e62d243c8f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speech_to_text/tokenization_speech_to_text.py
@@ -0,0 +1,294 @@
+# Copyright 2021 The HuggingFace Inc. 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.
+"""Tokenization classes for Speech2Text."""
+
+import json
+import os
+from pathlib import Path
+from shutil import copyfile
+from typing import Any
+
+import sentencepiece
+
+from ...tokenization_python import PreTrainedTokenizer
+from ...utils import logging
+from ...utils.import_utils import requires
+
+
+logger = logging.get_logger(__name__)
+
+SPIECE_UNDERLINE = "▁"
+
+VOCAB_FILES_NAMES = {
+ "vocab_file": "vocab.json",
+ "spm_file": "sentencepiece.bpe.model",
+}
+
+
+MAX_MODEL_INPUT_SIZES = {
+ "facebook/s2t-small-librispeech-asr": 1024,
+}
+
+MUSTC_LANGS = ["pt", "fr", "ru", "nl", "ro", "it", "es", "de"]
+
+LANGUAGES = {"mustc": MUSTC_LANGS}
+
+
+@requires(backends=("sentencepiece",))
+class Speech2TextTokenizer(PreTrainedTokenizer):
+ """
+ Construct an Speech2Text tokenizer.
+
+ This tokenizer inherits from [`PreTrainedTokenizer`] which contains some of the main methods. Users should refer to
+ the superclass for more information regarding such methods.
+
+ Args:
+ vocab_file (`str`):
+ File containing the vocabulary.
+ spm_file (`str`):
+ Path to the [SentencePiece](https://github.com/google/sentencepiece) model file
+ bos_token (`str`, *optional*, defaults to `"<s>"`):
+ The beginning of sentence token.
+ eos_token (`str`, *optional*, defaults to `"</s>"`):
+ The end of sentence token.
+ unk_token (`str`, *optional*, defaults to `"<unk>"`):
+ The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
+ token instead.
+ pad_token (`str`, *optional*, defaults to `"<pad>"`):
+ The token used for padding, for example when batching sequences of different lengths.
+ do_upper_case (`bool`, *optional*, defaults to `False`):
+ Whether or not to uppercase the output when decoding.
+ do_lower_case (`bool`, *optional*, defaults to `False`):
+ Whether or not to lowercase the input when tokenizing.
+ tgt_lang (`str`, *optional*):
+ A string representing the target language.
+ sp_model_kwargs (`dict`, *optional*):
+ Will be passed to the `SentencePieceProcessor.__init__()` method. The [Python wrapper for
+ SentencePiece](https://github.com/google/sentencepiece/tree/master/python) can be used, among other things,
+ to set:
+
+ - `enable_sampling`: Enable subword regularization.
+ - `nbest_size`: Sampling parameters for unigram. Invalid for BPE-Dropout.
+
+ - `nbest_size = {0,1}`: No sampling is performed.
+ - `nbest_size > 1`: samples from the nbest_size results.
+ - `nbest_size < 0`: assuming that nbest_size is infinite and samples from the all hypothesis (lattice)
+ using forward-filtering-and-backward-sampling algorithm.
+
+ - `alpha`: Smoothing parameter for unigram sampling, and dropout probability of merge operations for
+ BPE-dropout.
+
+ **kwargs
+ Additional keyword arguments passed along to [`PreTrainedTokenizer`]
+ """
+
+ vocab_files_names = VOCAB_FILES_NAMES
+ model_input_names = ["input_ids", "attention_mask"]
+
+ prefix_tokens: list[int] = []
+
+ def __init__(
+ self,
+ vocab_file,
+ spm_file,
+ bos_token="<s>",
+ eos_token="</s>",
+ pad_token="<pad>",
+ unk_token="<unk>",
+ do_upper_case=False,
+ do_lower_case=False,
+ tgt_lang=None,
+ lang_codes=None,
+ additional_special_tokens=None,
+ sp_model_kwargs: dict[str, Any] | None = None,
+ **kwargs,
+ ) -> None:
+ self.sp_model_kwargs = {} if sp_model_kwargs is None else sp_model_kwargs
+
+ self.do_upper_case = do_upper_case
+ self.do_lower_case = do_lower_case
+
+ self.encoder = load_json(vocab_file)
+ self.decoder = {v: k for k, v in self.encoder.items()}
+ self.spm_file = spm_file
+ self.sp_model = load_spm(spm_file, self.sp_model_kwargs)
+
+ if lang_codes is not None:
+ self.lang_codes = lang_codes
+ self.langs = LANGUAGES[lang_codes]
+ self.lang_tokens = [f"<lang:{lang}>" for lang in self.langs]
+ self.lang_code_to_id = {lang: self.sp_model.PieceToId(f"<lang:{lang}>") for lang in self.langs}
+ if additional_special_tokens is not None:
+ additional_special_tokens = self.lang_tokens + additional_special_tokens
+ else:
+ additional_special_tokens = self.lang_tokens
+ self._tgt_lang = tgt_lang if tgt_lang is not None else self.langs[0]
+
+ self.set_tgt_lang_special_tokens(self._tgt_lang)
+ else:
+ self.lang_code_to_id = {}
+
+ super().__init__(
+ bos_token=bos_token,
+ eos_token=eos_token,
+ unk_token=unk_token,
+ pad_token=pad_token,
+ do_upper_case=do_upper_case,
+ do_lower_case=do_lower_case,
+ tgt_lang=tgt_lang,
+ lang_codes=lang_codes,
+ sp_model_kwargs=self.sp_model_kwargs,
+ additional_special_tokens=additional_special_tokens,
+ **kwargs,
+ )
+
+ @property
+ def vocab_size(self) -> int:
+ return len(self.encoder)
+
+ def get_vocab(self) -> dict:
+ vocab = self.encoder.copy()
+ vocab.update(self.added_tokens_encoder)
+ return vocab
+
+ @property
+ def tgt_lang(self) -> str | None:
+ return getattr(self, "_tgt_lang", None)
+
+ @tgt_lang.setter
+ def tgt_lang(self, new_tgt_lang) -> None:
+ self._tgt_lang = new_tgt_lang
+ self.set_tgt_lang_special_tokens(new_tgt_lang)
+
+ def set_tgt_lang_special_tokens(self, tgt_lang: str) -> None:
+ """Reset the special tokens to the target language setting. prefix=[eos, tgt_lang_code] and suffix=[eos]."""
+ lang_code_id = self.lang_code_to_id[tgt_lang]
+ self.prefix_tokens = [lang_code_id]
+
+ def _tokenize(self, text: str) -> list[str]:
+ return self.sp_model.encode(text, out_type=str)
+
+ def _convert_token_to_id(self, token):
+ return self.encoder.get(token, self.encoder[self.unk_token])
+
+ def _convert_id_to_token(self, index: int) -> str:
+ """Converts an index (integer) in a token (str) using the decoder."""
+ return self.decoder.get(index, self.unk_token)
+
+ def convert_tokens_to_string(self, tokens: list[str]) -> str:
+ """Converts a sequence of tokens (strings for sub-words) in a single string."""
+ current_sub_tokens = []
+ out_string = ""
+ for token in tokens:
+ # make sure that special tokens are not decoded using sentencepiece model
+ if token in self.all_special_tokens:
+ decoded = self.sp_model.decode(current_sub_tokens)
+ out_string += (decoded.upper() if self.do_upper_case else decoded) + token + " "
+ current_sub_tokens = []
+ else:
+ current_sub_tokens.append(token)
+ decoded = self.sp_model.decode(current_sub_tokens)
+ out_string += decoded.upper() if self.do_upper_case else decoded
+ return out_string.strip()
+
+ def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None) -> list[int]:
+ """Build model inputs from a sequence by appending eos_token_id."""
+ if token_ids_1 is None:
+ return self.prefix_tokens + token_ids_0 + [self.eos_token_id]
+ # We don't expect to process pairs, but leave the pair logic for API consistency
+ return self.prefix_tokens + token_ids_0 + token_ids_1 + [self.eos_token_id]
+
+ def get_special_tokens_mask(
+ self, token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False
+ ) -> list[int]:
+ """
+ Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
+ special tokens using the tokenizer `prepare_for_model` method.
+
+ Args:
+ token_ids_0 (`list[int]`):
+ List of IDs.
+ token_ids_1 (`list[int]`, *optional*):
+ Optional second list of IDs for sequence pairs.
+ already_has_special_tokens (`bool`, *optional*, defaults to `False`):
+ Whether or not the token list is already formatted with special tokens for the model.
+
+ Returns:
+ `list[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
+ """
+
+ if already_has_special_tokens:
+ return super().get_special_tokens_mask(
+ token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
+ )
+
+ prefix_ones = [1] * len(self.prefix_tokens)
+ suffix_ones = [1]
+ if token_ids_1 is None:
+ return prefix_ones + ([0] * len(token_ids_0)) + suffix_ones
+ return prefix_ones + ([0] * len(token_ids_0)) + ([0] * len(token_ids_1)) + suffix_ones
+
+ def __getstate__(self) -> dict:
+ state = self.__dict__.copy()
+ state["sp_model"] = None
+ return state
+
+ def __setstate__(self, d: dict) -> None:
+ self.__dict__ = d
+
+ # for backward compatibility
+ if not hasattr(self, "sp_model_kwargs"):
+ self.sp_model_kwargs = {}
+
+ self.sp_model = load_spm(self.spm_file, self.sp_model_kwargs)
+
+ def save_vocabulary(self, save_directory: str, filename_prefix: str | None = None) -> tuple[str]:
+ save_dir = Path(save_directory)
+ assert save_dir.is_dir(), f"{save_directory} should be a directory"
+ vocab_save_path = save_dir / (
+ (filename_prefix + "-" if filename_prefix else "") + self.vocab_files_names["vocab_file"]
+ )
+ spm_save_path = save_dir / (
+ (filename_prefix + "-" if filename_prefix else "") + self.vocab_files_names["spm_file"]
+ )
+
+ save_json(self.encoder, vocab_save_path)
+
+ if os.path.abspath(self.spm_file) != os.path.abspath(spm_save_path) and os.path.isfile(self.spm_file):
+ copyfile(self.spm_file, spm_save_path)
+ elif not os.path.isfile(self.spm_file):
+ with open(spm_save_path, "wb") as fi:
+ content_spiece_model = self.sp_model.serialized_model_proto()
+ fi.write(content_spiece_model)
+
+ return (str(vocab_save_path), str(spm_save_path))
+
+
+def load_spm(path: str, sp_model_kwargs: dict[str, Any]) -> sentencepiece.SentencePieceProcessor:
+ spm = sentencepiece.SentencePieceProcessor(**sp_model_kwargs)
+ spm.Load(str(path))
+ return spm
+
+
+def load_json(path: str) -> dict | list:
+ with open(path, "r") as f:
+ return json.load(f)
+
+
+def save_json(data, path: str) -> None:
+ with open(path, "w") as f:
+ json.dump(data, f, indent=2)
+
+
+__all__ = ["Speech2TextTokenizer"]
diff --git a/lib/python3.11/site-packages/transformers/models/speecht5/__init__.py b/lib/python3.11/site-packages/transformers/models/speecht5/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..52fee59ae9b96d14361a771cbc58089d5e5811f2
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speecht5/__init__.py
@@ -0,0 +1,30 @@
+# Copyright 2024 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_speecht5 import *
+ from .feature_extraction_speecht5 import *
+ from .modeling_speecht5 import *
+ from .processing_speecht5 import *
+ from .tokenization_speecht5 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/speecht5/configuration_speecht5.py b/lib/python3.11/site-packages/transformers/models/speecht5/configuration_speecht5.py
new file mode 100644
index 0000000000000000000000000000000000000000..82646d9f8927f0e848cb2ce4f9a4ecc6f810ab63
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speecht5/configuration_speecht5.py
@@ -0,0 +1,279 @@
+# Copyright 2023 The Fairseq Authors, Microsoft Research, and the HuggingFace Inc. 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.
+"""SpeechT5 model configuration"""
+
+import functools
+import operator
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="microsoft/speecht5_asr")
+@strict
+class SpeechT5Config(PreTrainedConfig):
+ r"""
+ positional_dropout (`float`, *optional*, defaults to 0.1):
+ The dropout probability for the text position encoding layers.
+ feat_extract_norm (`str`, *optional*, defaults to `"group"`):
+ The norm to be applied to 1D convolutional layers in the speech encoder pre-net. One of `"group"` for group
+ normalization of only the first 1D convolutional layer or `"layer"` for layer normalization of all 1D
+ convolutional layers.
+ feat_proj_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout probability for output of the speech encoder pre-net.
+ feat_extract_activation (`str, `optional`, defaults to `"gelu"`):
+ The non-linear activation function (function or string) in the 1D convolutional layers of the feature
+ extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported.
+ conv_dim (`tuple[int]` or `list[int]`, *optional*, defaults to `(512, 512, 512, 512, 512, 512, 512)`):
+ A tuple of integers defining the number of input and output channels of each 1D convolutional layer in the
+ speech encoder pre-net. The length of *conv_dim* defines the number of 1D convolutional layers.
+ conv_stride (`tuple[int]` or `list[int]`, *optional*, defaults to `(5, 2, 2, 2, 2, 2, 2)`):
+ A tuple of integers defining the stride of each 1D convolutional layer in the speech encoder pre-net. The
+ length of *conv_stride* defines the number of convolutional layers and has to match the length of
+ *conv_dim*.
+ conv_kernel (`tuple[int]` or `list[int]`, *optional*, defaults to `(10, 3, 3, 3, 3, 3, 3)`):
+ A tuple of integers defining the kernel size of each 1D convolutional layer in the speech encoder pre-net.
+ The length of *conv_kernel* defines the number of convolutional layers and has to match the length of
+ *conv_dim*.
+ conv_bias (`bool`, *optional*, defaults to `False`):
+ Whether the 1D convolutional layers have a bias.
+ num_conv_pos_embeddings (`int`, *optional*, defaults to 128):
+ Number of convolutional positional embeddings. Defines the kernel size of 1D convolutional positional
+ embeddings layer.
+ num_conv_pos_embedding_groups (`int`, *optional*, defaults to 16):
+ Number of groups of 1D convolutional positional embeddings layer.
+ apply_spec_augment (`bool`, *optional*, defaults to `True`):
+ Whether to apply *SpecAugment* data augmentation to the outputs of the speech encoder pre-net. For
+ reference see [SpecAugment: A Simple Data Augmentation Method for Automatic Speech
+ Recognition](https://huggingface.co/papers/1904.08779).
+ mask_time_prob (`float`, *optional*, defaults to 0.05):
+ Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking
+ procedure generates ''mask_time_prob*len(time_axis)/mask_time_length'' independent masks over the axis. If
+ reasoning from the probability of each feature vector to be chosen as the start of the vector span to be
+ masked, *mask_time_prob* should be `prob_vector_start*mask_time_length`. Note that overlap may decrease the
+ actual percentage of masked vectors. This is only relevant if `apply_spec_augment is True`.
+ mask_time_length (`int`, *optional*, defaults to 10):
+ Length of vector span along the time axis.
+ mask_time_min_masks (`int`, *optional*, defaults to 2),:
+ The minimum number of masks of length `mask_feature_length` generated along the time axis, each time step,
+ irrespectively of `mask_feature_prob`. Only relevant if ''mask_time_prob*len(time_axis)/mask_time_length <
+ mask_time_min_masks''
+ mask_feature_prob (`float`, *optional*, defaults to 0.0):
+ Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The
+ masking procedure generates ''mask_feature_prob*len(feature_axis)/mask_time_length'' independent masks over
+ the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector
+ span to be masked, *mask_feature_prob* should be `prob_vector_start*mask_feature_length`. Note that overlap
+ may decrease the actual percentage of masked vectors. This is only relevant if `apply_spec_augment is
+ True`.
+ mask_feature_length (`int`, *optional*, defaults to 10):
+ Length of vector span along the feature axis.
+ mask_feature_min_masks (`int`, *optional*, defaults to 0),:
+ The minimum number of masks of length `mask_feature_length` generated along the feature axis, each time
+ step, irrespectively of `mask_feature_prob`. Only relevant if
+ ''mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks''
+ num_mel_bins (`int`, *optional*, defaults to 80):
+ Number of mel features used per input features. Used by the speech decoder pre-net. Should correspond to
+ the value used in the [`SpeechT5Processor`] class.
+ speech_decoder_prenet_layers (`int`, *optional*, defaults to 2):
+ Number of layers in the speech decoder pre-net.
+ speech_decoder_prenet_units (`int`, *optional*, defaults to 256):
+ Dimensionality of the layers in the speech decoder pre-net.
+ speech_decoder_prenet_dropout (`float`, *optional*, defaults to 0.5):
+ The dropout probability for the speech decoder pre-net layers.
+ speaker_embedding_dim (`int`, *optional*, defaults to 512):
+ Dimensionality of the *XVector* embedding vectors.
+ speech_decoder_postnet_layers (`int`, *optional*, defaults to 5):
+ Number of layers in the speech decoder post-net.
+ speech_decoder_postnet_units (`int`, *optional*, defaults to 256):
+ Dimensionality of the layers in the speech decoder post-net.
+ speech_decoder_postnet_kernel (`int`, *optional*, defaults to 5):
+ Number of convolutional filter channels in the speech decoder post-net.
+ speech_decoder_postnet_dropout (`float`, *optional*, defaults to 0.5):
+ The dropout probability for the speech decoder post-net layers.
+ reduction_factor (`int`, *optional*, defaults to 2):
+ Spectrogram length reduction factor for the speech decoder inputs.
+ max_speech_positions (`int`, *optional*, defaults to 4000):
+ The maximum sequence length of speech features that this model might ever be used with.
+ max_text_positions (`int`, *optional*, defaults to 450):
+ The maximum sequence length of text features that this model might ever be used with.
+ encoder_max_relative_position (`int`, *optional*, defaults to 160):
+ Maximum distance for relative position embedding in the encoder.
+ use_guided_attention_loss (`bool`, *optional*, defaults to `True`):
+ Whether to apply guided attention loss while training the TTS model.
+ guided_attention_loss_num_heads (`int`, *optional*, defaults to 2):
+ Number of attention heads the guided attention loss will be applied to. Use -1 to apply this loss to all
+ attention heads.
+ guided_attention_loss_sigma (`float`, *optional*, defaults to 0.4):
+ Standard deviation for guided attention loss.
+ guided_attention_loss_scale (`float`, *optional*, defaults to 10.0):
+ Scaling coefficient for guided attention loss (also known as lambda).
+
+ Example:
+
+ ```python
+ >>> from transformers import SpeechT5Model, SpeechT5Config
+
+ >>> # Initializing a "microsoft/speecht5_asr" style configuration
+ >>> configuration = SpeechT5Config()
+
+ >>> # Initializing a model (with random weights) from the "microsoft/speecht5_asr" style configuration
+ >>> model = SpeechT5Model(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "speecht5"
+ attribute_map = {"num_attention_heads": "encoder_attention_heads", "num_hidden_layers": "encoder_layers"}
+
+ vocab_size: int = 81
+ hidden_size: int = 768
+ encoder_layers: int = 12
+ encoder_attention_heads: int = 12
+ encoder_ffn_dim: int = 3072
+ encoder_layerdrop: float | int = 0.1
+ decoder_layers: int = 6
+ decoder_ffn_dim: int = 3072
+ decoder_attention_heads: int = 12
+ decoder_layerdrop: float | int = 0.1
+ hidden_act: str = "gelu"
+ positional_dropout: float | int = 0.1
+ hidden_dropout: float | int = 0.1
+ attention_dropout: float | int = 0.1
+ activation_dropout: float | int = 0.1
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-5
+ scale_embedding: bool = False
+ feat_extract_norm: str = "group"
+ feat_proj_dropout: float | int = 0.0
+ feat_extract_activation: str = "gelu"
+ conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)
+ conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)
+ conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)
+ conv_bias: bool = False
+ num_conv_pos_embeddings: int = 128
+ num_conv_pos_embedding_groups: int = 16
+ apply_spec_augment: bool = True
+ mask_time_prob: float | int = 0.05
+ mask_time_length: int = 10
+ mask_time_min_masks: int = 2
+ mask_feature_prob: float | int = 0.0
+ mask_feature_length: int = 10
+ mask_feature_min_masks: int = 0
+ pad_token_id: int | None = 1
+ bos_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 2
+ decoder_start_token_id: int | None = 2
+ num_mel_bins: int = 80
+ speech_decoder_prenet_layers: int = 2
+ speech_decoder_prenet_units: int = 256
+ speech_decoder_prenet_dropout: float | int = 0.5
+ speaker_embedding_dim: int = 512
+ speech_decoder_postnet_layers: int = 5
+ speech_decoder_postnet_units: int = 256
+ speech_decoder_postnet_kernel: int = 5
+ speech_decoder_postnet_dropout: float | int = 0.5
+ reduction_factor: int = 2
+ max_speech_positions: int = 4000
+ max_text_positions: int = 450
+ encoder_max_relative_position: int = 160
+ use_guided_attention_loss: bool = True
+ guided_attention_loss_num_heads: int = 2
+ guided_attention_loss_sigma: float = 0.4
+ guided_attention_loss_scale: float = 10.0
+ use_cache: bool = True
+ is_encoder_decoder: bool = True
+ tie_word_embeddings: bool = True
+
+ def __post_init__(self, **kwargs):
+ self.num_feat_extract_layers = len(self.conv_dim)
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if (
+ (len(self.conv_stride) != self.num_feat_extract_layers)
+ or (len(self.conv_kernel) != self.num_feat_extract_layers)
+ or (len(self.conv_dim) != self.num_feat_extract_layers)
+ ):
+ raise ValueError(
+ "Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="
+ " `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="
+ f" {len(self.conv_dim)}`, `len(config.conv_stride) = {len(self.conv_stride)}`,"
+ f" `len(config.conv_kernel) = {len(self.conv_kernel)}`."
+ )
+
+ def inputs_to_logits_ratio(self):
+ return functools.reduce(operator.mul, self.conv_stride, 1)
+
+
+@auto_docstring(checkpoint="microsoft/speecht5_asr")
+@strict
+class SpeechT5HifiGanConfig(PreTrainedConfig):
+ r"""
+ model_in_dim (`int`, *optional*, defaults to 80):
+ The number of frequency bins in the input log-mel spectrogram.
+ upsample_initial_channel (`int`, *optional*, defaults to 512):
+ The number of input channels into the upsampling network.
+ upsample_rates (`tuple[int]` or `list[int]`, *optional*, defaults to `[4, 4, 4, 4]`):
+ A tuple of integers defining the stride of each 1D convolutional layer in the upsampling network. The
+ length of *upsample_rates* defines the number of convolutional layers and has to match the length of
+ *upsample_kernel_sizes*.
+ upsample_kernel_sizes (`tuple[int]` or `list[int]`, *optional*, defaults to `[8, 8, 8, 8]`):
+ A tuple of integers defining the kernel size of each 1D convolutional layer in the upsampling network. The
+ length of *upsample_kernel_sizes* defines the number of convolutional layers and has to match the length of
+ *upsample_rates*.
+ resblock_kernel_sizes (`tuple[int]` or `list[int]`, *optional*, defaults to `[3, 7, 11]`):
+ A tuple of integers defining the kernel sizes of the 1D convolutional layers in the multi-receptive field
+ fusion (MRF) module.
+ resblock_dilation_sizes (`tuple[tuple[int]]` or `list[list[int]]`, *optional*, defaults to `[[1, 3, 5], [1, 3, 5], [1, 3, 5]]`):
+ A nested tuple of integers defining the dilation rates of the dilated 1D convolutional layers in the
+ multi-receptive field fusion (MRF) module.
+ leaky_relu_slope (`float`, *optional*, defaults to 0.1):
+ The angle of the negative slope used by the leaky ReLU activation.
+ normalize_before (`bool`, *optional*, defaults to `True`):
+ Whether or not to normalize the spectrogram before vocoding using the vocoder's learned mean and variance.
+
+ Example:
+
+ ```python
+ >>> from transformers import SpeechT5HifiGan, SpeechT5HifiGanConfig
+
+ >>> # Initializing a "microsoft/speecht5_hifigan" style configuration
+ >>> configuration = SpeechT5HifiGanConfig()
+
+ >>> # Initializing a model (with random weights) from the "microsoft/speecht5_hifigan" style configuration
+ >>> model = SpeechT5HifiGan(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "speecht5_hifigan"
+
+ model_in_dim: int = 80
+ sampling_rate: int = 16000
+ upsample_initial_channel: int = 512
+ upsample_rates: list[int] | tuple[int, ...] = (4, 4, 4, 4)
+ upsample_kernel_sizes: list[int] | tuple[int, ...] = (8, 8, 8, 8)
+ resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11)
+ resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5))
+ initializer_range: float = 0.01
+ leaky_relu_slope: float = 0.1
+ normalize_before: bool = True
+
+
+__all__ = ["SpeechT5Config", "SpeechT5HifiGanConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/speecht5/feature_extraction_speecht5.py b/lib/python3.11/site-packages/transformers/models/speecht5/feature_extraction_speecht5.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b9ca2e1f954ebeeb520dbb965b08c9a3b0e2d73
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speecht5/feature_extraction_speecht5.py
@@ -0,0 +1,374 @@
+# Copyright 2023 The HuggingFace Inc. 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.
+"""Feature extractor class for SpeechT5."""
+
+from typing import Any
+
+import numpy as np
+
+from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
+from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
+from ...feature_extraction_utils import BatchFeature
+from ...utils import PaddingStrategy, TensorType, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class SpeechT5FeatureExtractor(SequenceFeatureExtractor):
+ r"""
+ Constructs a SpeechT5 feature extractor.
+
+ This class can pre-process a raw speech signal by (optionally) normalizing to zero-mean unit-variance, for use by
+ the SpeechT5 speech encoder prenet.
+
+ This class can also extract log-mel filter bank features from raw speech, for use by the SpeechT5 speech decoder
+ prenet.
+
+ This feature extractor inherits from [`~feature_extraction_sequence_utils.SequenceFeatureExtractor`] which contains
+ most of the main methods. Users should refer to this superclass for more information regarding those methods.
+
+ Args:
+ feature_size (`int`, *optional*, defaults to 1):
+ The feature dimension of the extracted features.
+ sampling_rate (`int`, *optional*, defaults to 16000):
+ The sampling rate at which the audio files should be digitalized expressed in hertz (Hz).
+ padding_value (`float`, *optional*, defaults to 0.0):
+ The value that is used to fill the padding values.
+ do_normalize (`bool`, *optional*, defaults to `False`):
+ Whether or not to zero-mean unit-variance normalize the input. Normalizing can help to significantly
+ improve the performance for some models.
+ num_mel_bins (`int`, *optional*, defaults to 80):
+ The number of mel-frequency bins in the extracted spectrogram features.
+ hop_length (`int`, *optional*, defaults to 16):
+ Number of ms between windows. Otherwise referred to as "shift" in many papers.
+ win_length (`int`, *optional*, defaults to 64):
+ Number of ms per window.
+ win_function (`str`, *optional*, defaults to `"hann_window"`):
+ Name for the window function used for windowing, must be accessible via `torch.{win_function}`
+ fmin (`float`, *optional*, defaults to 80):
+ Minimum mel frequency in Hz.
+ fmax (`float`, *optional*, defaults to 7600):
+ Maximum mel frequency in Hz.
+ mel_floor (`float`, *optional*, defaults to 1e-10):
+ Minimum value of mel frequency banks..
+ return_attention_mask (`bool`, *optional*, defaults to `True`):
+ Whether or not [`~SpeechT5FeatureExtractor.__call__`] should return `attention_mask`.
+ """
+
+ model_input_names = ["input_values", "attention_mask"]
+
+ def __init__(
+ self,
+ feature_size: int = 1,
+ sampling_rate: int = 16000,
+ padding_value: float = 0.0,
+ do_normalize: bool = False,
+ num_mel_bins: int = 80,
+ hop_length: int = 16,
+ win_length: int = 64,
+ win_function: str = "hann_window",
+ fmin: float = 80,
+ fmax: float = 7600,
+ mel_floor: float = 1e-10,
+ return_attention_mask: bool = True,
+ **kwargs,
+ ):
+ super().__init__(feature_size=feature_size, sampling_rate=sampling_rate, padding_value=padding_value, **kwargs)
+ self.do_normalize = do_normalize
+ self.return_attention_mask = return_attention_mask
+
+ self.num_mel_bins = num_mel_bins
+ self.hop_length = hop_length
+ self.win_length = win_length
+ self.win_function = win_function
+ self.fmin = fmin
+ self.fmax = fmax
+ self.mel_floor = mel_floor
+
+ self.sample_size = win_length * sampling_rate // 1000
+ self.sample_stride = hop_length * sampling_rate // 1000
+ self.n_fft = optimal_fft_length(self.sample_size)
+ self.n_freqs = (self.n_fft // 2) + 1
+
+ self.window = window_function(window_length=self.sample_size, name=self.win_function, periodic=True)
+
+ self.mel_filters = mel_filter_bank(
+ num_frequency_bins=self.n_freqs,
+ num_mel_filters=self.num_mel_bins,
+ min_frequency=self.fmin,
+ max_frequency=self.fmax,
+ sampling_rate=self.sampling_rate,
+ norm="slaney",
+ mel_scale="slaney",
+ )
+
+ @staticmethod
+ # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
+ def zero_mean_unit_var_norm(
+ input_values: list[np.ndarray], attention_mask: list[np.ndarray], padding_value: float = 0.0
+ ) -> list[np.ndarray]:
+ """
+ Every array in the list is normalized to have zero mean and unit variance
+ """
+ if attention_mask is not None:
+ attention_mask = np.array(attention_mask, np.int32)
+ normed_input_values = []
+
+ for vector, length in zip(input_values, attention_mask.sum(-1)):
+ normed_slice = (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7)
+ if length < normed_slice.shape[0]:
+ normed_slice[length:] = padding_value
+
+ normed_input_values.append(normed_slice)
+ else:
+ normed_input_values = [(x - x.mean()) / np.sqrt(x.var() + 1e-7) for x in input_values]
+
+ return normed_input_values
+
+ def _extract_mel_features(
+ self,
+ one_waveform: np.ndarray,
+ ) -> np.ndarray:
+ """
+ Extracts log-mel filterbank features for one waveform array (unbatched).
+ """
+ log_mel_spec = spectrogram(
+ one_waveform,
+ window=self.window,
+ frame_length=self.sample_size,
+ hop_length=self.sample_stride,
+ fft_length=self.n_fft,
+ mel_filters=self.mel_filters,
+ mel_floor=self.mel_floor,
+ log_mel="log10",
+ )
+ return log_mel_spec.T
+
+ def __call__(
+ self,
+ audio: np.ndarray | list[float] | list[np.ndarray] | list[list[float]] | None = None,
+ audio_target: np.ndarray | list[float] | list[np.ndarray] | list[list[float]] | None = None,
+ padding: bool | str | PaddingStrategy = False,
+ max_length: int | None = None,
+ truncation: bool = False,
+ pad_to_multiple_of: int | None = None,
+ return_attention_mask: bool | None = None,
+ return_tensors: str | TensorType | None = None,
+ sampling_rate: int | None = None,
+ **kwargs,
+ ) -> BatchFeature:
+ """
+ Main method to featurize and prepare for the model one or several sequence(s).
+
+ Pass in a value for `audio` to extract waveform features. Pass in a value for `audio_target` to extract log-mel
+ spectrogram features.
+
+ Args:
+ audio (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`, *optional*):
+ The sequence or batch of sequences to be processed. Each sequence can be a numpy array, a list of float
+ values, a list of numpy arrays or a list of list of float values. This outputs waveform features. Must
+ be mono channel audio, not stereo, i.e. single float per timestep.
+ audio_target (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`, *optional*):
+ The sequence or batch of sequences to be processed as targets. Each sequence can be a numpy array, a
+ list of float values, a list of numpy arrays or a list of list of float values. This outputs log-mel
+ spectrogram features.
+ padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):
+ Select a strategy to pad the returned sequences (according to the model's padding side and padding
+ index) among:
+
+ - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+ sequence if provided).
+ - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
+ acceptable input length for the model if that argument is not provided.
+ - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
+ lengths).
+ max_length (`int`, *optional*):
+ Maximum length of the returned list and optionally padding length (see above).
+ truncation (`bool`):
+ Activates truncation to cut input sequences longer than *max_length* to *max_length*.
+ pad_to_multiple_of (`int`, *optional*):
+ If set will pad the sequence to a multiple of the provided value.
+
+ This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability
+ `>= 7.5` (Volta), or on TPUs which benefit from having sequence lengths be a multiple of 128.
+ return_attention_mask (`bool`, *optional*):
+ Whether to return the attention mask. If left to the default, will return the attention mask according
+ to the specific feature_extractor's default.
+
+ [What are attention masks?](../glossary#attention-mask)
+
+ return_tensors (`str` or [`~utils.TensorType`], *optional*):
+ If set, will return tensors instead of list of python integers. Acceptable values are:
+
+ - `'pt'`: Return PyTorch `torch.Tensor` objects.
+ - `'np'`: Return Numpy `np.ndarray` objects.
+ sampling_rate (`int`, *optional*):
+ The sampling rate at which the `audio` or `audio_target` input was sampled. It is strongly recommended
+ to pass `sampling_rate` at the forward call to prevent silent errors.
+ """
+ if audio is None and audio_target is None:
+ raise ValueError("You must provide either `audio` or `audio_target` values.")
+
+ if sampling_rate is not None:
+ if sampling_rate != self.sampling_rate:
+ raise ValueError(
+ f"The model corresponding to this feature extractor: {self} was trained using a sampling rate of"
+ f" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"
+ f" {self.sampling_rate} and not {sampling_rate}."
+ )
+ else:
+ logger.warning(
+ f"It is strongly recommended to pass the `sampling_rate` argument to `{self.__class__.__name__}()`. "
+ "Failing to do so can result in silent errors that might be hard to debug."
+ )
+
+ if audio is not None:
+ inputs = self._process_audio(
+ audio,
+ False,
+ padding,
+ max_length,
+ truncation,
+ pad_to_multiple_of,
+ return_attention_mask,
+ return_tensors,
+ **kwargs,
+ )
+ else:
+ inputs = None
+
+ if audio_target is not None:
+ inputs_target = self._process_audio(
+ audio_target,
+ True,
+ padding,
+ max_length,
+ truncation,
+ pad_to_multiple_of,
+ return_attention_mask,
+ return_tensors,
+ **kwargs,
+ )
+
+ if inputs is None:
+ return inputs_target
+ else:
+ inputs["labels"] = inputs_target["input_values"]
+ decoder_attention_mask = inputs_target.get("attention_mask")
+ if decoder_attention_mask is not None:
+ inputs["decoder_attention_mask"] = decoder_attention_mask
+
+ return inputs
+
+ def _process_audio(
+ self,
+ speech: np.ndarray | list[float] | list[np.ndarray] | list[list[float]],
+ is_target: bool = False,
+ padding: bool | str | PaddingStrategy = False,
+ max_length: int | None = None,
+ truncation: bool = False,
+ pad_to_multiple_of: int | None = None,
+ return_attention_mask: bool | None = None,
+ return_tensors: str | TensorType | None = None,
+ **kwargs,
+ ) -> BatchFeature:
+ is_batched_numpy = isinstance(speech, np.ndarray) and len(speech.shape) > 1
+ if is_batched_numpy and len(speech.shape) > 2:
+ raise ValueError(f"Only mono-channel audio is supported for input to {self}")
+ is_batched = is_batched_numpy or (
+ isinstance(speech, (list, tuple)) and (isinstance(speech[0], (np.ndarray, tuple, list)))
+ )
+
+ if is_batched:
+ speech = [np.asarray(speech, dtype=np.float32) for speech in speech]
+ elif not is_batched and not isinstance(speech, np.ndarray):
+ speech = np.asarray(speech, dtype=np.float32)
+ elif isinstance(speech, np.ndarray) and speech.dtype is np.dtype(np.float64):
+ speech = speech.astype(np.float32)
+
+ # always return batch
+ if not is_batched:
+ speech = [speech]
+
+ # needed to make pad() work on spectrogram inputs
+ feature_size_hack = self.feature_size
+
+ # convert into correct format for padding
+ if is_target:
+ features = [self._extract_mel_features(waveform) for waveform in speech]
+ encoded_inputs = BatchFeature({"input_values": features})
+ self.feature_size = self.num_mel_bins
+ else:
+ encoded_inputs = BatchFeature({"input_values": speech})
+
+ padded_inputs = self.pad(
+ encoded_inputs,
+ padding=padding,
+ max_length=max_length,
+ truncation=truncation,
+ pad_to_multiple_of=pad_to_multiple_of,
+ return_attention_mask=return_attention_mask,
+ **kwargs,
+ )
+
+ self.feature_size = feature_size_hack
+
+ # convert input values to correct format
+ input_values = padded_inputs["input_values"]
+ if not isinstance(input_values[0], np.ndarray):
+ padded_inputs["input_values"] = [np.asarray(array, dtype=np.float32) for array in input_values]
+ elif (
+ not isinstance(input_values, np.ndarray)
+ and isinstance(input_values[0], np.ndarray)
+ and input_values[0].dtype is np.dtype(np.float64)
+ ):
+ padded_inputs["input_values"] = [array.astype(np.float32) for array in input_values]
+ elif isinstance(input_values, np.ndarray) and input_values.dtype is np.dtype(np.float64):
+ padded_inputs["input_values"] = input_values.astype(np.float32)
+
+ # convert attention_mask to correct format
+ attention_mask = padded_inputs.get("attention_mask")
+ if attention_mask is not None:
+ padded_inputs["attention_mask"] = [np.asarray(array, dtype=np.int32) for array in attention_mask]
+
+ # zero-mean and unit-variance normalization
+ if not is_target and self.do_normalize:
+ attention_mask = (
+ attention_mask
+ if self._get_padding_strategies(padding, max_length=max_length) is not PaddingStrategy.DO_NOT_PAD
+ else None
+ )
+ padded_inputs["input_values"] = self.zero_mean_unit_var_norm(
+ padded_inputs["input_values"], attention_mask=attention_mask, padding_value=self.padding_value
+ )
+
+ if return_tensors is not None:
+ padded_inputs = padded_inputs.convert_to_tensors(return_tensors)
+
+ return padded_inputs
+
+ def to_dict(self) -> dict[str, Any]:
+ output = super().to_dict()
+
+ # Don't serialize these as they are derived from the other properties.
+ names = ["window", "mel_filters", "sample_size", "sample_stride", "n_fft", "n_freqs"]
+ for name in names:
+ if name in output:
+ del output[name]
+
+ return output
+
+
+__all__ = ["SpeechT5FeatureExtractor"]
diff --git a/lib/python3.11/site-packages/transformers/models/speecht5/modeling_speecht5.py b/lib/python3.11/site-packages/transformers/models/speecht5/modeling_speecht5.py
new file mode 100644
index 0000000000000000000000000000000000000000..f75fa9dcdcd9e9b9de5d7b5e2ceaeb2c9038de6f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/speecht5/modeling_speecht5.py
@@ -0,0 +1,3095 @@
+# Copyright 2023 The Fairseq Authors, Microsoft Research, and the HuggingFace Inc. 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.
+"""PyTorch SpeechT5 model."""
+
+import math
+
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, L1Loss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...integrations.deepspeed import is_deepspeed_zero3_enabled
+from ...integrations.fsdp import is_fsdp_managed_module
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ BaseModelOutputWithPastAndCrossAttentions,
+ Seq2SeqLMOutput,
+ Seq2SeqModelOutput,
+ Seq2SeqSpectrogramOutput,
+)
+from ...modeling_utils import EmbeddingAccessMixin, PreTrainedModel
+from ...utils import auto_docstring, logging
+from .configuration_speecht5 import SpeechT5Config, SpeechT5HifiGanConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+_HIDDEN_STATES_START_POSITION = 1
+
+# General docstring
+
+
+# Copied from transformers.models.bart.modeling_bart.shift_tokens_right
+def shift_tokens_right(input_ids: torch.Tensor, pad_token_id: int, decoder_start_token_id: int):
+ """
+ Shift input ids one token to the right.
+ """
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[:, 1:] = input_ids[:, :-1].clone()
+ shifted_input_ids[:, 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.pad_token_id has to be defined.")
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+def shift_spectrograms_right(
+ input_values: torch.Tensor, reduction_factor: int = 1, attention_mask: torch.Tensor | None = None
+):
+ """
+ Shift input spectrograms one timestep to the right. Also applies the reduction factor to the sequence length.
+ """
+ # thin out frames for reduction factor
+ if reduction_factor > 1:
+ input_values = input_values[:, reduction_factor - 1 :: reduction_factor]
+ if attention_mask is not None:
+ attention_mask = attention_mask[:, reduction_factor - 1 :: reduction_factor]
+
+ shifted_input_values = input_values.new_zeros(input_values.shape)
+ shifted_input_values[:, 1:] = input_values[:, :-1].clone()
+
+ # replace possible -100 values in labels by zeros
+ shifted_input_values.masked_fill_(shifted_input_values == -100.0, 0.0)
+
+ return shifted_input_values, attention_mask
+
+
+# Copied from transformers.models.wav2vec2.modeling_wav2vec2._compute_mask_indices
+def _compute_mask_indices(
+ shape: tuple[int, int],
+ mask_prob: float,
+ mask_length: int,
+ attention_mask: torch.LongTensor | None = None,
+ min_masks: int = 0,
+) -> np.ndarray:
+ """
+ Computes random mask spans for a given shape. Used to implement [SpecAugment: A Simple Data Augmentation Method for
+ ASR](https://huggingface.co/papers/1904.08779). Note that this method is not optimized to run on TPU and should be run on
+ CPU as part of the preprocessing during training.
+
+ Args:
+ shape: The shape for which to compute masks. This should be of a tuple of size 2 where
+ the first element is the batch size and the second element is the length of the axis to span.
+ mask_prob: The percentage of the whole axis (between 0 and 1) which will be masked. The number of
+ independently generated mask spans of length `mask_length` is computed by
+ `mask_prob*shape[1]/mask_length`. Note that due to overlaps, `mask_prob` is an upper bound and the
+ actual percentage will be smaller.
+ mask_length: size of the mask
+ min_masks: minimum number of masked spans
+ attention_mask: A (right-padded) attention mask which independently shortens the feature axis of
+ each batch dimension.
+ """
+ batch_size, sequence_length = shape
+
+ if mask_length < 1:
+ raise ValueError("`mask_length` has to be bigger than 0.")
+
+ if mask_length > sequence_length:
+ raise ValueError(
+ f"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length}"
+ f" and `sequence_length`: {sequence_length}`"
+ )
+
+ # epsilon is used for probabilistic rounding
+ epsilon = np.random.rand(1).item()
+
+ def compute_num_masked_span(input_length):
+ """Given input length, compute how many spans should be masked"""
+ num_masked_span = int(mask_prob * input_length / mask_length + epsilon)
+ num_masked_span = max(num_masked_span, min_masks)
+
+ # make sure num masked span <= sequence_length
+ if num_masked_span * mask_length > sequence_length:
+ num_masked_span = sequence_length // mask_length
+
+ # make sure num_masked span is also <= input_length - (mask_length - 1)
+ if input_length - (mask_length - 1) < num_masked_span:
+ num_masked_span = max(input_length - (mask_length - 1), 0)
+
+ return num_masked_span
+
+ # compute number of masked spans in batch
+ input_lengths = (
+ attention_mask.detach().sum(-1).tolist()
+ if attention_mask is not None
+ else [sequence_length for _ in range(batch_size)]
+ )
+
+ # SpecAugment mask to fill
+ spec_aug_mask = np.zeros((batch_size, sequence_length), dtype=bool)
+ spec_aug_mask_idxs = []
+
+ max_num_masked_span = compute_num_masked_span(sequence_length)
+
+ if max_num_masked_span == 0:
+ return spec_aug_mask
+
+ for input_length in input_lengths:
+ # compute num of masked spans for this input
+ num_masked_span = compute_num_masked_span(input_length)
+
+ # get random indices to mask
+ spec_aug_mask_idx = np.random.choice(
+ np.arange(input_length - (mask_length - 1)), num_masked_span, replace=False
+ )
+
+ # pick first sampled index that will serve as a dummy index to pad vector
+ # to ensure same dimension for all batches due to probabilistic rounding
+ # Picking first sample just pads those vectors twice.
+ if len(spec_aug_mask_idx) == 0:
+ # this case can only happen if `input_length` is strictly smaller then
+ # `sequence_length` in which case the last token has to be a padding
+ # token which we can use as a dummy mask id
+ dummy_mask_idx = sequence_length - 1
+ else:
+ dummy_mask_idx = spec_aug_mask_idx[0]
+
+ spec_aug_mask_idx = np.concatenate(
+ [spec_aug_mask_idx, np.ones(max_num_masked_span - num_masked_span, dtype=np.int32) * dummy_mask_idx]
+ )
+ spec_aug_mask_idxs.append(spec_aug_mask_idx)
+
+ spec_aug_mask_idxs = np.array(spec_aug_mask_idxs)
+
+ # expand masked indices to masked spans
+ spec_aug_mask_idxs = np.broadcast_to(
+ spec_aug_mask_idxs[:, :, None], (batch_size, max_num_masked_span, mask_length)
+ )
+ spec_aug_mask_idxs = spec_aug_mask_idxs.reshape(batch_size, max_num_masked_span * mask_length)
+
+ # add offset to the starting indexes so that indexes now create a span
+ offsets = np.arange(mask_length)[None, None, :]
+ offsets = np.broadcast_to(offsets, (batch_size, max_num_masked_span, mask_length)).reshape(
+ batch_size, max_num_masked_span * mask_length
+ )
+ spec_aug_mask_idxs = spec_aug_mask_idxs + offsets
+
+ # ensure that we cannot have indices larger than sequence_length
+ if spec_aug_mask_idxs.max() > sequence_length - 1:
+ spec_aug_mask_idxs[spec_aug_mask_idxs > sequence_length - 1] = sequence_length - 1
+
+ # scatter indices to mask
+ np.put_along_axis(spec_aug_mask, spec_aug_mask_idxs, 1, -1)
+
+ return spec_aug_mask
+
+
+# Copied from transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2NoLayerNormConvLayer with Wav2Vec2->SpeechT5
+class SpeechT5NoLayerNormConvLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.conv_dim[layer_id - 1] if layer_id > 0 else 1
+ self.out_conv_dim = config.conv_dim[layer_id]
+
+ self.conv = nn.Conv1d(
+ self.in_conv_dim,
+ self.out_conv_dim,
+ kernel_size=config.conv_kernel[layer_id],
+ stride=config.conv_stride[layer_id],
+ bias=config.conv_bias,
+ )
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2LayerNormConvLayer with Wav2Vec2->SpeechT5
+class SpeechT5LayerNormConvLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.conv_dim[layer_id - 1] if layer_id > 0 else 1
+ self.out_conv_dim = config.conv_dim[layer_id]
+
+ self.conv = nn.Conv1d(
+ self.in_conv_dim,
+ self.out_conv_dim,
+ kernel_size=config.conv_kernel[layer_id],
+ stride=config.conv_stride[layer_id],
+ bias=config.conv_bias,
+ )
+ self.layer_norm = nn.LayerNorm(self.out_conv_dim, elementwise_affine=True)
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+
+ hidden_states = hidden_states.transpose(-2, -1)
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = hidden_states.transpose(-2, -1)
+
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2GroupNormConvLayer with Wav2Vec2->SpeechT5
+class SpeechT5GroupNormConvLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.conv_dim[layer_id - 1] if layer_id > 0 else 1
+ self.out_conv_dim = config.conv_dim[layer_id]
+
+ self.conv = nn.Conv1d(
+ self.in_conv_dim,
+ self.out_conv_dim,
+ kernel_size=config.conv_kernel[layer_id],
+ stride=config.conv_stride[layer_id],
+ bias=config.conv_bias,
+ )
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ self.layer_norm = nn.GroupNorm(num_groups=self.out_conv_dim, num_channels=self.out_conv_dim, affine=True)
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.speech_to_text.modeling_speech_to_text.Speech2TextSinusoidalPositionalEmbedding with Speech2Text->SpeechT5
+class SpeechT5SinusoidalPositionalEmbedding(nn.Module):
+ """This module produces sinusoidal positional embeddings of any length."""
+
+ def __init__(self, num_positions: int, embedding_dim: int, padding_idx: int | None = None):
+ super().__init__()
+ self.offset = 2
+ self.num_positions = num_positions
+ self.embedding_dim = embedding_dim
+ self.padding_idx = padding_idx
+ self.make_weights(num_positions + self.offset, embedding_dim, padding_idx)
+
+ def make_weights(self, num_embeddings: int, embedding_dim: int, padding_idx: int | None = None):
+ emb_weights = self.get_embedding(num_embeddings, embedding_dim, padding_idx)
+ if hasattr(self, "weights"):
+ # in forward put the weights on the correct dtype and device of the param
+ emb_weights = emb_weights.to(dtype=self.weights.dtype, device=self.weights.device)
+
+ self.register_buffer("weights", emb_weights, persistent=False)
+
+ @staticmethod
+ def get_embedding(num_embeddings: int, embedding_dim: int, padding_idx: int | None = None):
+ """
+ Build sinusoidal embeddings. This matches the implementation in tensor2tensor, but differs slightly from the
+ description in Section 3.5 of "Attention Is All You Need".
+ """
+ half_dim = embedding_dim // 2
+ emb = math.log(10000) / (half_dim - 1)
+ emb = torch.exp(torch.arange(half_dim, dtype=torch.int64).float() * -emb)
+ emb = torch.arange(num_embeddings, dtype=torch.int64).float().unsqueeze(1) * emb.unsqueeze(0)
+ emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1).view(num_embeddings, -1)
+ if embedding_dim % 2 == 1:
+ # zero pad
+ emb = torch.cat([emb, torch.zeros(num_embeddings, 1)], dim=1)
+ if padding_idx is not None:
+ emb[padding_idx, :] = 0
+ return emb.to(torch.get_default_dtype())
+
+ @torch.no_grad()
+ def forward(self, input_ids: torch.Tensor, past_key_values_length: int = 0):
+ bsz, seq_len = input_ids.size()
+ # Create the position ids from the input token ids. Any padded tokens remain padded.
+ position_ids = self.create_position_ids_from_input_ids(input_ids, self.padding_idx, past_key_values_length).to(
+ input_ids.device
+ )
+
+ # expand embeddings if needed
+ max_pos = self.padding_idx + 1 + seq_len
+ if max_pos > self.weights.size(0):
+ self.make_weights(max_pos + self.offset, self.embedding_dim, self.padding_idx)
+
+ return self.weights.index_select(0, position_ids.view(-1)).view(bsz, seq_len, -1).detach()
+
+ def create_position_ids_from_input_ids(
+ self, input_ids: torch.Tensor, padding_idx: int, past_key_values_length: int | None = 0
+ ):
+ """
+ Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding
+ symbols are ignored. This is modified from fairseq's `utils.make_positions`.
+
+ Args:
+ x: torch.Tensor x:
+ Returns: torch.Tensor
+ """
+ # The series of casts and type-conversions here are carefully balanced to both work with ONNX export and XLA.
+ mask = input_ids.ne(padding_idx).int()
+ incremental_indices = (torch.cumsum(mask, dim=1).type_as(mask) + past_key_values_length) * mask
+ return incremental_indices.long() + padding_idx
+
+
+# Copied from transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2PositionalConvEmbedding with Wav2Vec2->SpeechT5
+class SpeechT5PositionalConvEmbedding(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.conv = nn.Conv1d(
+ config.hidden_size,
+ config.hidden_size,
+ kernel_size=config.num_conv_pos_embeddings,
+ padding=config.num_conv_pos_embeddings // 2,
+ groups=config.num_conv_pos_embedding_groups,
+ )
+
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ if is_deepspeed_zero3_enabled():
+ import deepspeed
+
+ with deepspeed.zero.GatheredParameters(self.conv.weight, modifier_rank=0):
+ self.conv = weight_norm(self.conv, name="weight", dim=2)
+ if hasattr(self.conv, "parametrizations"):
+ weight_g = self.conv.parametrizations.weight.original0
+ weight_v = self.conv.parametrizations.weight.original1
+ else:
+ weight_g = self.conv.weight_g
+ weight_v = self.conv.weight_v
+ deepspeed.zero.register_external_parameter(self, weight_v)
+ deepspeed.zero.register_external_parameter(self, weight_g)
+ else:
+ self.conv = weight_norm(self.conv, name="weight", dim=2)
+
+ self.padding = SpeechT5SamePadLayer(config.num_conv_pos_embeddings)
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ def forward(self, hidden_states):
+ hidden_states = hidden_states.transpose(1, 2)
+
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.padding(hidden_states)
+ hidden_states = self.activation(hidden_states)
+
+ hidden_states = hidden_states.transpose(1, 2)
+ return hidden_states
+
+
+class SpeechT5ScaledPositionalEncoding(nn.Module):
+ """
+ Scaled positional encoding, see §3.2 in https://huggingface.co/papers/1809.08895
+ """
+
+ def __init__(self, dropout, dim, max_len=5000):
+ pe = torch.zeros(max_len, dim)
+ position = torch.arange(0, max_len).unsqueeze(1)
+ div_term = torch.exp(torch.arange(0, dim, 2, dtype=torch.int64).float() * -(math.log(10000.0) / dim))
+ pe[:, 0::2] = torch.sin(position.float() * div_term)
+ pe[:, 1::2] = torch.cos(position.float() * div_term)
+ pe = pe.unsqueeze(0)
+ super().__init__()
+ self.register_buffer("pe", pe, persistent=False)
+ self.dropout = nn.Dropout(p=dropout)
+ self.dim = dim
+ self.max_len = max_len
+ self.alpha = nn.Parameter(torch.tensor(1.0))
+
+ def forward(self, emb):
+ emb = emb + self.alpha * self.pe[:, : emb.size(1)]
+ emb = self.dropout(emb)
+ return emb
+
+
+class SpeechT5RelativePositionalEncoding(torch.nn.Module):
+ def __init__(self, dim, max_length=1000):
+ super().__init__()
+ self.dim = dim
+ self.max_length = max_length
+ self.pe_k = torch.nn.Embedding(2 * max_length, dim)
+
+ def forward(self, hidden_states):
+ seq_len = hidden_states.shape[1]
+ pos_seq = torch.arange(0, seq_len).to(device=hidden_states.device, dtype=torch.long)
+ pos_seq = pos_seq[:, None] - pos_seq[None, :]
+
+ pos_seq = torch.where(pos_seq < -self.max_length, -self.max_length, pos_seq)
+ pos_seq = torch.where(pos_seq >= self.max_length, self.max_length - 1, pos_seq)
+ pos_seq = pos_seq + self.max_length
+
+ return self.pe_k(pos_seq)
+
+
+# Copied from transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2SamePadLayer with Wav2Vec2->SpeechT5
+class SpeechT5SamePadLayer(nn.Module):
+ def __init__(self, num_conv_pos_embeddings):
+ super().__init__()
+ self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else 0
+
+ def forward(self, hidden_states):
+ if self.num_pad_remove > 0:
+ hidden_states = hidden_states[:, :, : -self.num_pad_remove]
+ return hidden_states
+
+
+# Copied from transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2FeatureEncoder with Wav2Vec2->SpeechT5
+class SpeechT5FeatureEncoder(nn.Module):
+ """Construct the features from raw audio waveform"""
+
+ def __init__(self, config):
+ super().__init__()
+
+ if config.feat_extract_norm == "group":
+ conv_layers = [SpeechT5GroupNormConvLayer(config, layer_id=0)] + [
+ SpeechT5NoLayerNormConvLayer(config, layer_id=i + 1) for i in range(config.num_feat_extract_layers - 1)
+ ]
+ elif config.feat_extract_norm == "layer":
+ conv_layers = [
+ SpeechT5LayerNormConvLayer(config, layer_id=i) for i in range(config.num_feat_extract_layers)
+ ]
+ else:
+ raise ValueError(
+ f"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group', 'layer']"
+ )
+ self.conv_layers = nn.ModuleList(conv_layers)
+ self.gradient_checkpointing = False
+ self._requires_grad = True
+
+ def _freeze_parameters(self):
+ for param in self.parameters():
+ param.requires_grad = False
+ self._requires_grad = False
+
+ def forward(self, input_values):
+ hidden_states = input_values[:, None]
+
+ # make sure hidden_states require grad for gradient_checkpointing
+ if self._requires_grad and self.training:
+ hidden_states.requires_grad = True
+
+ for conv_layer in self.conv_layers:
+ hidden_states = conv_layer(hidden_states)
+
+ return hidden_states
+
+
+# Copied from transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2FeatureProjection with Wav2Vec2->SpeechT5
+class SpeechT5FeatureProjection(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.layer_norm = nn.LayerNorm(config.conv_dim[-1], eps=config.layer_norm_eps)
+ self.projection = nn.Linear(config.conv_dim[-1], config.hidden_size)
+ self.dropout = nn.Dropout(config.feat_proj_dropout)
+
+ def forward(self, hidden_states):
+ # non-projected hidden states are needed for quantization
+ norm_hidden_states = self.layer_norm(hidden_states)
+ hidden_states = self.projection(norm_hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return hidden_states, norm_hidden_states
+
+
+class SpeechT5SpeechEncoderPrenet(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.feature_encoder = SpeechT5FeatureEncoder(config)
+ self.feature_projection = SpeechT5FeatureProjection(config)
+
+ # model only needs masking vector if mask prob is > 0.0
+ if config.mask_time_prob > 0.0 or config.mask_feature_prob > 0.0:
+ self.masked_spec_embed = nn.Parameter(torch.Tensor(config.hidden_size).uniform_())
+
+ self.pos_conv_embed = SpeechT5PositionalConvEmbedding(config)
+ self.pos_sinusoidal_embed = SpeechT5SinusoidalPositionalEmbedding(
+ config.max_speech_positions + config.pad_token_id + 1,
+ config.hidden_size,
+ config.pad_token_id,
+ )
+
+ def freeze_feature_encoder(self):
+ self.feature_encoder._freeze_parameters()
+
+ def forward(
+ self,
+ input_values: torch.Tensor,
+ attention_mask: torch.LongTensor | None = None,
+ mask_time_indices: torch.FloatTensor | None = None,
+ ):
+ extract_features = self.feature_encoder(input_values)
+ extract_features = extract_features.transpose(1, 2)
+
+ if attention_mask is not None:
+ # compute reduced attention_mask corresponding to feature vectors
+ attention_mask = self._get_feature_vector_attention_mask(
+ extract_features.shape[1],
+ attention_mask,
+ )
+
+ hidden_states, extract_features = self.feature_projection(extract_features)
+ hidden_states = self._mask_hidden_states(
+ hidden_states, mask_time_indices=mask_time_indices, attention_mask=attention_mask
+ )
+
+ positional_conv_embedding = self.pos_conv_embed(hidden_states)
+ hidden_states = hidden_states + positional_conv_embedding
+
+ if attention_mask is not None:
+ padding_mask = attention_mask.ne(1).long()
+ else:
+ padding_mask = torch.zeros(hidden_states.shape[:2], dtype=torch.long, device=hidden_states.device)
+
+ positional_sinusoidal_embeddings = self.pos_sinusoidal_embed(padding_mask)
+ hidden_states = hidden_states + positional_sinusoidal_embeddings
+
+ return hidden_states, attention_mask
+
+ # Copied from transformers.models.unispeech.modeling_unispeech.UniSpeechPreTrainedModel._get_feature_vector_attention_mask
+ def _get_feature_vector_attention_mask(self, feature_vector_length: int, attention_mask: torch.LongTensor):
+ # Effectively attention_mask.sum(-1), but not inplace to be able to run
+ # on inference mode.
+ non_padded_lengths = attention_mask.cumsum(dim=-1)[:, -1]
+ output_lengths = self._get_feat_extract_output_lengths(non_padded_lengths).to(torch.long)
+ batch_size = attention_mask.shape[0]
+
+ attention_mask = torch.zeros(
+ (batch_size, feature_vector_length), dtype=attention_mask.dtype, device=attention_mask.device
+ )
+ # these two operations makes sure that all values before the output lengths idxs are attended to
+ attention_mask[(torch.arange(attention_mask.shape[0], device=attention_mask.device), output_lengths - 1)] = 1
+ attention_mask = attention_mask.flip([-1]).cumsum(-1).flip([-1]).bool()
+ return attention_mask
+
+ # Copied from transformers.models.unispeech.modeling_unispeech.UniSpeechPreTrainedModel._get_feat_extract_output_lengths
+ def _get_feat_extract_output_lengths(self, input_lengths: torch.LongTensor | int):
+ """
+ Computes the output length of the convolutional layers
+ """
+
+ def _conv_out_length(input_length, kernel_size, stride):
+ # 1D convolutional layer output length formula taken
+ # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html
+ return torch.div(input_length - kernel_size, stride, rounding_mode="floor") + 1
+
+ for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride):
+ input_lengths = _conv_out_length(input_lengths, kernel_size, stride)
+
+ return input_lengths
+
+ # Copied from transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2Model._mask_hidden_states
+ def _mask_hidden_states(
+ self,
+ hidden_states: torch.FloatTensor,
+ mask_time_indices: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ ):
+ """
+ Masks extracted features along time axis and/or along feature axis according to
+ [SpecAugment](https://huggingface.co/papers/1904.08779).
+ """
+
+ # `config.apply_spec_augment` can set masking to False
+ if not getattr(self.config, "apply_spec_augment", True):
+ return hidden_states
+
+ # generate indices & apply SpecAugment along time axis
+ batch_size, sequence_length, hidden_size = hidden_states.size()
+
+ if mask_time_indices is not None:
+ # apply SpecAugment along time axis with given mask_time_indices
+ hidden_states[mask_time_indices] = self.masked_spec_embed.to(hidden_states.dtype)
+ elif self.config.mask_time_prob > 0 and self.training:
+ mask_time_indices = _compute_mask_indices(
+ (batch_size, sequence_length),
+ mask_prob=self.config.mask_time_prob,
+ mask_length=self.config.mask_time_length,
+ attention_mask=attention_mask,
+ min_masks=self.config.mask_time_min_masks,
+ )
+ mask_time_indices = torch.tensor(mask_time_indices, device=hidden_states.device, dtype=torch.bool)
+ hidden_states[mask_time_indices] = self.masked_spec_embed.to(hidden_states.dtype)
+
+ if self.config.mask_feature_prob > 0 and self.training:
+ # generate indices & apply SpecAugment along feature axis
+ mask_feature_indices = _compute_mask_indices(
+ (batch_size, hidden_size),
+ mask_prob=self.config.mask_feature_prob,
+ mask_length=self.config.mask_feature_length,
+ min_masks=self.config.mask_feature_min_masks,
+ )
+ mask_feature_indices = torch.tensor(mask_feature_indices, device=hidden_states.device, dtype=torch.bool)
+ mask_feature_indices = mask_feature_indices[:, None].expand(-1, sequence_length, -1)
+ hidden_states[mask_feature_indices] = 0
+
+ return hidden_states
+
+
+class SpeechT5SpeechDecoderPrenet(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+
+ self.layers = nn.ModuleList(
+ [
+ nn.Linear(
+ config.num_mel_bins if i == 0 else config.speech_decoder_prenet_units,
+ config.speech_decoder_prenet_units,
+ )
+ for i in range(config.speech_decoder_prenet_layers)
+ ]
+ )
+
+ self.final_layer = nn.Linear(config.speech_decoder_prenet_units, config.hidden_size)
+ self.encode_positions = SpeechT5ScaledPositionalEncoding(
+ config.positional_dropout,
+ config.hidden_size,
+ config.max_speech_positions,
+ )
+ self.speaker_embeds_layer = nn.Linear(config.speaker_embedding_dim + config.hidden_size, config.hidden_size)
+
+ def _consistent_dropout(self, inputs_embeds, p):
+ mask = torch.bernoulli(inputs_embeds[0], p=p)
+ all_masks = mask.unsqueeze(0).repeat(inputs_embeds.size(0), 1, 1)
+ return torch.where(all_masks == 1, inputs_embeds, 0) * 1 / (1 - p)
+
+ def forward(
+ self,
+ input_values: torch.Tensor,
+ speaker_embeddings: torch.Tensor | None = None,
+ ):
+ # Dropout is always applied, even when evaluating. See §2.2 in https://huggingface.co/papers/1712.05884.
+
+ inputs_embeds = input_values
+ for layer in self.layers:
+ inputs_embeds = nn.functional.relu(layer(inputs_embeds))
+ inputs_embeds = self._consistent_dropout(inputs_embeds, self.config.speech_decoder_prenet_dropout)
+
+ inputs_embeds = self.final_layer(inputs_embeds)
+ inputs_embeds = self.encode_positions(inputs_embeds)
+
+ if speaker_embeddings is not None:
+ speaker_embeddings = nn.functional.normalize(speaker_embeddings)
+ speaker_embeddings = speaker_embeddings.unsqueeze(1).expand(-1, inputs_embeds.size(1), -1)
+ inputs_embeds = torch.cat([inputs_embeds, speaker_embeddings], dim=-1)
+ inputs_embeds = nn.functional.relu(self.speaker_embeds_layer(inputs_embeds))
+
+ return inputs_embeds
+
+
+class SpeechT5BatchNormConvLayer(nn.Module):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+
+ if layer_id == 0:
+ in_conv_dim = config.num_mel_bins
+ else:
+ in_conv_dim = config.speech_decoder_postnet_units
+
+ if layer_id == config.speech_decoder_postnet_layers - 1:
+ out_conv_dim = config.num_mel_bins
+ else:
+ out_conv_dim = config.speech_decoder_postnet_units
+
+ self.conv = nn.Conv1d(
+ in_conv_dim,
+ out_conv_dim,
+ kernel_size=config.speech_decoder_postnet_kernel,
+ stride=1,
+ padding=(config.speech_decoder_postnet_kernel - 1) // 2,
+ bias=False,
+ )
+ self.batch_norm = nn.BatchNorm1d(out_conv_dim)
+
+ if layer_id < config.speech_decoder_postnet_layers - 1:
+ self.activation = nn.Tanh()
+ else:
+ self.activation = None
+
+ self.dropout = nn.Dropout(config.speech_decoder_postnet_dropout)
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.batch_norm(hidden_states)
+ if self.activation is not None:
+ hidden_states = self.activation(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return hidden_states
+
+
+class SpeechT5SpeechDecoderPostnet(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+
+ self.feat_out = nn.Linear(config.hidden_size, config.num_mel_bins * config.reduction_factor)
+ self.prob_out = nn.Linear(config.hidden_size, config.reduction_factor)
+
+ self.layers = nn.ModuleList(
+ [SpeechT5BatchNormConvLayer(config, i) for i in range(config.speech_decoder_postnet_layers)]
+ )
+
+ def forward(self, hidden_states: torch.Tensor):
+ outputs_before_postnet = self.feat_out(hidden_states).view(hidden_states.size(0), -1, self.config.num_mel_bins)
+ outputs_after_postnet = self.postnet(outputs_before_postnet)
+ logits = self.prob_out(hidden_states).view(hidden_states.size(0), -1)
+ return outputs_before_postnet, outputs_after_postnet, logits
+
+ def postnet(self, hidden_states: torch.Tensor):
+ layer_output = hidden_states.transpose(1, 2)
+ for layer in self.layers:
+ layer_output = layer(layer_output)
+ return hidden_states + layer_output.transpose(1, 2)
+
+
+class SpeechT5TextEncoderPrenet(nn.Module, EmbeddingAccessMixin):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, config.pad_token_id)
+ self.encode_positions = SpeechT5ScaledPositionalEncoding(
+ config.positional_dropout,
+ config.hidden_size,
+ config.max_text_positions,
+ )
+
+ def forward(self, input_ids: torch.Tensor):
+ inputs_embeds = self.embed_tokens(input_ids)
+ inputs_embeds = self.encode_positions(inputs_embeds)
+ return inputs_embeds
+
+
+class SpeechT5TextDecoderPrenet(nn.Module, EmbeddingAccessMixin):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.dropout = nn.Dropout(config.positional_dropout)
+ self.embed_scale = math.sqrt(config.hidden_size) if config.scale_embedding else 1.0
+
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, config.pad_token_id)
+
+ self.embed_positions = SpeechT5SinusoidalPositionalEmbedding(
+ config.max_text_positions + config.pad_token_id + 1,
+ config.hidden_size,
+ config.pad_token_id,
+ )
+
+ def forward(
+ self,
+ input_ids: torch.Tensor,
+ attention_mask: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ ):
+ if input_ids is not None:
+ input_shape = input_ids.size()
+ input_ids = input_ids.view(-1, input_shape[-1])
+ else:
+ raise ValueError("You have to specify `decoder_input_ids`")
+
+ past_key_values_length = 0 if past_key_values is None else past_key_values.get_seq_length()
+ positions = self.embed_positions(input_ids, past_key_values_length)
+
+ inputs_embeds = self.embed_tokens(input_ids) * self.embed_scale
+ inputs_embeds += positions
+ inputs_embeds = self.dropout(inputs_embeds)
+
+ return inputs_embeds, attention_mask
+
+
+class SpeechT5TextDecoderPostnet(nn.Module, EmbeddingAccessMixin):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+ def forward(self, hidden_states: torch.Tensor):
+ return self.lm_head(hidden_states)
+
+ def get_output_embeddings(self):
+ # Post-net has no token embeddings, but its lm_head must still be
+ # tied to the decoder weights when `tie_word_embeddings=True`.
+ return self.lm_head
+
+ def set_output_embeddings(self, new_embeddings):
+ self.lm_head = new_embeddings
+
+
+class SpeechT5Attention(nn.Module):
+ """
+ Multi-headed attention from 'Attention Is All You Need' paper with relative position bias (see
+ https://aclanthology.org/N18-2074.pdf)
+ """
+
+ def __init__(
+ self,
+ embed_dim: int,
+ num_heads: int,
+ dropout: float | None = 0.0,
+ is_decoder: bool | None = False,
+ bias: bool | None = True,
+ layer_idx: bool | None = None,
+ ):
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.num_heads = num_heads
+ self.dropout = dropout
+ self.head_dim = embed_dim // num_heads
+
+ if (self.head_dim * num_heads) != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}"
+ f" and `num_heads`: {num_heads})."
+ )
+ self.scaling = self.head_dim**-0.5
+ self.is_decoder = is_decoder
+ self.layer_idx = layer_idx
+
+ self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ key_value_states: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_bias: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ **kwargs,
+ ) -> tuple[torch.Tensor, torch.Tensor | None, Cache | None]:
+ """Input shape: Batch x Time x Channel"""
+
+ # if key_value_states are provided this layer is used as a cross-attention layer
+ # for the decoder
+ is_cross_attention = key_value_states is not None
+
+ bsz, tgt_len, _ = hidden_states.size()
+
+ # get query proj
+ query_states = self.q_proj(hidden_states) * self.scaling
+
+ is_updated = False
+ if past_key_values is not None:
+ if isinstance(past_key_values, EncoderDecoderCache):
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ if is_cross_attention:
+ # after the first generated id, we can subsequently re-use all key/value_states from cache
+ curr_past_key_values = past_key_values.cross_attention_cache
+ else:
+ curr_past_key_values = past_key_values.self_attention_cache
+ else:
+ curr_past_key_values = past_key_values
+
+ current_states = key_value_states if is_cross_attention else hidden_states
+ if is_cross_attention and past_key_values is not None and is_updated:
+ # reuse k,v, cross_attentions
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+ else:
+ key_states = self.k_proj(current_states)
+ value_states = self.v_proj(current_states)
+ key_states = key_states.view(bsz, -1, self.num_heads, self.head_dim).transpose(1, 2)
+ value_states = value_states.view(bsz, -1, self.num_heads, self.head_dim).transpose(1, 2)
+
+ if past_key_values is not None:
+ # save all key/value_states to cache to be re-used for fast auto-regressive generation
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+ if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+ past_key_values.is_updated[self.layer_idx] = True
+
+ proj_shape = (bsz * self.num_heads, -1, self.head_dim)
+ query_states = query_states.view(bsz, tgt_len, self.num_heads, self.head_dim).transpose(1, 2)
+ query_states = query_states.reshape(*proj_shape)
+ key_states = key_states.reshape(*proj_shape)
+ value_states = value_states.reshape(*proj_shape)
+
+ src_len = key_states.size(1)
+ attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))
+
+ if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len):
+ raise ValueError(
+ f"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is"
+ f" {attn_weights.size()}"
+ )
+
+ # relative attention bias
+ if position_bias is not None:
+ reshape_q = query_states.contiguous().view(bsz * self.num_heads, -1, self.head_dim).transpose(0, 1)
+ rel_pos_bias = torch.matmul(reshape_q, position_bias.transpose(-2, -1))
+ rel_pos_bias = rel_pos_bias.transpose(0, 1).view(
+ bsz * self.num_heads, position_bias.size(0), position_bias.size(1)
+ )
+ attn_weights += rel_pos_bias
+
+ if attention_mask is not None:
+ if attention_mask.size() != (bsz, 1, tgt_len, src_len):
+ raise ValueError(
+ f"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {attention_mask.size()}"
+ )
+ attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len) + attention_mask
+ attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+
+ if output_attentions:
+ # this operation is a bit awkward, but it's required to
+ # make sure that attn_weights keeps its gradient.
+ # In order to do so, attn_weights have to be reshaped
+ # twice and have to be reused in the following
+ attn_weights_reshaped = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
+ attn_weights = attn_weights_reshaped.view(bsz * self.num_heads, tgt_len, src_len)
+ else:
+ attn_weights_reshaped = None
+
+ attn_probs = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+ attn_output = torch.bmm(attn_probs, value_states)
+
+ if attn_output.size() != (bsz * self.num_heads, tgt_len, self.head_dim):
+ raise ValueError(
+ f"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is"
+ f" {attn_output.size()}"
+ )
+
+ attn_output = attn_output.view(bsz, self.num_heads, tgt_len, self.head_dim)
+ attn_output = attn_output.transpose(1, 2)
+
+ # Use the `embed_dim` from the config (stored in the class) rather than `hidden_state` because `attn_output` can be
+ # partitioned across GPUs when using tensor-parallelism.
+ attn_output = attn_output.reshape(bsz, tgt_len, self.embed_dim)
+
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights_reshaped
+
+
+class SpeechT5FeedForward(nn.Module):
+ def __init__(self, config, intermediate_size):
+ super().__init__()
+ self.intermediate_dropout = nn.Dropout(config.activation_dropout)
+
+ self.intermediate_dense = nn.Linear(config.hidden_size, intermediate_size)
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ self.output_dense = nn.Linear(intermediate_size, config.hidden_size)
+ self.output_dropout = nn.Dropout(config.hidden_dropout)
+
+ def forward(self, hidden_states):
+ hidden_states = self.intermediate_dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ hidden_states = self.intermediate_dropout(hidden_states)
+
+ hidden_states = self.output_dense(hidden_states)
+ hidden_states = self.output_dropout(hidden_states)
+ return hidden_states
+
+
+class SpeechT5EncoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: SpeechT5Config):
+ super().__init__()
+ self.attention = SpeechT5Attention(
+ embed_dim=config.hidden_size,
+ num_heads=config.encoder_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=False,
+ )
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.feed_forward = SpeechT5FeedForward(config, config.encoder_ffn_dim)
+ self.final_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ position_bias: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ ):
+ """
+ Args:
+ hidden_states (`torch.FloatTensor`):
+ input to the layer of shape `(batch, seq_len, hidden_size)`
+ attention_mask (`torch.FloatTensor`):
+ attention mask of size `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very
+ large negative values.
+ position_bias (`torch.FloatTensor`):
+ relative position embeddings of size `(seq_len, seq_len, hidden_size // encoder_attention_heads)`
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ """
+ residual = hidden_states
+ hidden_states, attn_weights = self.attention(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ position_bias=position_bias,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = residual + hidden_states
+
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = hidden_states + self.feed_forward(hidden_states)
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (attn_weights,)
+
+ return outputs
+
+
+class SpeechT5DecoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: SpeechT5Config, layer_idx=None):
+ super().__init__()
+ self.self_attn = SpeechT5Attention(
+ embed_dim=config.hidden_size,
+ num_heads=config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=True,
+ layer_idx=layer_idx,
+ )
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.self_attn_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ self.encoder_attn = SpeechT5Attention(
+ config.hidden_size,
+ config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=True,
+ layer_idx=layer_idx,
+ )
+ self.encoder_attn_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ self.feed_forward = SpeechT5FeedForward(config, config.decoder_ffn_dim)
+ self.final_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ output_attentions: bool | None = False,
+ use_cache: bool | None = True,
+ **kwargs,
+ ):
+ """
+ Args:
+ hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, hidden_size)`
+ attention_mask (`torch.FloatTensor`): attention mask of size
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+ encoder_hidden_states (`torch.FloatTensor`):
+ cross attention input to the layer of shape `(batch, seq_len, hidden_size)`
+ encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+ past_key_values (`Cache`): cached past key and value projection states
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ """
+ residual = hidden_states
+
+ # Self Attention
+ hidden_states, self_attn_weights = self.self_attn(
+ hidden_states=hidden_states,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ )
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = residual + hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+
+ # Cross-Attention Block
+ cross_attn_weights = None
+ if encoder_hidden_states is not None:
+ residual = hidden_states
+
+ hidden_states, cross_attn_weights = self.encoder_attn(
+ hidden_states=hidden_states,
+ key_value_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = residual + hidden_states
+ hidden_states = self.encoder_attn_layer_norm(hidden_states)
+
+ # Fully Connected
+ hidden_states = hidden_states + self.feed_forward(hidden_states)
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (self_attn_weights, cross_attn_weights)
+
+ return outputs
+
+
+@auto_docstring
+class SpeechT5PreTrainedModel(PreTrainedModel):
+ config: SpeechT5Config
+ base_model_prefix = "speecht5"
+ main_input_name = "input_values"
+ input_modalities = "audio"
+ supports_gradient_checkpointing = True
+
+ @torch.no_grad()
+ def _init_weights(self, module: nn.Module):
+ """Initialize the weights"""
+ std = self.config.initializer_range
+ if isinstance(module, SpeechT5PositionalConvEmbedding):
+ init.normal_(
+ module.conv.weight,
+ mean=0,
+ std=2 * math.sqrt(1 / (module.conv.kernel_size[0] * module.conv.in_channels)),
+ )
+ init.constant_(module.conv.bias, 0)
+ elif isinstance(module, SpeechT5ScaledPositionalEncoding):
+ init.ones_(module.alpha)
+ dim, max_len = module.dim, module.max_len
+ pe = torch.zeros(max_len, dim)
+ position = torch.arange(0, max_len).unsqueeze(1)
+ div_term = torch.exp(torch.arange(0, dim, 2, dtype=torch.int64).float() * -(math.log(10000.0) / dim))
+ pe[:, 0::2] = torch.sin(position.float() * div_term)
+ pe[:, 1::2] = torch.cos(position.float() * div_term)
+ pe = pe.unsqueeze(0)
+ init.copy_(module.pe, pe)
+ elif isinstance(module, SpeechT5FeatureProjection):
+ k = math.sqrt(1 / module.projection.in_features)
+ init.uniform_(module.projection.weight, a=-k, b=k)
+ init.uniform_(module.projection.bias, a=-k, b=k)
+ elif isinstance(module, nn.Linear):
+ init.normal_(module.weight, mean=0.0, std=std)
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, (nn.LayerNorm, nn.GroupNorm, nn.BatchNorm1d)):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ if getattr(module, "running_mean", None) is not None:
+ init.zeros_(module.running_mean)
+ init.ones_(module.running_var)
+ init.zeros_(module.num_batches_tracked)
+ elif isinstance(module, nn.Conv1d):
+ init.kaiming_normal_(module.weight)
+ if module.bias is not None:
+ k = math.sqrt(module.groups / (module.in_channels * module.kernel_size[0]))
+ init.uniform_(module.bias, a=-k, b=k)
+ elif isinstance(module, nn.Embedding):
+ init.normal_(module.weight, mean=0.0, std=std)
+ # Here we need the check explicitly, as we slice the weight in the `zeros_` call, so it looses the flag
+ if module.padding_idx is not None and not getattr(module.weight, "_is_hf_initialized", False):
+ init.zeros_(module.weight[module.padding_idx])
+ elif isinstance(module, SpeechT5SinusoidalPositionalEmbedding):
+ emb_weights = module.get_embedding(
+ module.num_positions + module.offset, module.embedding_dim, module.padding_idx
+ )
+ init.copy_(module.weights, emb_weights)
+ elif isinstance(module, SpeechT5HifiGan):
+ init.zeros_(module.mean)
+ init.ones_(module.scale)
+
+ if hasattr(module, "masked_spec_embed"):
+ init.uniform_(module.masked_spec_embed)
+
+
+class SpeechT5Encoder(SpeechT5PreTrainedModel):
+ """
+ Transformer encoder consisting of *config.encoder_layers* layers. Each layer is a [`SpeechT5EncoderLayer`].
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layerdrop = config.encoder_layerdrop
+
+ self.layers = nn.ModuleList([SpeechT5EncoderLayer(config) for _ in range(config.encoder_layers)])
+
+ self.embed_positions = SpeechT5RelativePositionalEncoding(
+ config.hidden_size // config.encoder_attention_heads, config.encoder_max_relative_position
+ )
+
+ self.gradient_checkpointing = False
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ hidden_states: torch.FloatTensor,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutput:
+ """
+ Args:
+ hidden_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, feature_size)`):
+ Features extracted from the speech or text input by the encoder prenet.
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing convolution and attention on padding token indices. Mask values selected in
+ `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+ for more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ )
+
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ position_bias = self.embed_positions(hidden_states)
+
+ synced_gpus = is_deepspeed_zero3_enabled() or is_fsdp_managed_module(self)
+
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ for idx, encoder_layer in enumerate(self.layers):
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ skip_the_layer = False
+ if self.training:
+ dropout_probability = torch.rand([])
+ skip_the_layer = dropout_probability < self.layerdrop
+
+ if not skip_the_layer or synced_gpus:
+ # under fsdp or deepspeed zero3 all gpus must run in sync
+ layer_outputs = encoder_layer(
+ hidden_states,
+ attention_mask=attention_mask,
+ position_bias=position_bias,
+ output_attentions=output_attentions,
+ )
+ hidden_states = layer_outputs[0]
+
+ if skip_the_layer:
+ layer_outputs = (None, None)
+
+ if output_attentions:
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+
+class SpeechT5EncoderWithSpeechPrenet(SpeechT5PreTrainedModel):
+ """
+ Wrapper around SpeechT5Encoder that applies SpeechT5SpeechEncoderPrenet to convert the audio waveform data to
+ hidden features.
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+ self.prenet = SpeechT5SpeechEncoderPrenet(config)
+ self.wrapped_encoder = SpeechT5Encoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ input_values: torch.FloatTensor,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutput:
+ hidden_states, attention_mask = self.prenet(input_values, attention_mask)
+
+ outputs = self.wrapped_encoder(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ return outputs
+
+
+class SpeechT5EncoderWithTextPrenet(SpeechT5PreTrainedModel):
+ """
+ Wrapper around SpeechT5Encoder that applies SpeechT5TextEncoderPrenet to convert the input_ids to hidden features.
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+ self.prenet = SpeechT5TextEncoderPrenet(config)
+ self.wrapped_encoder = SpeechT5Encoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.prenet.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.prenet.set_input_embeddings(value)
+
+ def forward(
+ self,
+ input_values: torch.FloatTensor,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutput:
+ hidden_states = self.prenet(input_values)
+
+ outputs = self.wrapped_encoder(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ return outputs
+
+
+class SpeechT5EncoderWithoutPrenet(SpeechT5PreTrainedModel):
+ """
+ This wrapper class is a helper class to correctly load pretrained checkpoints when used in combination with
+ [`SpeechT5Model`].
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+ self.wrapped_encoder = SpeechT5Encoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ input_values: torch.FloatTensor,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutput:
+ return self.wrapped_encoder(
+ hidden_states=input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+
+class SpeechT5Decoder(SpeechT5PreTrainedModel):
+ """
+ Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`SpeechT5DecoderLayer`]
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+ self.layerdrop = config.decoder_layerdrop
+
+ self.layers = nn.ModuleList([SpeechT5DecoderLayer(config, layer_idx=i) for i in range(config.decoder_layers)])
+
+ self.gradient_checkpointing = False
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ hidden_states: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutputWithPastAndCrossAttentions:
+ r"""
+ Args:
+ hidden_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, feature_size)`):
+ Features extracted from the speech or text input by the decoder prenet.
+ attention_mask (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*):
+ Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
+ of the decoder.
+ encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, encoder_sequence_length)`, *optional*):
+ Mask to avoid performing cross-attention on padding tokens indices of encoder input_ids. Mask values
+ selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and in the
+ cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
+
+ If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those
+ that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of
+ all `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation.
+ This is useful if you want more control over how to convert `input_ids` indices into associated vectors
+ than the model's internal embedding lookup matrix.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+ for more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if self.gradient_checkpointing and self.training:
+ if use_cache:
+ logger.warning_once(
+ "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+ )
+ use_cache = False
+
+ if use_cache and past_key_values is None:
+ past_key_values = EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache(config=self.config))
+
+ attention_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+
+ # expand encoder attention mask
+ if encoder_hidden_states is not None and encoder_attention_mask is not None:
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+
+ synced_gpus = is_deepspeed_zero3_enabled() or is_fsdp_managed_module(self)
+
+ # decoder layers
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+ all_cross_attentions = () if (output_attentions and encoder_hidden_states is not None) else None
+
+ for idx, decoder_layer in enumerate(self.layers):
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ skip_the_layer = False
+ if self.training:
+ dropout_probability = torch.rand([])
+ skip_the_layer = dropout_probability < self.layerdrop
+ if skip_the_layer and not synced_gpus:
+ continue
+
+ layer_outputs = decoder_layer(
+ hidden_states,
+ attention_mask,
+ encoder_hidden_states, # as a positional argument for gradient checkpointing
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ use_cache=use_cache,
+ )
+ hidden_states = layer_outputs[0]
+ if output_attentions:
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+ if encoder_hidden_states is not None:
+ all_cross_attentions = all_cross_attentions + (layer_outputs[2],)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(
+ v
+ for v in [hidden_states, past_key_values, all_hidden_states, all_self_attentions, all_cross_attentions]
+ if v is not None
+ )
+
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ cross_attentions=all_cross_attentions,
+ )
+
+
+class SpeechT5DecoderWithSpeechPrenet(SpeechT5PreTrainedModel):
+ """
+ Wrapper around SpeechT5Decoder that applies SpeechT5SpeechDecoderPrenet to convert log-mel filterbanks to hidden
+ features.
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+ self.prenet = SpeechT5SpeechDecoderPrenet(config)
+ self.wrapped_decoder = SpeechT5Decoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ input_values: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.LongTensor | None = None,
+ speaker_embeddings: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutputWithPastAndCrossAttentions:
+ decoder_hidden_states = self.prenet(input_values, speaker_embeddings)
+
+ outputs = self.wrapped_decoder(
+ hidden_states=decoder_hidden_states,
+ attention_mask=attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ return outputs
+
+
+class SpeechT5DecoderWithTextPrenet(SpeechT5PreTrainedModel):
+ """
+ Wrapper around SpeechT5Decoder that applies SpeechT5TextDecoderPrenet to convert input tokens to hidden features.
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+ self.prenet = SpeechT5TextDecoderPrenet(config)
+ self.wrapped_decoder = SpeechT5Decoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.prenet.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.prenet.set_input_embeddings(value)
+
+ def forward(
+ self,
+ input_values: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutputWithPastAndCrossAttentions:
+ decoder_hidden_states, attention_mask = self.prenet(input_values, attention_mask, past_key_values)
+
+ outputs = self.wrapped_decoder(
+ hidden_states=decoder_hidden_states,
+ attention_mask=attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ return outputs
+
+
+class SpeechT5DecoderWithoutPrenet(SpeechT5PreTrainedModel):
+ """
+ This wrapper class is a helper class to correctly load pretrained checkpoints when used in combination with
+ [`SpeechT5Model`].
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+ self.wrapped_decoder = SpeechT5Decoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ input_values: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutputWithPastAndCrossAttentions:
+ outputs = self.wrapped_decoder(
+ hidden_states=input_values,
+ attention_mask=attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ return outputs
+
+
+class SpeechT5GuidedMultiheadAttentionLoss(nn.Module):
+ """
+ Guided attention loss from the paper [Efficiently Trainable Text-to-Speech System Based on Deep Convolutional
+ Networks with Guided Attention](https://huggingface.co/papers/1710.08969), adapted for multi-head attention.
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__()
+ self.sigma = config.guided_attention_loss_sigma
+ self.scale = config.guided_attention_loss_scale
+
+ def forward(
+ self, attentions: torch.FloatTensor, input_masks: torch.BoolTensor, output_masks: torch.BoolTensor
+ ) -> torch.Tensor:
+ """
+ Compute the attention loss.
+
+ Args:
+ attentions (`torch.FloatTensor` of shape `(batch_size, layers * heads, output_sequence_length, input_sequence_length)`):
+ Batch of multi-head attention weights
+ input_masks (`torch.BoolTensor` of shape `(batch_size, input_sequence_length)`):
+ Input attention mask as booleans.
+ output_masks (`torch.BoolTensor` of shape `(batch_size, output_sequence_length)`):
+ Target attention mask as booleans.
+
+ Returns:
+ `torch.Tensor` with the loss value
+ """
+ guided_attn_masks = self._make_guided_attention_masks(input_masks, output_masks, attentions.device)
+ masks = output_masks.unsqueeze(-1) & input_masks.unsqueeze(-2)
+ masks = masks.to(attentions.device).unsqueeze(1)
+
+ losses = guided_attn_masks * attentions
+ loss = torch.mean(losses.masked_select(masks))
+ return self.scale * loss
+
+ def _make_guided_attention_masks(self, input_masks, output_masks, device):
+ input_lengths = input_masks.sum(-1)
+ output_lengths = output_masks.sum(-1)
+
+ guided_attn_masks = torch.zeros((len(input_masks), output_masks.shape[1], input_masks.shape[1]), device=device)
+
+ for idx, (ilen, olen) in enumerate(zip(input_lengths, output_lengths)):
+ guided_attn_masks[idx, :olen, :ilen] = self._make_guided_attention_mask(ilen, olen, self.sigma, device)
+
+ return guided_attn_masks.unsqueeze(1)
+
+ @staticmethod
+ def _make_guided_attention_mask(input_length, output_length, sigma, device):
+ grid_y, grid_x = torch.meshgrid(
+ torch.arange(input_length, device=device),
+ torch.arange(output_length, device=device),
+ indexing="xy",
+ )
+ grid_x = grid_x.float() / output_length
+ grid_y = grid_y.float() / input_length
+ return 1.0 - torch.exp(-((grid_y - grid_x) ** 2) / (2 * (sigma**2)))
+
+
+class SpeechT5SpectrogramLoss(nn.Module):
+ """
+ Loss computation used by SpeechT5ForTextToSpeech.
+ """
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__()
+ self.use_guided_attention_loss = config.use_guided_attention_loss
+ self.guided_attention_loss_num_heads = config.guided_attention_loss_num_heads
+ self.reduction_factor = config.reduction_factor
+
+ self.l1_criterion = L1Loss()
+ self.bce_criterion = BCEWithLogitsLoss(pos_weight=torch.tensor(5.0))
+
+ if self.use_guided_attention_loss:
+ self.attn_criterion = SpeechT5GuidedMultiheadAttentionLoss(config)
+
+ def forward(
+ self,
+ attention_mask: torch.LongTensor,
+ outputs_before_postnet: torch.FloatTensor,
+ outputs_after_postnet: torch.FloatTensor,
+ logits: torch.FloatTensor,
+ labels: torch.FloatTensor,
+ cross_attentions: torch.FloatTensor | None = None,
+ ) -> torch.Tensor:
+ padding_mask = labels != -100.0
+
+ # mask out the padded portions
+ labels = labels.masked_select(padding_mask)
+ outputs_before_postnet = outputs_before_postnet.masked_select(padding_mask)
+ outputs_after_postnet = outputs_after_postnet.masked_select(padding_mask)
+
+ # spectrogram loss
+ l1_loss = self.l1_criterion(outputs_after_postnet, labels) + self.l1_criterion(outputs_before_postnet, labels)
+
+ # construct stop labels from the padding mask
+ masks = padding_mask[:, :, 0]
+ stop_labels = torch.cat([~masks * 1.0, torch.ones(masks.size(0), 1).to(masks.device)], dim=1)
+ stop_labels = stop_labels[:, 1:].masked_select(masks)
+ logits = logits.masked_select(masks)
+
+ # stop token loss
+ bce_loss = self.bce_criterion(logits, stop_labels)
+
+ # combined loss
+ loss = l1_loss + bce_loss
+
+ # guided attention loss
+ if self.use_guided_attention_loss:
+ attn = torch.cat([x[:, : self.guided_attention_loss_num_heads] for x in cross_attentions], dim=1)
+ input_masks = attention_mask == 1
+ output_masks = padding_mask[:, :, 0]
+ if self.reduction_factor > 1:
+ output_masks = output_masks[:, self.reduction_factor - 1 :: self.reduction_factor]
+ attn_loss = self.attn_criterion(attn, input_masks, output_masks)
+ loss += attn_loss
+
+ return loss
+
+
+@auto_docstring(
+ custom_intro="""
+ The bare SpeechT5 Encoder-Decoder Model outputting raw hidden-states without any specific pre- or post-nets.
+ """
+)
+class SpeechT5Model(SpeechT5PreTrainedModel):
+ def __init__(
+ self,
+ config: SpeechT5Config,
+ encoder: nn.Module | None = None,
+ decoder: nn.Module | None = None,
+ ):
+ r"""
+ encoder (`PreTrainedModel`, *optional*):
+ The encoder model to use.
+ decoder (`PreTrainedModel`, *optional*):
+ The decoder model to use.
+ """
+ super().__init__(config)
+ self.config = config
+ self.encoder = SpeechT5EncoderWithoutPrenet(config) if encoder is None else encoder
+ self.decoder = SpeechT5DecoderWithoutPrenet(config) if decoder is None else decoder
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ if isinstance(self.encoder, SpeechT5EncoderWithTextPrenet):
+ return self.encoder.get_input_embeddings()
+ if isinstance(self.decoder, SpeechT5DecoderWithTextPrenet):
+ return self.decoder.get_input_embeddings()
+ raise NotImplementedError
+
+ def set_input_embeddings(self, value):
+ if isinstance(self.encoder, SpeechT5EncoderWithTextPrenet):
+ self.encoder.set_input_embeddings(value)
+ if isinstance(self.decoder, SpeechT5DecoderWithTextPrenet):
+ self.decoder.set_input_embeddings(value)
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ if isinstance(self.encoder, SpeechT5EncoderWithSpeechPrenet):
+ self.encoder.prenet.freeze_feature_encoder()
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ decoder_input_values: torch.Tensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ speaker_embeddings: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | Seq2SeqModelOutput:
+ r"""
+ input_values (`torch.Tensor` of shape `(batch_size, sequence_length)`):
+ Depending on which encoder is being used, the `input_values` are either: float values of the input raw
+ speech waveform, or indices of input sequence tokens in the vocabulary, or hidden states.
+ decoder_input_values (`torch.Tensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Depending on which decoder is being used, the `decoder_input_values` are either: float values of log-mel
+ filterbank features extracted from the raw speech waveform, or indices of decoder input sequence tokens in
+ the vocabulary, or hidden states.
+ decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_values`. Causal mask will
+ also be used by default.
+
+ If you want to change padding behavior, you should read [`SpeechT5Decoder._prepare_decoder_attention_mask`]
+ and modify to your needs. See diagram 1 in [the paper](https://huggingface.co/papers/1910.13461) for more
+ information on the default strategy.
+ speaker_embeddings (`torch.FloatTensor` of shape `(batch_size, config.speaker_embedding_dim)`, *optional*):
+ Tensor containing the speaker embeddings.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # Encode if needed (training, first prediction pass)
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_values=input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ # If the user passed a tuple for encoder_outputs, we wrap it in a BaseModelOutput when return_dict=True
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ # downsample encoder attention mask (only for encoders with speech input)
+ if attention_mask is not None and isinstance(self.encoder, SpeechT5EncoderWithSpeechPrenet):
+ encoder_attention_mask = self.encoder.prenet._get_feature_vector_attention_mask(
+ encoder_outputs[0].shape[1], attention_mask
+ )
+ else:
+ encoder_attention_mask = attention_mask
+
+ if isinstance(self.decoder, SpeechT5DecoderWithSpeechPrenet):
+ decoder_args = {"speaker_embeddings": speaker_embeddings}
+ else:
+ decoder_args = {}
+
+ decoder_outputs = self.decoder(
+ input_values=decoder_input_values,
+ attention_mask=decoder_attention_mask,
+ encoder_hidden_states=encoder_outputs[0],
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ **decoder_args,
+ )
+
+ if not return_dict:
+ return decoder_outputs + encoder_outputs
+
+ return Seq2SeqModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ SpeechT5 Model with a speech encoder and a text decoder.
+ """
+)
+class SpeechT5ForSpeechToText(SpeechT5PreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"text_decoder_postnet.lm_head.weight": "speecht5.decoder.prenet.embed_tokens.weight"}
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+
+ if config.vocab_size is None:
+ raise ValueError(
+ f"You are trying to instantiate {self.__class__} with a configuration that does not define the"
+ " vocabulary size of the language model head. Please instantiate the model as follows:"
+ " `SpeechT5ForSpeechToText.from_pretrained(..., vocab_size=vocab_size)`. or define `vocab_size` of"
+ " your model's configuration."
+ )
+
+ speech_encoder = SpeechT5EncoderWithSpeechPrenet(config)
+ text_decoder = SpeechT5DecoderWithTextPrenet(config)
+ self.speecht5 = SpeechT5Model(config, speech_encoder, text_decoder)
+
+ self.text_decoder_postnet = SpeechT5TextDecoderPostnet(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.get_encoder().prenet.freeze_feature_encoder()
+
+ def get_output_embeddings(self):
+ return self.text_decoder_postnet.get_output_embeddings()
+
+ def set_output_embeddings(self, new_embeddings):
+ self.text_decoder_postnet.set_output_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ labels: torch.LongTensor | None = None,
+ **kwargs,
+ ) -> tuple | Seq2SeqLMOutput:
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Float values of input raw speech waveform. Values can be obtained by loading a *.flac* or *.wav* audio file
+ into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library
+ (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
+ To prepare the array into `input_values`, the [`SpeechT5Processor`] should be used for padding
+ and conversion into a tensor of type `torch.FloatTensor`. See [`SpeechT5Processor.__call__`] for details.
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`SpeechT5Tokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ SpeechT5 uses the `eos_token_id` as the starting token for `decoder_input_ids` generation. If
+ `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
+ `past_key_values`).
+ decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_values`. Causal mask will
+ also be used by default.
+
+ If you want to change padding behavior, you should read [`SpeechT5Decoder._prepare_decoder_attention_mask`]
+ and modify to your needs. See diagram 1 in [the paper](https://huggingface.co/papers/1910.13461) for more
+ information on the default strategy.
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the language modeling loss. Indices should either be in `[0, ..., config.vocab_size]`
+ or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored (masked), the loss is
+ only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+ Label indices can be obtained using [`SpeechT5Tokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ Example:
+
+ ```python
+ >>> from transformers import SpeechT5Processor, SpeechT5ForSpeechToText
+ >>> from datasets import load_dataset
+
+ >>> dataset = load_dataset(
+ ... "hf-internal-testing/librispeech_asr_demo", "clean", split="validation"
+ ... ) # doctest: +IGNORE_RESULT
+ >>> dataset = dataset.sort("id")
+ >>> sampling_rate = dataset.features["audio"].sampling_rate
+
+ >>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_asr")
+ >>> model = SpeechT5ForSpeechToText.from_pretrained("microsoft/speecht5_asr")
+
+ >>> # audio file is decoded on the fly
+ >>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
+ >>> predicted_ids = model.generate(**inputs, max_length=100)
+
+ >>> # transcribe speech
+ >>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
+ >>> transcription[0]
+ 'mister quilter is the apostle of the middle classes and we are glad to welcome his gospel'
+ ```
+
+ ```python
+ >>> inputs["labels"] = processor(text_target=dataset[0]["text"], return_tensors="pt").input_ids
+
+ >>> # compute loss
+ >>> loss = model(**inputs).loss
+ >>> round(loss.item(), 2)
+ 19.68
+ ```
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if labels is not None:
+ if decoder_input_ids is None:
+ decoder_input_ids = shift_tokens_right(
+ labels, self.config.pad_token_id, self.config.decoder_start_token_id
+ )
+
+ outputs = self.speecht5(
+ input_values=input_values,
+ attention_mask=attention_mask,
+ decoder_input_values=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ encoder_outputs=encoder_outputs,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=True,
+ )
+
+ logits = self.text_decoder_postnet(outputs[0])
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.config.vocab_size), labels.view(-1))
+
+ if not return_dict:
+ output = (logits,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ decoder_hidden_states=outputs.decoder_hidden_states,
+ decoder_attentions=outputs.decoder_attentions,
+ cross_attentions=outputs.cross_attentions,
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+ encoder_hidden_states=outputs.encoder_hidden_states,
+ encoder_attentions=outputs.encoder_attentions,
+ )
+
+
+def _generate_speech(
+ model: SpeechT5PreTrainedModel,
+ input_values: torch.FloatTensor,
+ speaker_embeddings: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ threshold: float = 0.5,
+ minlenratio: float = 0.0,
+ maxlenratio: float = 20.0,
+ vocoder: nn.Module | None = None,
+ output_cross_attentions: bool = False,
+ return_output_lengths: bool = False,
+) -> torch.FloatTensor | tuple[torch.FloatTensor, torch.FloatTensor]:
+ if speaker_embeddings is None:
+ raise ValueError(
+ """`speaker_embeddings` must be specified. For example, you can use a speaker embeddings by following
+ the code snippet provided in this link:
+ https://huggingface.co/datasets/Matthijs/cmu-arctic-xvectors
+ """
+ )
+
+ if attention_mask is None:
+ encoder_attention_mask = 1 - (input_values == model.config.pad_token_id).int()
+ else:
+ encoder_attention_mask = attention_mask
+
+ bsz = input_values.size(0)
+
+ encoder_out = model.speecht5.encoder(
+ input_values=input_values,
+ attention_mask=encoder_attention_mask,
+ return_dict=True,
+ )
+
+ encoder_last_hidden_state = encoder_out.last_hidden_state
+
+ # downsample encoder attention mask
+ if isinstance(model.speecht5.encoder, SpeechT5EncoderWithSpeechPrenet):
+ encoder_attention_mask = model.speecht5.encoder.prenet._get_feature_vector_attention_mask(
+ encoder_out[0].shape[1], encoder_attention_mask
+ )
+
+ maxlen = int(encoder_last_hidden_state.size(1) * maxlenratio / model.config.reduction_factor)
+ minlen = int(encoder_last_hidden_state.size(1) * minlenratio / model.config.reduction_factor)
+
+ # Start the output sequence with a mel spectrum that is all zeros.
+ output_sequence = encoder_last_hidden_state.new_zeros(bsz, 1, model.config.num_mel_bins)
+
+ spectrogram = []
+ cross_attentions = []
+ past_key_values = None
+ idx = 0
+ result_spectrogram = {}
+
+ while True:
+ idx += 1
+
+ # Run the decoder prenet on the entire output sequence.
+ decoder_hidden_states = model.speecht5.decoder.prenet(output_sequence, speaker_embeddings)
+ # Run the decoder layers on the last element of the prenet output.
+ decoder_out = model.speecht5.decoder.wrapped_decoder(
+ hidden_states=decoder_hidden_states[:, -1:],
+ attention_mask=None,
+ encoder_hidden_states=encoder_last_hidden_state,
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=True,
+ output_attentions=output_cross_attentions,
+ return_dict=True,
+ )
+
+ if output_cross_attentions:
+ cross_attentions.append(torch.cat(decoder_out.cross_attentions, dim=0))
+
+ last_decoder_output = decoder_out.last_hidden_state.squeeze(1)
+ past_key_values = decoder_out.past_key_values
+
+ # Predict the new mel spectrum for this step in the sequence.
+ spectrum = model.speech_decoder_postnet.feat_out(last_decoder_output)
+ spectrum = spectrum.view(bsz, model.config.reduction_factor, model.config.num_mel_bins)
+ spectrogram.append(spectrum)
+
+ # Extend the output sequence with the new mel spectrum.
+ new_spectrogram = spectrum[:, -1, :].view(bsz, 1, model.config.num_mel_bins)
+ output_sequence = torch.cat((output_sequence, new_spectrogram), dim=1)
+ # Predict the probability that this is the stop token.
+ prob = torch.sigmoid(model.speech_decoder_postnet.prob_out(last_decoder_output))
+
+ if idx < minlen:
+ continue
+ else:
+ # If the generation loop is less than maximum length time, check the ones in the batch that have met
+ # the prob threshold. Otherwise, assume all have met thresholds and fill other spectrograms for the batch.
+ if idx < maxlen:
+ meet_thresholds = torch.sum(prob, dim=-1) >= threshold
+ meet_indexes = torch.where(meet_thresholds)[0].tolist()
+ else:
+ meet_indexes = range(len(prob))
+ meet_indexes = [i for i in meet_indexes if i not in result_spectrogram]
+ if len(meet_indexes) > 0:
+ spectrograms = torch.stack(spectrogram)
+ spectrograms = spectrograms.transpose(0, 1).flatten(1, 2)
+ spectrograms = model.speech_decoder_postnet.postnet(spectrograms)
+ for meet_index in meet_indexes:
+ result_spectrogram[meet_index] = spectrograms[meet_index]
+ if len(result_spectrogram) >= bsz:
+ break
+ spectrograms = [result_spectrogram[i] for i in range(len(result_spectrogram))]
+ if not return_output_lengths:
+ spectrogram = spectrograms[0] if bsz == 1 else torch.nn.utils.rnn.pad_sequence(spectrograms, batch_first=True)
+ if vocoder is not None:
+ outputs = vocoder(spectrogram)
+ else:
+ outputs = spectrogram
+ if output_cross_attentions:
+ cross_attentions = torch.cat(cross_attentions, dim=2)
+ if bsz > 1:
+ cross_attentions = cross_attentions.view(
+ bsz, int(cross_attentions.size(0) / bsz), *cross_attentions.size()[-3:]
+ )
+ outputs = (outputs, cross_attentions)
+ else:
+ # batched return values should also include the spectrogram/waveform lengths
+ spectrogram_lengths = []
+ for i in range(bsz):
+ spectrogram_lengths.append(spectrograms[i].size(0))
+ if vocoder is None:
+ spectrograms = torch.nn.utils.rnn.pad_sequence(spectrograms, batch_first=True)
+ outputs = (spectrograms, spectrogram_lengths)
+ else:
+ waveforms = []
+ spectrograms = torch.nn.utils.rnn.pad_sequence(spectrograms, batch_first=True)
+ waveforms = vocoder(spectrograms)
+ waveform_lengths = [int(waveforms.size(1) / max(spectrogram_lengths)) * i for i in spectrogram_lengths]
+ outputs = (waveforms, waveform_lengths)
+ if output_cross_attentions:
+ cross_attentions = torch.cat(cross_attentions, dim=2)
+ cross_attentions = cross_attentions.view(
+ bsz, int(cross_attentions.size(0) / bsz), *cross_attentions.size()[-3:]
+ )
+ outputs = (*outputs, cross_attentions)
+ return outputs
+
+
+@auto_docstring(
+ custom_intro="""
+ SpeechT5 Model with a text encoder and a speech decoder.
+ """
+)
+class SpeechT5ForTextToSpeech(SpeechT5PreTrainedModel):
+ input_modalities = ("text",)
+ main_input_name = "input_ids"
+
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+
+ if config.vocab_size is None:
+ raise ValueError(
+ f"You are trying to instantiate {self.__class__} with a configuration that does not define the"
+ " vocabulary size of the language model head. Please instantiate the model as follows:"
+ " `SpeechT5ForTextToSpeech.from_pretrained(..., vocab_size=vocab_size)`. or define `vocab_size` of"
+ " your model's configuration."
+ )
+
+ text_encoder = SpeechT5EncoderWithTextPrenet(config)
+ speech_decoder = SpeechT5DecoderWithSpeechPrenet(config)
+ self.speecht5 = SpeechT5Model(config, text_encoder, speech_decoder)
+
+ self.speech_decoder_postnet = SpeechT5SpeechDecoderPostnet(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @classmethod
+ def can_generate(cls) -> bool:
+ # Speecht5 has a unique model structure, where the external class (`SpeechT5ForTextToSpeech`) doesn't need to inherit from
+ # `GenerationMixin` (it has a non-standard generation method). This means that the base `can_generate()` will return `False`,
+ # but we need to override it so as to do `GenerationConfig` handling in multiple parts of the codebase.
+ return True
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ decoder_input_values: torch.FloatTensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ speaker_embeddings: torch.FloatTensor | None = None,
+ labels: torch.FloatTensor | None = None,
+ stop_labels: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple | Seq2SeqSpectrogramOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`SpeechT5Tokenizer`]. See [`~PreTrainedTokenizer.encode`] and
+ [`~PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ decoder_input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_mel_bins)`):
+ Float values of input mel spectrogram.
+
+ SpeechT5 uses an all-zero spectrum as the starting token for `decoder_input_values` generation. If
+ `past_key_values` is used, optionally only the last `decoder_input_values` have to be input (see
+ `past_key_values`).
+ decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_values`. Causal mask will
+ also be used by default.
+
+ If you want to change padding behavior, you should read [`SpeechT5Decoder._prepare_decoder_attention_mask`]
+ and modify to your needs. See diagram 1 in [the paper](https://huggingface.co/papers/1910.13461) for more
+ information on the default strategy.
+ speaker_embeddings (`torch.FloatTensor` of shape `(batch_size, config.speaker_embedding_dim)`, *optional*):
+ Tensor containing the speaker embeddings.
+ labels (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_mel_bins)`, *optional*):
+ Float values of target mel spectrogram. Timesteps set to `-100.0` are ignored (masked) for the loss
+ computation. Spectrograms can be obtained using [`SpeechT5Processor`]. See [`SpeechT5Processor.__call__`]
+ for details.
+ stop_labels (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Binary tensor indicating the position of the stop token in the sequence.
+
+ Example:
+
+ ```python
+ >>> from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan, set_seed
+ >>> import torch
+
+ >>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
+ >>> model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")
+ >>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
+
+ >>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
+ >>> speaker_embeddings = torch.zeros((1, 512)) # or load xvectors from a file
+
+ >>> set_seed(555) # make deterministic
+
+ >>> # generate speech
+ >>> speech = model.generate(inputs["input_ids"], speaker_embeddings=speaker_embeddings, vocoder=vocoder)
+ >>> speech.shape
+ torch.Size([15872])
+ ```
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if labels is not None:
+ if decoder_input_values is None:
+ decoder_input_values, decoder_attention_mask = shift_spectrograms_right(
+ labels, self.config.reduction_factor, decoder_attention_mask
+ )
+ if self.config.use_guided_attention_loss:
+ output_attentions = True
+
+ outputs = self.speecht5(
+ input_values=input_ids,
+ attention_mask=attention_mask,
+ decoder_input_values=decoder_input_values,
+ decoder_attention_mask=decoder_attention_mask,
+ encoder_outputs=encoder_outputs,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ speaker_embeddings=speaker_embeddings,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=True,
+ )
+
+ outputs_before_postnet, outputs_after_postnet, logits = self.speech_decoder_postnet(outputs[0])
+
+ loss = None
+ if labels is not None:
+ criterion = SpeechT5SpectrogramLoss(self.config)
+ loss = criterion(
+ attention_mask,
+ outputs_before_postnet,
+ outputs_after_postnet,
+ logits,
+ labels,
+ outputs.cross_attentions,
+ )
+
+ if not return_dict:
+ output = (outputs_after_postnet,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return Seq2SeqSpectrogramOutput(
+ loss=loss,
+ spectrogram=outputs_after_postnet,
+ past_key_values=outputs.past_key_values,
+ decoder_hidden_states=outputs.decoder_hidden_states,
+ decoder_attentions=outputs.decoder_attentions,
+ cross_attentions=outputs.cross_attentions,
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+ encoder_hidden_states=outputs.encoder_hidden_states,
+ encoder_attentions=outputs.encoder_attentions,
+ )
+
+ @torch.no_grad()
+ def generate(
+ self,
+ input_ids: torch.LongTensor,
+ attention_mask: torch.LongTensor | None = None,
+ speaker_embeddings: torch.FloatTensor | None = None,
+ threshold: float = 0.5,
+ minlenratio: float = 0.0,
+ maxlenratio: float = 20.0,
+ vocoder: nn.Module | None = None,
+ output_cross_attentions: bool = False,
+ return_output_lengths: bool = False,
+ **kwargs,
+ ) -> torch.FloatTensor | tuple[torch.FloatTensor, torch.FloatTensor]:
+ r"""
+ Converts a sequence of input tokens into a sequence of mel spectrograms, which are subsequently turned into a
+ speech waveform using a vocoder.
+
+ Args:
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`SpeechT5Tokenizer`]. See [`~PreTrainedTokenizer.encode`] and
+ [`~PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ attention_mask (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Attention mask from the tokenizer, required for batched inference to signal to the model where to
+ ignore padded tokens from the input_ids.
+ speaker_embeddings (`torch.FloatTensor` of shape `(batch_size, config.speaker_embedding_dim)`, *optional*):
+ Tensor containing the speaker embeddings.
+ threshold (`float`, *optional*, defaults to 0.5):
+ The generated sequence ends when the predicted stop token probability exceeds this value.
+ minlenratio (`float`, *optional*, defaults to 0.0):
+ Used to calculate the minimum required length for the output sequence.
+ maxlenratio (`float`, *optional*, defaults to 20.0):
+ Used to calculate the maximum allowed length for the output sequence.
+ vocoder (`nn.Module`, *optional*):
+ The vocoder that converts the mel spectrogram into a speech waveform. If `None`, the output is the mel
+ spectrogram.
+ output_cross_attentions (`bool`, *optional*, defaults to `False`):
+ Whether or not to return the attentions tensors of the decoder's cross-attention layers.
+ return_output_lengths (`bool`, *optional*, defaults to `False`):
+ Whether or not to return the concrete spectrogram/waveform lengths.
+
+ Returns:
+ `tuple(torch.FloatTensor)` comprising various elements depending on the inputs:
+ - when `return_output_lengths` is False
+ - **spectrogram** (*optional*, returned when no `vocoder` is provided) `torch.FloatTensor` of shape
+ `(output_sequence_length, config.num_mel_bins)` -- The predicted log-mel spectrogram.
+ - **waveform** (*optional*, returned when a `vocoder` is provided) `torch.FloatTensor` of shape
+ `(num_frames,)` -- The predicted speech waveform.
+ - **cross_attentions** (*optional*, returned when `output_cross_attentions` is `True`)
+ `torch.FloatTensor` of shape `(config.decoder_layers, config.decoder_attention_heads,
+ output_sequence_length, input_sequence_length)` -- The outputs of the decoder's cross-attention layers.
+ - when `return_output_lengths` is True
+ - **spectrograms** (*optional*, returned when no `vocoder` is provided) `torch.FloatTensor` of shape
+ `(batch_size, output_sequence_length, config.num_mel_bins)` -- The predicted log-mel spectrograms that
+ are padded to the maximum length.
+ - **spectrogram_lengths** (*optional*, returned when no `vocoder` is provided) `list[Int]` -- A list of
+ all the concrete lengths for each spectrogram.
+ - **waveforms** (*optional*, returned when a `vocoder` is provided) `torch.FloatTensor` of shape
+ `(batch_size, num_frames)` -- The predicted speech waveforms that are padded to the maximum length.
+ - **waveform_lengths** (*optional*, returned when a `vocoder` is provided) `list[Int]` -- A list of all
+ the concrete lengths for each waveform.
+ - **cross_attentions** (*optional*, returned when `output_cross_attentions` is `True`)
+ `torch.FloatTensor` of shape `(batch_size, config.decoder_layers, config.decoder_attention_heads,
+ output_sequence_length, input_sequence_length)` -- The outputs of the decoder's cross-attention layers.
+ """
+ if speaker_embeddings is not None:
+ batch_size = input_ids.size(0)
+ if speaker_embeddings.size(0) != batch_size:
+ if speaker_embeddings.size(0) == 1:
+ speaker_embeddings = speaker_embeddings.repeat(batch_size, 1)
+ else:
+ raise ValueError(
+ "The first dimension of speaker_embeddings must be either 1 or the same as batch_size."
+ )
+
+ return _generate_speech(
+ self,
+ input_ids,
+ speaker_embeddings,
+ attention_mask,
+ threshold,
+ minlenratio,
+ maxlenratio,
+ vocoder,
+ output_cross_attentions,
+ return_output_lengths,
+ )
+
+ @torch.no_grad()
+ def generate_speech(
+ self,
+ input_ids: torch.LongTensor,
+ speaker_embeddings: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ threshold: float = 0.5,
+ minlenratio: float = 0.0,
+ maxlenratio: float = 20.0,
+ vocoder: nn.Module | None = None,
+ output_cross_attentions: bool = False,
+ return_output_lengths: bool = False,
+ ) -> torch.FloatTensor | tuple[torch.FloatTensor, torch.FloatTensor]:
+ r"""
+ Converts a sequence of input tokens into a sequence of mel spectrograms, which are subsequently turned into a
+ speech waveform using a vocoder.
+
+ Args:
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`SpeechT5Tokenizer`]. See [`~PreTrainedTokenizer.encode`] and
+ [`~PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ speaker_embeddings (`torch.FloatTensor` of shape `(batch_size, config.speaker_embedding_dim)`, *optional*):
+ Tensor containing the speaker embeddings.
+ attention_mask (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing convolution and attention on padding token indices. Mask values selected in
+ `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ threshold (`float`, *optional*, defaults to 0.5):
+ The generated sequence ends when the predicted stop token probability exceeds this value.
+ minlenratio (`float`, *optional*, defaults to 0.0):
+ Used to calculate the minimum required length for the output sequence.
+ maxlenratio (`float`, *optional*, defaults to 20.0):
+ Used to calculate the maximum allowed length for the output sequence.
+ vocoder (`nn.Module`, *optional*, defaults to `None`):
+ The vocoder that converts the mel spectrogram into a speech waveform. If `None`, the output is the mel
+ spectrogram.
+ output_cross_attentions (`bool`, *optional*, defaults to `False`):
+ Whether or not to return the attentions tensors of the decoder's cross-attention layers.
+ return_output_lengths (`bool`, *optional*, defaults to `False`):
+ Whether or not to return the concrete spectrogram/waveform lengths.
+
+ Returns:
+ `tuple(torch.FloatTensor)` comprising various elements depending on the inputs:
+ - when `return_output_lengths` is False
+ - **spectrogram** (*optional*, returned when no `vocoder` is provided) `torch.FloatTensor` of shape
+ `(output_sequence_length, config.num_mel_bins)` -- The predicted log-mel spectrogram.
+ - **waveform** (*optional*, returned when a `vocoder` is provided) `torch.FloatTensor` of shape
+ `(num_frames,)` -- The predicted speech waveform.
+ - **cross_attentions** (*optional*, returned when `output_cross_attentions` is `True`)
+ `torch.FloatTensor` of shape `(config.decoder_layers, config.decoder_attention_heads,
+ output_sequence_length, input_sequence_length)` -- The outputs of the decoder's cross-attention layers.
+ - when `return_output_lengths` is True
+ - **spectrograms** (*optional*, returned when no `vocoder` is provided) `torch.FloatTensor` of shape
+ `(batch_size, output_sequence_length, config.num_mel_bins)` -- The predicted log-mel spectrograms that
+ are padded to the maximum length.
+ - **spectrogram_lengths** (*optional*, returned when no `vocoder` is provided) `list[Int]` -- A list of
+ all the concrete lengths for each spectrogram.
+ - **waveforms** (*optional*, returned when a `vocoder` is provided) `torch.FloatTensor` of shape
+ `(batch_size, num_frames)` -- The predicted speech waveforms that are padded to the maximum length.
+ - **waveform_lengths** (*optional*, returned when a `vocoder` is provided) `list[Int]` -- A list of all
+ the concrete lengths for each waveform.
+ - **cross_attentions** (*optional*, returned when `output_cross_attentions` is `True`)
+ `torch.FloatTensor` of shape `(batch_size, config.decoder_layers, config.decoder_attention_heads,
+ output_sequence_length, input_sequence_length)` -- The outputs of the decoder's cross-attention layers.
+ """
+ if speaker_embeddings is not None:
+ batch_size = input_ids.size(0)
+ if speaker_embeddings.size(0) != batch_size:
+ if speaker_embeddings.size(0) == 1:
+ speaker_embeddings = speaker_embeddings.repeat(batch_size, 1)
+ else:
+ raise ValueError(
+ "The first dimension of speaker_embeddings must be either 1 or the same as batch size."
+ )
+
+ return _generate_speech(
+ self,
+ input_ids,
+ speaker_embeddings,
+ attention_mask,
+ threshold,
+ minlenratio,
+ maxlenratio,
+ vocoder,
+ output_cross_attentions,
+ return_output_lengths,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ SpeechT5 Model with a speech encoder and a speech decoder.
+ """
+)
+class SpeechT5ForSpeechToSpeech(SpeechT5PreTrainedModel):
+ def __init__(self, config: SpeechT5Config):
+ super().__init__(config)
+
+ speech_encoder = SpeechT5EncoderWithSpeechPrenet(config)
+ speech_decoder = SpeechT5DecoderWithSpeechPrenet(config)
+ self.speecht5 = SpeechT5Model(config, speech_encoder, speech_decoder)
+
+ self.speech_decoder_postnet = SpeechT5SpeechDecoderPostnet(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.get_encoder().prenet.freeze_feature_encoder()
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ decoder_input_values: torch.FloatTensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ speaker_embeddings: torch.FloatTensor | None = None,
+ labels: torch.FloatTensor | None = None,
+ stop_labels: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple | Seq2SeqSpectrogramOutput:
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Float values of input raw speech waveform. Values can be obtained by loading a *.flac* or *.wav* audio file
+ into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library
+ (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
+ To prepare the array into `input_values`, the [`SpeechT5Processor`] should be used for padding and conversion into
+ a tensor of type `torch.FloatTensor`. See [`SpeechT5Processor.__call__`] for details.
+ decoder_input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_mel_bins)`):
+ Float values of input mel spectrogram.
+
+ SpeechT5 uses an all-zero spectrum as the starting token for `decoder_input_values` generation. If
+ `past_key_values` is used, optionally only the last `decoder_input_values` have to be input (see
+ `past_key_values`).
+ decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_values`. Causal mask will
+ also be used by default.
+
+ If you want to change padding behavior, you should read [`SpeechT5Decoder._prepare_decoder_attention_mask`]
+ and modify to your needs. See diagram 1 in [the paper](https://huggingface.co/papers/1910.13461) for more
+ information on the default strategy.
+ speaker_embeddings (`torch.FloatTensor` of shape `(batch_size, config.speaker_embedding_dim)`, *optional*):
+ Tensor containing the speaker embeddings.
+ labels (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.num_mel_bins)`, *optional*):
+ Float values of target mel spectrogram. Spectrograms can be obtained using [`SpeechT5Processor`]. See
+ [`SpeechT5Processor.__call__`] for details.
+ stop_labels (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Binary tensor indicating the position of the stop token in the sequence.
+
+ Example:
+
+ ```python
+ >>> from transformers import SpeechT5Processor, SpeechT5ForSpeechToSpeech, SpeechT5HifiGan, set_seed
+ >>> from datasets import load_dataset
+ >>> import torch
+
+ >>> dataset = load_dataset(
+ ... "hf-internal-testing/librispeech_asr_demo", "clean", split="validation"
+ ... ) # doctest: +IGNORE_RESULT
+ >>> dataset = dataset.sort("id")
+ >>> sampling_rate = dataset.features["audio"].sampling_rate
+
+ >>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_vc")
+ >>> model = SpeechT5ForSpeechToSpeech.from_pretrained("microsoft/speecht5_vc")
+ >>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
+
+ >>> # audio file is decoded on the fly
+ >>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
+
+ >>> speaker_embeddings = torch.zeros((1, 512)) # or load xvectors from a file
+
+ >>> set_seed(555) # make deterministic
+
+ >>> # generate speech
+ >>> speech = model.generate_speech(inputs["input_values"], speaker_embeddings, vocoder=vocoder)
+ >>> speech.shape
+ torch.Size([77824])
+ ```
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if labels is not None:
+ if decoder_input_values is None:
+ decoder_input_values, decoder_attention_mask = shift_spectrograms_right(
+ labels, self.config.reduction_factor, decoder_attention_mask
+ )
+
+ outputs = self.speecht5(
+ input_values=input_values,
+ attention_mask=attention_mask,
+ decoder_input_values=decoder_input_values,
+ decoder_attention_mask=decoder_attention_mask,
+ encoder_outputs=encoder_outputs,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ speaker_embeddings=speaker_embeddings,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=True,
+ )
+
+ _, spectrogram, logits = self.speech_decoder_postnet(outputs[0])
+
+ loss = None
+
+ if not return_dict:
+ output = (spectrogram,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return Seq2SeqSpectrogramOutput(
+ loss=loss,
+ spectrogram=spectrogram,
+ past_key_values=outputs.past_key_values,
+ decoder_hidden_states=outputs.decoder_hidden_states,
+ decoder_attentions=outputs.decoder_attentions,
+ cross_attentions=outputs.cross_attentions,
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+ encoder_hidden_states=outputs.encoder_hidden_states,
+ encoder_attentions=outputs.encoder_attentions,
+ )
+
+ @torch.no_grad()
+ def generate_speech(
+ self,
+ input_values: torch.FloatTensor,
+ speaker_embeddings: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ threshold: float = 0.5,
+ minlenratio: float = 0.0,
+ maxlenratio: float = 20.0,
+ vocoder: nn.Module | None = None,
+ output_cross_attentions: bool = False,
+ return_output_lengths: bool = False,
+ ) -> torch.FloatTensor:
+ r"""
+ Converts a raw speech waveform into a sequence of mel spectrograms, which are subsequently turned back into a
+ speech waveform using a vocoder.
+
+ Args:
+ input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Float values of input raw speech waveform.
+
+ Values can be obtained by loading a *.flac* or *.wav* audio file into an array of type `list[float]`,
+ a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library (`pip install torchcodec`)
+ or the soundfile library (`pip install soundfile`).
+ To prepare the array into `input_values`, the [`SpeechT5Processor`] should be used for padding and
+ conversion into a tensor of type `torch.FloatTensor`. See [`SpeechT5Processor.__call__`] for details.
+ speaker_embeddings (`torch.FloatTensor` of shape `(batch_size, config.speaker_embedding_dim)`, *optional*):
+ Tensor containing the speaker embeddings.
+ attention_mask (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing convolution and attention on padding token indices. Mask values selected in
+ `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ threshold (`float`, *optional*, defaults to 0.5):
+ The generated sequence ends when the predicted stop token probability exceeds this value.
+ minlenratio (`float`, *optional*, defaults to 0.0):
+ Used to calculate the minimum required length for the output sequence.
+ maxlenratio (`float`, *optional*, defaults to 20.0):
+ Used to calculate the maximum allowed length for the output sequence.
+ vocoder (`nn.Module`, *optional*, defaults to `None`):
+ The vocoder that converts the mel spectrogram into a speech waveform. If `None`, the output is the mel
+ spectrogram.
+ output_cross_attentions (`bool`, *optional*, defaults to `False`):
+ Whether or not to return the attentions tensors of the decoder's cross-attention layers.
+ return_output_lengths (`bool`, *optional*, defaults to `False`):
+ Whether or not to return the concrete spectrogram/waveform lengths.
+
+ Returns:
+ `tuple(torch.FloatTensor)` comprising various elements depending on the inputs:
+ - when `return_output_lengths` is False
+ - **spectrogram** (*optional*, returned when no `vocoder` is provided) `torch.FloatTensor` of shape
+ `(output_sequence_length, config.num_mel_bins)` -- The predicted log-mel spectrogram.
+ - **waveform** (*optional*, returned when a `vocoder` is provided) `torch.FloatTensor` of shape
+ `(num_frames,)` -- The predicted speech waveform.
+ - **cross_attentions** (*optional*, returned when `output_cross_attentions` is `True`)
+ `torch.FloatTensor` of shape `(config.decoder_layers, config.decoder_attention_heads,
+ output_sequence_length, input_sequence_length)` -- The outputs of the decoder's cross-attention layers.
+ - when `return_output_lengths` is True
+ - **spectrograms** (*optional*, returned when no `vocoder` is provided) `torch.FloatTensor` of shape
+ `(batch_size, output_sequence_length, config.num_mel_bins)` -- The predicted log-mel spectrograms that
+ are padded to the maximum length.
+ - **spectrogram_lengths** (*optional*, returned when no `vocoder` is provided) `list[Int]` -- A list of
+ all the concrete lengths for each spectrogram.
+ - **waveforms** (*optional*, returned when a `vocoder` is provided) `torch.FloatTensor` of shape
+ `(batch_size, num_frames)` -- The predicted speech waveforms that are padded to the maximum length.
+ - **waveform_lengths** (*optional*, returned when a `vocoder` is provided) `list[Int]` -- A list of all
+ the concrete lengths for each waveform.
+ - **cross_attentions** (*optional*, returned when `output_cross_attentions` is `True`)
+ `torch.FloatTensor` of shape `(batch_size, config.decoder_layers, config.decoder_attention_heads,
+ output_sequence_length, input_sequence_length)` -- The outputs of the decoder's cross-attention layers.
+ """
+ if speaker_embeddings is None:
+ speaker_embeddings = torch.zeros((1, 512), device=input_values.device)
+
+ return _generate_speech(
+ self,
+ input_values,
+ speaker_embeddings,
+ attention_mask,
+ threshold,
+ minlenratio,
+ maxlenratio,
+ vocoder,
+ output_cross_attentions,
+ return_output_lengths,
+ )
+
+
+class HifiGanResidualBlock(nn.Module):
+ def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5), leaky_relu_slope=0.1):
+ super().__init__()
+ self.leaky_relu_slope = leaky_relu_slope
+
+ self.convs1 = nn.ModuleList(
+ [
+ nn.Conv1d(
+ channels,
+ channels,
+ kernel_size,
+ stride=1,
+ dilation=dilation[i],
+ padding=self.get_padding(kernel_size, dilation[i]),
+ )
+ for i in range(len(dilation))
+ ]
+ )
+ self.convs2 = nn.ModuleList(
+ [
+ nn.Conv1d(
+ channels,
+ channels,
+ kernel_size,
+ stride=1,
+ dilation=1,
+ padding=self.get_padding(kernel_size, 1),
+ )
+ for _ in range(len(dilation))
+ ]
+ )
+
+ def get_padding(self, kernel_size, dilation=1):
+ return (kernel_size * dilation - dilation) // 2
+
+ def apply_weight_norm(self):
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ for layer in self.convs1:
+ weight_norm(layer)
+ for layer in self.convs2:
+ weight_norm(layer)
+
+ def remove_weight_norm(self):
+ for layer in self.convs1:
+ nn.utils.remove_weight_norm(layer)
+ for layer in self.convs2:
+ nn.utils.remove_weight_norm(layer)
+
+ def forward(self, hidden_states):
+ for conv1, conv2 in zip(self.convs1, self.convs2):
+ residual = hidden_states
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.leaky_relu_slope)
+ hidden_states = conv1(hidden_states)
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.leaky_relu_slope)
+ hidden_states = conv2(hidden_states)
+ hidden_states = hidden_states + residual
+ return hidden_states
+
+
+@auto_docstring(
+ custom_intro="""
+ HiFi-GAN vocoder.
+ """
+)
+class SpeechT5HifiGan(PreTrainedModel):
+ config: SpeechT5HifiGanConfig
+ main_input_name = "spectrogram"
+
+ def __init__(self, config: SpeechT5HifiGanConfig):
+ super().__init__(config)
+ self.num_kernels = len(config.resblock_kernel_sizes)
+ self.num_upsamples = len(config.upsample_rates)
+ self.conv_pre = nn.Conv1d(
+ config.model_in_dim,
+ config.upsample_initial_channel,
+ kernel_size=7,
+ stride=1,
+ padding=3,
+ )
+
+ self.upsampler = nn.ModuleList()
+ for i, (upsample_rate, kernel_size) in enumerate(zip(config.upsample_rates, config.upsample_kernel_sizes)):
+ self.upsampler.append(
+ nn.ConvTranspose1d(
+ config.upsample_initial_channel // (2**i),
+ config.upsample_initial_channel // (2 ** (i + 1)),
+ kernel_size=kernel_size,
+ stride=upsample_rate,
+ padding=(kernel_size - upsample_rate) // 2,
+ )
+ )
+
+ self.resblocks = nn.ModuleList()
+ for i in range(len(self.upsampler)):
+ channels = config.upsample_initial_channel // (2 ** (i + 1))
+ for kernel_size, dilation in zip(config.resblock_kernel_sizes, config.resblock_dilation_sizes):
+ self.resblocks.append(HifiGanResidualBlock(channels, kernel_size, dilation, config.leaky_relu_slope))
+
+ self.conv_post = nn.Conv1d(channels, 1, kernel_size=7, stride=1, padding=3)
+
+ self.register_buffer("mean", torch.zeros(config.model_in_dim))
+ self.register_buffer("scale", torch.ones(config.model_in_dim))
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, SpeechT5HifiGan):
+ init.zeros_(module.mean)
+ init.ones_(module.scale)
+
+ def apply_weight_norm(self):
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ weight_norm(self.conv_pre)
+ for layer in self.upsampler:
+ weight_norm(layer)
+ for layer in self.resblocks:
+ layer.apply_weight_norm()
+ weight_norm(self.conv_post)
+
+ def remove_weight_norm(self):
+ nn.utils.remove_weight_norm(self.conv_pre)
+ for layer in self.upsampler:
+ nn.utils.remove_weight_norm(layer)
+ for layer in self.resblocks:
+ layer.remove_weight_norm()
+ nn.utils.remove_weight_norm(self.conv_post)
+
+ @auto_docstring(
+ custom_intro="""
+ Converts a log-mel spectrogram into a speech waveform. Passing a batch of log-mel spectrograms returns a batch
+ of speech waveforms. Passing a single, un-batched log-mel spectrogram returns a single, un-batched speech
+ waveform.
+ """
+ )
+ def forward(self, spectrogram: torch.FloatTensor, **kwargs) -> torch.FloatTensor:
+ r"""
+ spectrogram (`torch.FloatTensor`):
+ Tensor containing the log-mel spectrograms. Can be batched and of shape `(batch_size, sequence_length,
+ config.model_in_dim)`, or un-batched and of shape `(sequence_length, config.model_in_dim)`.
+
+ Returns:
+ `torch.FloatTensor`: Tensor containing the speech waveform. If the input spectrogram is batched, will be of
+ shape `(batch_size, num_frames,)`. If un-batched, will be of shape `(num_frames,)`.
+ """
+ if self.config.normalize_before:
+ spectrogram = (spectrogram - self.mean) / self.scale
+
+ is_batched = spectrogram.dim() == 3
+ if not is_batched:
+ spectrogram = spectrogram.unsqueeze(0)
+
+ hidden_states = spectrogram.transpose(2, 1)
+
+ hidden_states = self.conv_pre(hidden_states)
+ for i in range(self.num_upsamples):
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.config.leaky_relu_slope)
+ hidden_states = self.upsampler[i](hidden_states)
+
+ res_state = self.resblocks[i * self.num_kernels](hidden_states)
+ for j in range(1, self.num_kernels):
+ res_state += self.resblocks[i * self.num_kernels + j](hidden_states)
+ hidden_states = res_state / self.num_kernels
+
+ hidden_states = nn.functional.leaky_relu(hidden_states)
+ hidden_states = self.conv_post(hidden_states)
+ hidden_states = torch.tanh(hidden_states)
+
+ if not is_batched:
+ # remove batch dim and collapse tensor to 1-d audio waveform
+ waveform = hidden_states.squeeze(0).transpose(1, 0).view(-1)
+ else:
+ # remove seq-len dim since this collapses to 1
+ waveform = hidden_states.squeeze(1)
+
+ return waveform
+
+
+__all__ = [
+ "SpeechT5ForSpeechToText",
+ "SpeechT5ForSpeechToSpeech",
+ "SpeechT5ForTextToSpeech",
+ "SpeechT5Model",
+ "SpeechT5PreTrainedModel",
+ "SpeechT5HifiGan",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bfc35a5231684216d61e82bd982e9b5c70057f61
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/configuration_superglue.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/configuration_superglue.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c1bd8527014db6edf2524e386fbafe06822154f1
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/configuration_superglue.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/image_processing_pil_superglue.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/image_processing_pil_superglue.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a4f1c6a2bd6c8044f2e43fcb5801926005fc561
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/image_processing_pil_superglue.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/image_processing_superglue.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/image_processing_superglue.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..91321043e12f7734dc349545b98c3439e1617aed
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/image_processing_superglue.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/modeling_superglue.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/modeling_superglue.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..884607bd7f2969e8787cdbdc3b499e5792af34b4
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superglue/__pycache__/modeling_superglue.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superglue/modeling_superglue.py b/lib/python3.11/site-packages/transformers/models/superglue/modeling_superglue.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b88ddce9492a42796553bea23fe0a3f715efe6d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/superglue/modeling_superglue.py
@@ -0,0 +1,758 @@
+# Copyright 2024 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.
+"""PyTorch SuperGlue model."""
+
+import math
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from transformers import PreTrainedModel
+from transformers.models.superglue.configuration_superglue import SuperGlueConfig
+
+from ... import initialization as init
+from ...masking_utils import create_bidirectional_mask
+from ...utils import ModelOutput, auto_docstring, logging
+from ..auto import AutoModelForKeypointDetection
+
+
+logger = logging.get_logger(__name__)
+
+
+def concat_pairs(tensor_tuple0: tuple[torch.Tensor], tensor_tuple1: tuple[torch.Tensor]) -> tuple[torch.Tensor]:
+ """
+ Concatenate two tuples of tensors pairwise
+
+ Args:
+ tensor_tuple0 (`tuple[torch.Tensor]`):
+ Tuple of tensors.
+ tensor_tuple1 (`tuple[torch.Tensor]`):
+ Tuple of tensors.
+
+ Returns:
+ (`tuple[torch.Tensor]`): Tuple of concatenated tensors.
+ """
+ return tuple(torch.cat([tensor0, tensor1]) for tensor0, tensor1 in zip(tensor_tuple0, tensor_tuple1))
+
+
+def normalize_keypoints(keypoints: torch.Tensor, height: int, width: int) -> torch.Tensor:
+ """
+ Normalize keypoints locations based on image image_shape
+
+ Args:
+ keypoints (`torch.Tensor` of shape `(batch_size, num_keypoints, 2)`):
+ Keypoints locations in (x, y) format.
+ height (`int`):
+ Image height.
+ width (`int`):
+ Image width.
+
+ Returns:
+ Normalized keypoints locations of shape (`torch.Tensor` of shape `(batch_size, num_keypoints, 2)`).
+ """
+ size = torch.tensor([width, height], device=keypoints.device, dtype=keypoints.dtype)[None]
+ center = size / 2
+ scaling = size.max(1, keepdim=True).values * 0.7
+ return (keypoints - center[:, None, :]) / scaling[:, None, :]
+
+
+def log_sinkhorn_iterations(
+ log_cost_matrix: torch.Tensor,
+ log_source_distribution: torch.Tensor,
+ log_target_distribution: torch.Tensor,
+ num_iterations: int,
+) -> torch.Tensor:
+ """
+ Perform Sinkhorn Normalization in Log-space for stability
+
+ Args:
+ log_cost_matrix (`torch.Tensor` of shape `(batch_size, num_rows, num_columns)`):
+ Logarithm of the cost matrix.
+ log_source_distribution (`torch.Tensor` of shape `(batch_size, num_rows)`):
+ Logarithm of the source distribution.
+ log_target_distribution (`torch.Tensor` of shape `(batch_size, num_columns)`):
+ Logarithm of the target distribution.
+
+ Returns:
+ log_cost_matrix (`torch.Tensor` of shape `(batch_size, num_rows, num_columns)`): Logarithm of the optimal
+ transport matrix.
+ """
+ log_u_scaling = torch.zeros_like(log_source_distribution)
+ log_v_scaling = torch.zeros_like(log_target_distribution)
+ for _ in range(num_iterations):
+ log_u_scaling = log_source_distribution - torch.logsumexp(log_cost_matrix + log_v_scaling.unsqueeze(1), dim=2)
+ log_v_scaling = log_target_distribution - torch.logsumexp(log_cost_matrix + log_u_scaling.unsqueeze(2), dim=1)
+ return log_cost_matrix + log_u_scaling.unsqueeze(2) + log_v_scaling.unsqueeze(1)
+
+
+def log_optimal_transport(scores: torch.Tensor, reg_param: torch.Tensor, iterations: int) -> torch.Tensor:
+ """
+ Perform Differentiable Optimal Transport in Log-space for stability
+
+ Args:
+ scores: (`torch.Tensor` of shape `(batch_size, num_rows, num_columns)`):
+ Cost matrix.
+ reg_param: (`torch.Tensor` of shape `(batch_size, 1, 1)`):
+ Regularization parameter.
+ iterations: (`int`):
+ Number of Sinkhorn iterations.
+
+ Returns:
+ log_optimal_transport_matrix: (`torch.Tensor` of shape `(batch_size, num_rows, num_columns)`): Logarithm of the
+ optimal transport matrix.
+ """
+ batch_size, num_rows, num_columns = scores.shape
+ one_tensor = scores.new_tensor(1)
+ num_rows_tensor, num_columns_tensor = (num_rows * one_tensor).to(scores), (num_columns * one_tensor).to(scores)
+
+ source_reg_param = reg_param.expand(batch_size, num_rows, 1)
+ target_reg_param = reg_param.expand(batch_size, 1, num_columns)
+ reg_param = reg_param.expand(batch_size, 1, 1)
+
+ couplings = torch.cat([torch.cat([scores, source_reg_param], -1), torch.cat([target_reg_param, reg_param], -1)], 1)
+
+ log_normalization = -(num_rows_tensor + num_columns_tensor).log()
+ log_source_distribution = torch.cat(
+ [log_normalization.expand(num_rows), num_columns_tensor.log()[None] + log_normalization]
+ )
+ log_target_distribution = torch.cat(
+ [log_normalization.expand(num_columns), num_rows_tensor.log()[None] + log_normalization]
+ )
+ log_source_distribution, log_target_distribution = (
+ log_source_distribution[None].expand(batch_size, -1),
+ log_target_distribution[None].expand(batch_size, -1),
+ )
+
+ log_optimal_transport_matrix = log_sinkhorn_iterations(
+ couplings, log_source_distribution, log_target_distribution, num_iterations=iterations
+ )
+ log_optimal_transport_matrix = log_optimal_transport_matrix - log_normalization # multiply probabilities by M+N
+ return log_optimal_transport_matrix
+
+
+def arange_like(x, dim: int) -> torch.Tensor:
+ return x.new_ones(x.shape[dim]).cumsum(0) - 1
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for outputs of SuperGlue keypoint matching models. Due to the nature of keypoint detection and matching, the number
+ of keypoints is not fixed and can vary from image to image, which makes batching non-trivial. In the batch of
+ images, the maximum number of matches is set as the dimension of the matches and matching scores. The mask tensor is
+ used to indicate which values in the keypoints, matches and matching_scores tensors are keypoint matching
+ information.
+ """
+)
+@dataclass
+class SuperGlueKeypointMatchingOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*):
+ Loss computed during training.
+ matches (`torch.FloatTensor` of shape `(batch_size, 2, num_matches)`):
+ Index of keypoint matched in the other image.
+ matching_scores (`torch.FloatTensor` of shape `(batch_size, 2, num_matches)`):
+ Scores of predicted matches.
+ keypoints (`torch.FloatTensor` of shape `(batch_size, num_keypoints, 2)`):
+ Absolute (x, y) coordinates of predicted keypoints in a given image.
+ mask (`torch.IntTensor` of shape `(batch_size, num_keypoints)`):
+ Mask indicating which values in matches and matching_scores are keypoint matching information.
+ hidden_states (`tuple[torch.FloatTensor, ...]`, *optional*):
+ Tuple of `torch.FloatTensor` (one for the output of each stage) of shape `(batch_size, 2, num_channels,
+ num_keypoints)`, returned when `output_hidden_states=True` is passed or when
+ `config.output_hidden_states=True`)
+ attentions (`tuple[torch.FloatTensor, ...]`, *optional*):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, 2, num_heads, num_keypoints,
+ num_keypoints)`, returned when `output_attentions=True` is passed or when `config.output_attentions=True`)
+ """
+
+ loss: torch.FloatTensor | None = None
+ matches: torch.FloatTensor | None = None
+ matching_scores: torch.FloatTensor | None = None
+ keypoints: torch.FloatTensor | None = None
+ mask: torch.IntTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+class SuperGlueMultiLayerPerceptron(nn.Module):
+ def __init__(self, config: SuperGlueConfig, in_channels: int, out_channels: int) -> None:
+ super().__init__()
+ self.linear = nn.Linear(in_channels, out_channels)
+ self.batch_norm = nn.BatchNorm1d(out_channels)
+ self.activation = nn.ReLU()
+
+ def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+ hidden_state = self.linear(hidden_state)
+ hidden_state = hidden_state.transpose(-1, -2)
+ hidden_state = self.batch_norm(hidden_state)
+ hidden_state = hidden_state.transpose(-1, -2)
+ hidden_state = self.activation(hidden_state)
+ return hidden_state
+
+
+class SuperGlueKeypointEncoder(nn.Module):
+ def __init__(self, config: SuperGlueConfig) -> None:
+ super().__init__()
+ layer_sizes = config.keypoint_encoder_sizes
+ hidden_size = config.hidden_size
+ # 3 here consists of 2 for the (x, y) coordinates and 1 for the score of the keypoint
+ encoder_channels = [3] + layer_sizes + [hidden_size]
+
+ layers = [
+ SuperGlueMultiLayerPerceptron(config, encoder_channels[i - 1], encoder_channels[i])
+ for i in range(1, len(encoder_channels) - 1)
+ ]
+ layers.append(nn.Linear(encoder_channels[-2], encoder_channels[-1]))
+ self.encoder = nn.ModuleList(layers)
+
+ def forward(
+ self,
+ keypoints: torch.Tensor,
+ scores: torch.Tensor,
+ output_hidden_states: bool | None = False,
+ ) -> tuple[torch.Tensor, tuple[torch.Tensor] | None]:
+ scores = scores.unsqueeze(2)
+ hidden_state = torch.cat([keypoints, scores], dim=2)
+ all_hidden_states = () if output_hidden_states else None
+ for layer in self.encoder:
+ hidden_state = layer(hidden_state)
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_state,)
+ return hidden_state, all_hidden_states
+
+
+class SuperGlueSelfAttention(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+ raise ValueError(
+ f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention "
+ f"heads ({config.num_attention_heads})"
+ )
+
+ self.num_attention_heads = config.num_attention_heads
+ self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+ self.all_head_size = self.num_attention_heads * self.attention_head_size
+
+ self.query = nn.Linear(config.hidden_size, self.all_head_size)
+ self.key = nn.Linear(config.hidden_size, self.all_head_size)
+ self.value = nn.Linear(config.hidden_size, self.all_head_size)
+
+ self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+
+ self.is_decoder = config.is_decoder
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.FloatTensor | None = None,
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor]:
+ # If this is instantiated as a cross-attention module, the keys
+ # and values come from an encoder; the attention mask needs to be
+ # such that the encoder's padding tokens are not attended to.
+ is_cross_attention = encoder_hidden_states is not None
+ current_states = encoder_hidden_states if is_cross_attention else hidden_states
+ attention_mask = encoder_attention_mask if is_cross_attention else attention_mask
+
+ batch_size = hidden_states.shape[0]
+ key_layer = (
+ self.key(current_states)
+ .view(batch_size, -1, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ )
+ value_layer = (
+ self.value(current_states)
+ .view(batch_size, -1, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ )
+ query_layer = (
+ self.query(hidden_states)
+ .view(batch_size, -1, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ )
+
+ # Take the dot product between "query" and "key" to get the raw attention scores.
+ attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+
+ attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+ if attention_mask is not None:
+ # Apply the attention mask is (precomputed for all layers in SuperGlueModel forward() function)
+ attention_scores = attention_scores + attention_mask
+
+ # Normalize the attention scores to probabilities.
+ attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+ # This is actually dropping out entire tokens to attend to, which might
+ # seem a bit unusual, but is taken from the original Transformer paper.
+ attention_probs = self.dropout(attention_probs)
+
+ context_layer = torch.matmul(attention_probs, value_layer)
+
+ context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+ new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+ context_layer = context_layer.view(new_context_layer_shape)
+
+ outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+ if self.is_decoder:
+ outputs = outputs + (None,)
+ return outputs
+
+
+class SuperGlueSelfOutput(nn.Module):
+ def __init__(self, config: SuperGlueConfig):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+
+ def forward(self, hidden_states: torch.Tensor, *args) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ return hidden_states
+
+
+SUPERGLUE_SELF_ATTENTION_CLASSES = {
+ "eager": SuperGlueSelfAttention,
+}
+
+
+class SuperGlueAttention(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.self = SUPERGLUE_SELF_ATTENTION_CLASSES[config._attn_implementation](config)
+ self.output = SuperGlueSelfOutput(config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor]:
+ self_outputs = self.self(
+ hidden_states,
+ attention_mask=attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ output_attentions=output_attentions,
+ )
+ attention_output = self.output(self_outputs[0], hidden_states)
+ outputs = (attention_output,) + self_outputs[1:] # add attentions if we output them
+ return outputs
+
+
+class SuperGlueAttentionalPropagation(nn.Module):
+ def __init__(self, config: SuperGlueConfig) -> None:
+ super().__init__()
+ hidden_size = config.hidden_size
+ self.attention = SuperGlueAttention(config)
+ mlp_channels = [hidden_size * 2, hidden_size * 2, hidden_size]
+ layers = [
+ SuperGlueMultiLayerPerceptron(config, mlp_channels[i - 1], mlp_channels[i])
+ for i in range(1, len(mlp_channels) - 1)
+ ]
+ layers.append(nn.Linear(mlp_channels[-2], mlp_channels[-1]))
+ self.mlp = nn.ModuleList(layers)
+
+ def forward(
+ self,
+ descriptors: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ output_hidden_states: bool = False,
+ ) -> tuple[torch.Tensor, tuple[torch.Tensor] | None, tuple[torch.Tensor] | None]:
+ attention_outputs = self.attention(
+ descriptors,
+ attention_mask=attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ output_attentions=output_attentions,
+ )
+ output = attention_outputs[0]
+ attention = attention_outputs[1:]
+
+ hidden_state = torch.cat([descriptors, output], dim=2)
+
+ all_hidden_states = () if output_hidden_states else None
+ for layer in self.mlp:
+ hidden_state = layer(hidden_state)
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_state,)
+
+ return hidden_state, all_hidden_states, attention
+
+
+class SuperGlueAttentionalGNN(nn.Module):
+ def __init__(self, config: SuperGlueConfig) -> None:
+ super().__init__()
+ self.hidden_size = config.hidden_size
+ self.layers_types = config.gnn_layers_types
+ self.layers = nn.ModuleList([SuperGlueAttentionalPropagation(config) for _ in range(len(self.layers_types))])
+
+ def forward(
+ self,
+ descriptors: torch.Tensor,
+ mask: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ output_hidden_states: bool | None = False,
+ ) -> tuple[torch.Tensor, tuple | None, tuple | None]:
+ all_hidden_states = () if output_hidden_states else None
+ all_attentions = () if output_attentions else None
+
+ batch_size, num_keypoints, _ = descriptors.shape
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (descriptors,)
+
+ for gnn_layer, layer_type in zip(self.layers, self.layers_types):
+ encoder_hidden_states = None
+ encoder_attention_mask = None
+ if layer_type == "cross":
+ encoder_hidden_states = (
+ descriptors.reshape(-1, 2, num_keypoints, self.hidden_size)
+ .flip(1)
+ .reshape(batch_size, num_keypoints, self.hidden_size)
+ )
+ encoder_attention_mask = (
+ mask.reshape(-1, 2, 1, 1, num_keypoints).flip(1).reshape(batch_size, 1, 1, num_keypoints)
+ if mask is not None
+ else None
+ )
+
+ gnn_outputs = gnn_layer(
+ descriptors,
+ attention_mask=mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ output_hidden_states=output_hidden_states,
+ output_attentions=output_attentions,
+ )
+ delta = gnn_outputs[0]
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + gnn_outputs[1]
+ if output_attentions:
+ all_attentions = all_attentions + gnn_outputs[2]
+
+ descriptors = descriptors + delta
+ return descriptors, all_hidden_states, all_attentions
+
+
+class SuperGlueFinalProjection(nn.Module):
+ def __init__(self, config: SuperGlueConfig) -> None:
+ super().__init__()
+ hidden_size = config.hidden_size
+ self.final_proj = nn.Linear(hidden_size, hidden_size, bias=True)
+
+ def forward(self, descriptors: torch.Tensor) -> torch.Tensor:
+ return self.final_proj(descriptors)
+
+
+@auto_docstring
+class SuperGluePreTrainedModel(PreTrainedModel):
+ config: SuperGlueConfig
+ base_model_prefix = "superglue"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+
+ @torch.no_grad()
+ def _init_weights(self, module: nn.Module) -> None:
+ """Initialize the weights"""
+ super()._init_weights(module)
+ if hasattr(module, "bin_score"):
+ init.ones_(module.bin_score)
+
+
+@auto_docstring(
+ custom_intro="""
+ SuperGlue model taking images as inputs and outputting the matching of them.
+ """
+)
+class SuperGlueForKeypointMatching(SuperGluePreTrainedModel):
+ """SuperGlue feature matching middle-end
+
+ Given two sets of keypoints and locations, we determine the
+ correspondences by:
+ 1. Keypoint Encoding (normalization + visual feature and location fusion)
+ 2. Graph Neural Network with multiple self and cross-attention layers
+ 3. Final projection layer
+ 4. Optimal Transport Layer (a differentiable Hungarian matching algorithm)
+ 5. Thresholding matrix based on mutual exclusivity and a match_threshold
+
+ The correspondence ids use -1 to indicate non-matching points.
+
+ Paul-Edouard Sarlin, Daniel DeTone, Tomasz Malisiewicz, and Andrew
+ Rabinovich. SuperGlue: Learning Feature Matching with Graph Neural
+ Networks. In CVPR, 2020. https://huggingface.co/papers/1911.11763
+ """
+
+ def __init__(self, config: SuperGlueConfig) -> None:
+ super().__init__(config)
+
+ self.keypoint_detector = AutoModelForKeypointDetection.from_config(config.keypoint_detector_config)
+
+ self.keypoint_encoder = SuperGlueKeypointEncoder(config)
+ self.gnn = SuperGlueAttentionalGNN(config)
+ self.final_projection = SuperGlueFinalProjection(config)
+
+ bin_score = torch.nn.Parameter(torch.tensor(1.0))
+ self.register_parameter("bin_score", bin_score)
+
+ self.post_init()
+
+ def _match_image_pair(
+ self,
+ keypoints: torch.Tensor,
+ descriptors: torch.Tensor,
+ scores: torch.Tensor,
+ height: int,
+ width: int,
+ mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ ) -> tuple[torch.Tensor, torch.Tensor, tuple, tuple]:
+ """
+ Perform keypoint matching between two images.
+
+ Args:
+ keypoints (`torch.Tensor` of shape `(batch_size, 2, num_keypoints, 2)`):
+ Keypoints detected in the pair of image.
+ descriptors (`torch.Tensor` of shape `(batch_size, 2, descriptor_dim, num_keypoints)`):
+ Descriptors of the keypoints detected in the image pair.
+ scores (`torch.Tensor` of shape `(batch_size, 2, num_keypoints)`):
+ Confidence scores of the keypoints detected in the image pair.
+ height (`int`): Image height.
+ width (`int`): Image width.
+ mask (`torch.Tensor` of shape `(batch_size, 2, num_keypoints)`, *optional*):
+ Mask indicating which values in the keypoints, matches and matching_scores tensors are keypoint matching
+ information.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors. Default to `config.output_attentions`.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. Default to `config.output_hidden_states`.
+
+ Returns:
+ matches (`torch.Tensor` of shape `(batch_size, 2, num_keypoints)`):
+ For each image pair, for each keypoint in image0, the index of the keypoint in image1 that was matched
+ with. And for each keypoint in image1, the index of the keypoint in image0 that was matched with.
+ matching_scores (`torch.Tensor` of shape `(batch_size, 2, num_keypoints)`):
+ Scores of predicted matches for each image pair
+ all_hidden_states (`tuple(torch.FloatTensor)`, *optional*):
+ Tuple of `torch.FloatTensor` (one for the output of each stage) of shape `(1, 2, num_keypoints,
+ num_channels)`.
+ all_attentions (`tuple(torch.FloatTensor)`, *optional*):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(1, 2, num_heads, num_keypoints,
+ num_keypoints)`.
+ """
+ all_hidden_states = () if output_hidden_states else None
+ all_attentions = () if output_attentions else None
+
+ if keypoints.shape[2] == 0: # no keypoints
+ shape = keypoints.shape[:-1]
+ return (
+ keypoints.new_full(shape, -1, dtype=torch.int),
+ keypoints.new_zeros(shape),
+ all_hidden_states,
+ all_attentions,
+ )
+
+ batch_size, _, num_keypoints, _ = keypoints.shape
+ # (batch_size, 2, num_keypoints, 2) -> (batch_size * 2, num_keypoints, 2)
+ keypoints = keypoints.reshape(batch_size * 2, num_keypoints, 2)
+ descriptors = descriptors.reshape(batch_size * 2, num_keypoints, self.config.hidden_size)
+ scores = scores.reshape(batch_size * 2, num_keypoints)
+ mask = mask.reshape(batch_size * 2, num_keypoints) if mask is not None else None
+
+ # Keypoint normalization
+ keypoints = normalize_keypoints(keypoints, height, width)
+
+ encoded_keypoints = self.keypoint_encoder(keypoints, scores, output_hidden_states=output_hidden_states)
+
+ last_hidden_state = encoded_keypoints[0]
+
+ # Keypoint MLP encoder.
+ descriptors = descriptors + last_hidden_state
+
+ extended_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=descriptors[:, 0:1, :], # force q_len == 1
+ attention_mask=mask,
+ )
+
+ # Multi-layer Transformer network.
+ gnn_outputs = self.gnn(
+ descriptors,
+ mask=extended_attention_mask,
+ output_hidden_states=output_hidden_states,
+ output_attentions=output_attentions,
+ )
+ descriptors = gnn_outputs[0]
+
+ # Final MLP projection.
+ projected_descriptors = self.final_projection(descriptors)
+
+ # (batch_size * 2, num_keypoints, descriptor_dim) -> (batch_size, 2, num_keypoints, descriptor_dim)
+ final_descriptors = projected_descriptors.reshape(batch_size, 2, num_keypoints, self.config.hidden_size)
+ final_descriptors0 = final_descriptors[:, 0]
+ final_descriptors1 = final_descriptors[:, 1]
+
+ # Compute matching descriptor distance.
+ scores = final_descriptors0 @ final_descriptors1.transpose(1, 2)
+ scores = scores / self.config.hidden_size**0.5
+
+ if mask is not None:
+ mask = mask.reshape(batch_size, 2, num_keypoints)
+ mask0 = mask[:, 0].unsqueeze(2)
+ mask1 = mask[:, 1].unsqueeze(1)
+ mask = torch.logical_and(mask0, mask1)
+ scores = scores.masked_fill(mask == 0, torch.finfo(scores.dtype).min)
+
+ # Run the optimal transport.
+ scores = log_optimal_transport(scores, self.bin_score, iterations=self.config.sinkhorn_iterations)
+
+ # Get the matches with score above "match_threshold".
+ max0 = scores[:, :-1, :-1].max(2)
+ max1 = scores[:, :-1, :-1].max(1)
+ indices0 = max0.indices
+ indices1 = max1.indices
+ mutual0 = arange_like(indices0, 1)[None] == indices1.gather(1, indices0)
+ mutual1 = arange_like(indices1, 1)[None] == indices0.gather(1, indices1)
+ zero = scores.new_tensor(0)
+ matching_scores0 = torch.where(mutual0, max0.values.exp(), zero)
+ matching_scores0 = torch.where(matching_scores0 > self.config.matching_threshold, matching_scores0, zero)
+ matching_scores1 = torch.where(mutual1, matching_scores0.gather(1, indices1), zero)
+ valid0 = mutual0 & (matching_scores0 > zero)
+ valid1 = mutual1 & valid0.gather(1, indices1)
+ matches0 = torch.where(valid0, indices0, indices0.new_tensor(-1))
+ matches1 = torch.where(valid1, indices1, indices1.new_tensor(-1))
+
+ matches = torch.cat([matches0, matches1], dim=1).reshape(batch_size, 2, -1)
+ matching_scores = torch.cat([matching_scores0, matching_scores1], dim=1).reshape(batch_size, 2, -1)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + encoded_keypoints[1]
+ all_hidden_states = all_hidden_states + gnn_outputs[1]
+ all_hidden_states = all_hidden_states + (projected_descriptors,)
+ all_hidden_states = tuple(
+ x.reshape(batch_size, 2, num_keypoints, -1).transpose(-1, -2) for x in all_hidden_states
+ )
+ if output_attentions:
+ all_attentions = all_attentions + gnn_outputs[2]
+ all_attentions = tuple(x.reshape(batch_size, 2, -1, num_keypoints, num_keypoints) for x in all_attentions)
+
+ return (
+ matches,
+ matching_scores,
+ all_hidden_states,
+ all_attentions,
+ )
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ labels: torch.LongTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | SuperGlueKeypointMatchingOutput:
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, AutoModel
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> url = "https://github.com/magicleap/SuperGluePretrainedNetwork/blob/master/assets/phototourism_sample_images/london_bridge_78916675_4568141288.jpg?raw=true"
+ >>> with httpx.stream("GET", url) as response:
+ ... image_1 = Image.open(BytesIO(response.read()))
+
+ >>> url = "https://github.com/magicleap/SuperGluePretrainedNetwork/blob/master/assets/phototourism_sample_images/london_bridge_19481797_2295892421.jpg?raw=true"
+ >>> with httpx.stream("GET", url) as response:
+ ... image_2 = Image.open(BytesIO(response.read()))
+
+ >>> images = [image_1, image_2]
+
+ >>> processor = AutoImageProcessor.from_pretrained("magic-leap-community/superglue_outdoor")
+ >>> model = AutoModel.from_pretrained("magic-leap-community/superglue_outdoor")
+
+ >>> with torch.no_grad():
+ >>> inputs = processor(images, return_tensors="pt")
+ >>> outputs = model(**inputs)
+ ```"""
+ loss = None
+ if labels is not None:
+ raise ValueError("SuperGlue is not trainable, no labels should be provided.")
+
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if pixel_values.ndim != 5 or pixel_values.size(1) != 2:
+ raise ValueError("Input must be a 5D tensor of shape (batch_size, 2, num_channels, height, width)")
+
+ batch_size, _, channels, height, width = pixel_values.shape
+ pixel_values = pixel_values.reshape(batch_size * 2, channels, height, width)
+ keypoint_detections = self.keypoint_detector(pixel_values)
+
+ keypoints, scores, descriptors, mask = keypoint_detections[:4]
+ keypoints = keypoints.reshape(batch_size, 2, -1, 2).to(pixel_values)
+ scores = scores.reshape(batch_size, 2, -1).to(pixel_values)
+ descriptors = descriptors.reshape(batch_size, 2, -1, self.config.hidden_size).to(pixel_values)
+ mask = mask.reshape(batch_size, 2, -1)
+
+ absolute_keypoints = keypoints.clone()
+ absolute_keypoints[:, :, :, 0] = absolute_keypoints[:, :, :, 0] * width
+ absolute_keypoints[:, :, :, 1] = absolute_keypoints[:, :, :, 1] * height
+
+ matches, matching_scores, hidden_states, attentions = self._match_image_pair(
+ absolute_keypoints,
+ descriptors,
+ scores,
+ height,
+ width,
+ mask=mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ )
+
+ if not return_dict:
+ return tuple(
+ v
+ for v in [loss, matches, matching_scores, keypoints, mask, hidden_states, attentions]
+ if v is not None
+ )
+
+ return SuperGlueKeypointMatchingOutput(
+ loss=loss,
+ matches=matches,
+ matching_scores=matching_scores,
+ keypoints=keypoints,
+ mask=mask,
+ hidden_states=hidden_states,
+ attentions=attentions,
+ )
+
+
+__all__ = ["SuperGluePreTrainedModel", "SuperGlueForKeypointMatching"]
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/__init__.py b/lib/python3.11/site-packages/transformers/models/superpoint/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf1b097542ee7509bf4e89e922b6df6ddd475034
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/superpoint/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2024 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_superpoint import *
+ from .image_processing_pil_superpoint import *
+ from .image_processing_superpoint import *
+ from .modeling_superpoint import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a944ba65ef08ace5a825d1ae85cd5db83f1d892
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/configuration_superpoint.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/configuration_superpoint.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d8eecf14896d2bcb0891637feaeb9503dc723ed4
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/configuration_superpoint.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/image_processing_pil_superpoint.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/image_processing_pil_superpoint.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..de08c7c8ce16f71bf3ff7b89728d2c6a0268874c
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/image_processing_pil_superpoint.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/image_processing_superpoint.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/image_processing_superpoint.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e408cc069a4efe41ec72ee4b704b1cc68382008c
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/image_processing_superpoint.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/modeling_superpoint.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/modeling_superpoint.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bdaab178bed4acb350ff93d84e2add0323ad0fbe
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/superpoint/__pycache__/modeling_superpoint.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/configuration_superpoint.py b/lib/python3.11/site-packages/transformers/models/superpoint/configuration_superpoint.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3f0dfeb4fe63f1252c67dd174855825f5cd7e92
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/superpoint/configuration_superpoint.py
@@ -0,0 +1,66 @@
+# Copyright 2024 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="magic-leap-community/superpoint")
+@strict
+class SuperPointConfig(PreTrainedConfig):
+ r"""
+ encoder_hidden_sizes (`List`, *optional*, defaults to `[64, 64, 128, 128]`):
+ The number of channels in each convolutional layer in the encoder.
+ keypoint_decoder_dim (`int`, *optional*, defaults to 65):
+ The output dimension of the keypoint decoder.
+ descriptor_decoder_dim (`int`, *optional*, defaults to 256):
+ The output dimension of the descriptor decoder.
+ keypoint_threshold (`float`, *optional*, defaults to 0.005):
+ The threshold to use for extracting keypoints.
+ max_keypoints (`int`, *optional*, defaults to -1):
+ The maximum number of keypoints to extract. If `-1`, will extract all keypoints.
+ nms_radius (`int`, *optional*, defaults to 4):
+ The radius for non-maximum suppression.
+ border_removal_distance (`int`, *optional*, defaults to 4):
+ The distance from the border to remove keypoints.
+
+ Example:
+ ```python
+ >>> from transformers import SuperPointConfig, SuperPointForKeypointDetection
+
+ >>> # Initializing a SuperPoint superpoint style configuration
+ >>> configuration = SuperPointConfig()
+ >>> # Initializing a model from the superpoint style configuration
+ >>> model = SuperPointForKeypointDetection(configuration)
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "superpoint"
+
+ encoder_hidden_sizes: list[int] | tuple[int, ...] = (64, 64, 128, 128)
+ decoder_hidden_size: int = 256
+ keypoint_decoder_dim: int = 65
+ descriptor_decoder_dim: int = 256
+ keypoint_threshold: float = 0.005
+ max_keypoints: int = -1
+ nms_radius: int = 4
+ border_removal_distance: int = 4
+ initializer_range: float = 0.02
+
+
+__all__ = ["SuperPointConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/image_processing_pil_superpoint.py b/lib/python3.11/site-packages/transformers/models/superpoint/image_processing_pil_superpoint.py
new file mode 100644
index 0000000000000000000000000000000000000000..e34d250c41b36f6aa1b2f11ea9aac3251e9c2c22
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/superpoint/image_processing_pil_superpoint.py
@@ -0,0 +1,166 @@
+# Copyright 2024 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.
+"""Image processor class for SuperPoint."""
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from ...image_processing_backends import PilBackend
+from ...image_processing_utils import BatchFeature
+from ...image_utils import PILImageResampling, SizeDict
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+from ...utils.import_utils import requires
+
+
+if TYPE_CHECKING:
+ import torch
+
+ from .modeling_superpoint import SuperPointKeypointDescriptionOutput
+
+
+def is_grayscale(image: np.ndarray) -> bool:
+ """Checks if an image is grayscale (all RGB channels are identical)."""
+ if image.shape[0] == 1:
+ return True
+ return np.all(image[0, ...] == image[1, ...]) and np.all(image[1, ...] == image[2, ...])
+
+
+def convert_to_grayscale(image: np.ndarray) -> np.ndarray:
+ """
+ Converts an image to grayscale format using the NTSC formula. Only support numpy arrays.
+
+ This function is supposed to return a 1-channel image, but it returns a 3-channel image with the same value in each
+ channel, because of an issue that is discussed in :
+ https://github.com/huggingface/transformers/pull/25786#issuecomment-1730176446
+
+ Args:
+ image (np.ndarray):
+ The image to convert.
+ """
+ if is_grayscale(image):
+ return image
+
+ gray_image = image[0, ...] * 0.2989 + image[1, ...] * 0.5870 + image[2, ...] * 0.1140
+ gray_image = np.stack([gray_image] * 3, axis=0)
+ return gray_image
+
+
+# Adapted from transformers.models.superpoint.image_processing_superpoint.SuperPointImageProcessorKwargs
+class SuperPointImageProcessorKwargs(ImagesKwargs, total=False):
+ r"""
+ do_grayscale (`bool`, *optional*, defaults to `self.do_grayscale`):
+ Whether to convert the image to grayscale. Can be overridden by `do_grayscale` in the `preprocess` method.
+ """
+
+ do_grayscale: bool
+
+
+@auto_docstring
+class SuperPointImageProcessorPil(PilBackend):
+ valid_kwargs = SuperPointImageProcessorKwargs
+ resample = PILImageResampling.BILINEAR
+ size = {"height": 480, "width": 640}
+ default_to_square = False
+ do_resize = True
+ do_rescale = True
+ rescale_factor = 1 / 255
+ do_normalize = None
+ do_grayscale = False
+
+ def __init__(self, **kwargs: Unpack[SuperPointImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ def _preprocess(
+ self,
+ images: list[np.ndarray],
+ do_resize: bool,
+ size: SizeDict,
+ resample: PILImageResampling | None,
+ do_rescale: bool,
+ rescale_factor: float,
+ return_tensors: str | TensorType | None,
+ do_grayscale: bool = False,
+ **kwargs,
+ ) -> BatchFeature:
+ processed_images = []
+ for image in images:
+ # Resize (must happen before grayscale for PIL backend to work correctly)
+ if do_resize:
+ image = self.resize(image, size, resample)
+ # Rescale
+ if do_rescale:
+ image = self.rescale(image, rescale_factor)
+ # Apply grayscale conversion after rescale (if requested)
+ if do_grayscale:
+ image = convert_to_grayscale(image)
+ processed_images.append(image)
+
+ return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+ @requires(backends=("torch",))
+ def post_process_keypoint_detection(
+ self, outputs: "SuperPointKeypointDescriptionOutput", target_sizes: TensorType | list[tuple]
+ ) -> list[dict[str, "torch.Tensor"]]:
+ """
+ Converts the raw output of [`SuperPointForKeypointDetection`] into lists of keypoints, scores and descriptors
+ with coordinates absolute to the original image sizes.
+
+ Args:
+ outputs ([`SuperPointKeypointDescriptionOutput`]):
+ Raw outputs of the model containing keypoints in a relative (x, y) format, with scores and descriptors.
+ target_sizes (`torch.Tensor` or `list[tuple[int, int]]`):
+ Tensor of shape `(batch_size, 2)` or list of tuples (`tuple[int, int]`) containing the target size
+ `(height, width)` of each image in the batch. This must be the original
+ image size (before any processing).
+ Returns:
+ `list[Dict]`: A list of dictionaries, each dictionary containing the keypoints in absolute format according
+ to target_sizes, scores and descriptors for an image in the batch as predicted by the model.
+ """
+ import torch
+
+ if len(outputs.mask) != len(target_sizes):
+ raise ValueError("Make sure that you pass in as many target sizes as the batch dimension of the mask")
+
+ if isinstance(target_sizes, list):
+ image_sizes = torch.tensor(target_sizes, device=outputs.mask.device)
+ else:
+ if target_sizes.shape[1] != 2:
+ raise ValueError(
+ "Each element of target_sizes must contain the size (h, w) of each image of the batch"
+ )
+ image_sizes = target_sizes
+
+ # Flip the image sizes to (width, height) and convert keypoints to absolute coordinates
+ image_sizes = torch.flip(image_sizes, [1])
+ masked_keypoints = outputs.keypoints * image_sizes[:, None]
+
+ # Convert masked_keypoints to int
+ masked_keypoints = masked_keypoints.to(torch.int32)
+
+ results = []
+ for image_mask, keypoints, scores, descriptors in zip(
+ outputs.mask, masked_keypoints, outputs.scores, outputs.descriptors
+ ):
+ indices = torch.nonzero(image_mask).squeeze(1)
+ keypoints = keypoints[indices]
+ scores = scores[indices]
+ descriptors = descriptors[indices]
+ results.append({"keypoints": keypoints, "scores": scores, "descriptors": descriptors})
+
+ return results
+
+
+__all__ = ["SuperPointImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/image_processing_superpoint.py b/lib/python3.11/site-packages/transformers/models/superpoint/image_processing_superpoint.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0e9660b521653eade29bbea01b6f8189b22df38
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/superpoint/image_processing_superpoint.py
@@ -0,0 +1,164 @@
+# Copyright 2024 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.
+"""Image processor class for SuperPoint."""
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import PILImageResampling, SizeDict
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+if TYPE_CHECKING:
+ from .modeling_superpoint import SuperPointKeypointDescriptionOutput
+
+from torchvision.transforms.v2 import functional as tvF
+
+
+class SuperPointImageProcessorKwargs(ImagesKwargs, total=False):
+ r"""
+ do_grayscale (`bool`, *optional*, defaults to `self.do_grayscale`):
+ Whether to convert the image to grayscale. Can be overridden by `do_grayscale` in the `preprocess` method.
+ """
+
+ do_grayscale: bool
+
+
+def is_grayscale(image: "torch.Tensor") -> bool:
+ """Checks if an image is grayscale (all RGB channels are identical)."""
+ if image.ndim < 3 or image.shape[0 if image.ndim == 3 else 1] == 1:
+ return True
+ return torch.all(image[..., 0, :, :] == image[..., 1, :, :]) and torch.all(
+ image[..., 1, :, :] == image[..., 2, :, :]
+ )
+
+
+def convert_to_grayscale(image: "torch.Tensor") -> "torch.Tensor":
+ """
+ Converts an image to grayscale format using the NTSC formula. Only support torch.Tensor.
+
+ This function is supposed to return a 1-channel image, but it returns a 3-channel image with the same value in each
+ channel, because of an issue that is discussed in :
+ https://github.com/huggingface/transformers/pull/25786#issuecomment-1730176446
+
+ Args:
+ image (torch.Tensor):
+ The image to convert.
+ """
+ if is_grayscale(image):
+ return image
+ return tvF.rgb_to_grayscale(image, num_output_channels=3)
+
+
+@auto_docstring
+class SuperPointImageProcessor(TorchvisionBackend):
+ valid_kwargs = SuperPointImageProcessorKwargs
+ resample = PILImageResampling.BILINEAR
+ size = {"height": 480, "width": 640}
+ default_to_square = False
+ do_resize = True
+ do_rescale = True
+ rescale_factor = 1 / 255
+ do_normalize = None
+ do_grayscale = False
+
+ def __init__(self, **kwargs: Unpack[SuperPointImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ do_grayscale: bool = False,
+ **kwargs,
+ ) -> BatchFeature:
+ # Group images by size for batched processing
+ grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+ processed_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ # Apply grayscale conversion before resize (if requested)
+ if do_grayscale:
+ stacked_images = convert_to_grayscale(stacked_images)
+ # Resize
+ if do_resize:
+ stacked_images = self.resize(stacked_images, size=size, resample=resample)
+ # Rescale
+ if do_rescale:
+ stacked_images = self.rescale(stacked_images, rescale_factor)
+ processed_images_grouped[shape] = stacked_images
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index)
+ return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+ def post_process_keypoint_detection(
+ self, outputs: "SuperPointKeypointDescriptionOutput", target_sizes: TensorType | list[tuple]
+ ) -> list[dict[str, "torch.Tensor"]]:
+ """
+ Converts the raw output of [`SuperPointForKeypointDetection`] into lists of keypoints, scores and descriptors
+ with coordinates absolute to the original image sizes.
+
+ Args:
+ outputs ([`SuperPointKeypointDescriptionOutput`]):
+ Raw outputs of the model containing keypoints in a relative (x, y) format, with scores and descriptors.
+ target_sizes (`torch.Tensor` or `list[tuple[int, int]]`):
+ Tensor of shape `(batch_size, 2)` or list of tuples (`tuple[int, int]`) containing the target size
+ `(height, width)` of each image in the batch. This must be the original
+ image size (before any processing).
+ Returns:
+ `list[Dict]`: A list of dictionaries, each dictionary containing the keypoints in absolute format according
+ to target_sizes, scores and descriptors for an image in the batch as predicted by the model.
+ """
+ if len(outputs.mask) != len(target_sizes):
+ raise ValueError("Make sure that you pass in as many target sizes as the batch dimension of the mask")
+
+ if isinstance(target_sizes, list):
+ image_sizes = torch.tensor(target_sizes, device=outputs.mask.device)
+ else:
+ if target_sizes.shape[1] != 2:
+ raise ValueError(
+ "Each element of target_sizes must contain the size (h, w) of each image of the batch"
+ )
+ image_sizes = target_sizes
+
+ # Flip the image sizes to (width, height) and convert keypoints to absolute coordinates
+ image_sizes = torch.flip(image_sizes, [1])
+ masked_keypoints = outputs.keypoints * image_sizes[:, None]
+
+ # Convert masked_keypoints to int
+ masked_keypoints = masked_keypoints.to(torch.int32)
+
+ results = []
+ for image_mask, keypoints, scores, descriptors in zip(
+ outputs.mask, masked_keypoints, outputs.scores, outputs.descriptors
+ ):
+ indices = torch.nonzero(image_mask).squeeze(1)
+ keypoints = keypoints[indices]
+ scores = scores[indices]
+ descriptors = descriptors[indices]
+ results.append({"keypoints": keypoints, "scores": scores, "descriptors": descriptors})
+
+ return results
+
+
+__all__ = ["SuperPointImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/superpoint/modeling_superpoint.py b/lib/python3.11/site-packages/transformers/models/superpoint/modeling_superpoint.py
new file mode 100644
index 0000000000000000000000000000000000000000..cef96725d4d27a90064203a3b473c53d8fe10caa
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/superpoint/modeling_superpoint.py
@@ -0,0 +1,468 @@
+# Copyright 2024 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.
+"""PyTorch SuperPoint model."""
+
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import (
+ BaseModelOutputWithNoAttention,
+)
+from transformers.models.superpoint.configuration_superpoint import SuperPointConfig
+
+from ...utils import (
+ ModelOutput,
+ auto_docstring,
+ logging,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+def remove_keypoints_from_borders(
+ keypoints: torch.Tensor, scores: torch.Tensor, border: int, height: int, width: int
+) -> tuple[torch.Tensor, torch.Tensor]:
+ """Removes keypoints (and their associated scores) that are too close to the border"""
+ mask_h = (keypoints[:, 0] >= border) & (keypoints[:, 0] < (height - border))
+ mask_w = (keypoints[:, 1] >= border) & (keypoints[:, 1] < (width - border))
+ mask = mask_h & mask_w
+ return keypoints[mask], scores[mask]
+
+
+def top_k_keypoints(keypoints: torch.Tensor, scores: torch.Tensor, k: int) -> tuple[torch.Tensor, torch.Tensor]:
+ """Keeps the k keypoints with highest score"""
+ if k >= len(keypoints):
+ return keypoints, scores
+ scores, indices = torch.topk(scores, k, dim=0)
+ return keypoints[indices], scores
+
+
+def simple_nms(scores: torch.Tensor, nms_radius: int) -> torch.Tensor:
+ """Applies non-maximum suppression on scores"""
+ if nms_radius < 0:
+ raise ValueError("Expected positive values for nms_radius")
+
+ def max_pool(x):
+ return nn.functional.max_pool2d(x, kernel_size=nms_radius * 2 + 1, stride=1, padding=nms_radius)
+
+ zeros = torch.zeros_like(scores)
+ max_mask = scores == max_pool(scores)
+ for _ in range(2):
+ supp_mask = max_pool(max_mask.float()) > 0
+ supp_scores = torch.where(supp_mask, zeros, scores)
+ new_max_mask = supp_scores == max_pool(supp_scores)
+ max_mask = max_mask | (new_max_mask & (~supp_mask))
+ return torch.where(max_mask, scores, zeros)
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for outputs of image point description models. Due to the nature of keypoint detection, the number of
+ keypoints is not fixed and can vary from image to image, which makes batching non-trivial. In the batch of images,
+ the maximum number of keypoints is set as the dimension of the keypoints, scores and descriptors tensors. The mask
+ tensor is used to indicate which values in the keypoints, scores and descriptors tensors are keypoint information
+ and which are padding.
+ """
+)
+@dataclass
+class SuperPointKeypointDescriptionOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*):
+ Loss computed during training.
+ keypoints (`torch.FloatTensor` of shape `(batch_size, num_keypoints, 2)`):
+ Relative (x, y) coordinates of predicted keypoints in a given image.
+ scores (`torch.FloatTensor` of shape `(batch_size, num_keypoints)`):
+ Scores of predicted keypoints.
+ descriptors (`torch.FloatTensor` of shape `(batch_size, num_keypoints, descriptor_size)`):
+ Descriptors of predicted keypoints.
+ mask (`torch.BoolTensor` of shape `(batch_size, num_keypoints)`):
+ Mask indicating which values in keypoints, scores and descriptors are keypoint information.
+ hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or
+ when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
+ one for the output of each stage) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states
+ (also called feature maps) of the model at the output of each stage.
+ """
+
+ loss: torch.FloatTensor | None = None
+ keypoints: torch.IntTensor | None = None
+ scores: torch.FloatTensor | None = None
+ descriptors: torch.FloatTensor | None = None
+ mask: torch.BoolTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+
+
+class SuperPointConvBlock(nn.Module):
+ def __init__(
+ self, config: SuperPointConfig, in_channels: int, out_channels: int, add_pooling: bool = False
+ ) -> None:
+ super().__init__()
+ self.conv_a = nn.Conv2d(
+ in_channels,
+ out_channels,
+ kernel_size=3,
+ stride=1,
+ padding=1,
+ )
+ self.conv_b = nn.Conv2d(
+ out_channels,
+ out_channels,
+ kernel_size=3,
+ stride=1,
+ padding=1,
+ )
+ self.relu = nn.ReLU(inplace=True)
+ self.pool = nn.MaxPool2d(kernel_size=2, stride=2) if add_pooling else None
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.relu(self.conv_a(hidden_states))
+ hidden_states = self.relu(self.conv_b(hidden_states))
+ if self.pool is not None:
+ hidden_states = self.pool(hidden_states)
+ return hidden_states
+
+
+class SuperPointEncoder(nn.Module):
+ """
+ SuperPoint encoder module. It is made of 4 convolutional layers with ReLU activation and max pooling, reducing the
+ dimensionality of the image.
+ """
+
+ def __init__(self, config: SuperPointConfig) -> None:
+ super().__init__()
+ # SuperPoint uses 1 channel images
+ self.input_dim = 1
+
+ conv_blocks = []
+ conv_blocks.append(
+ SuperPointConvBlock(config, self.input_dim, config.encoder_hidden_sizes[0], add_pooling=True)
+ )
+ for i in range(1, len(config.encoder_hidden_sizes) - 1):
+ conv_blocks.append(
+ SuperPointConvBlock(
+ config, config.encoder_hidden_sizes[i - 1], config.encoder_hidden_sizes[i], add_pooling=True
+ )
+ )
+ conv_blocks.append(
+ SuperPointConvBlock(
+ config, config.encoder_hidden_sizes[-2], config.encoder_hidden_sizes[-1], add_pooling=False
+ )
+ )
+ self.conv_blocks = nn.ModuleList(conv_blocks)
+
+ def forward(
+ self,
+ input,
+ output_hidden_states: bool | None = False,
+ return_dict: bool | None = True,
+ ) -> tuple | BaseModelOutputWithNoAttention:
+ all_hidden_states = () if output_hidden_states else None
+
+ for conv_block in self.conv_blocks:
+ input = conv_block(input)
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (input,)
+ output = input
+ if not return_dict:
+ return tuple(v for v in [output, all_hidden_states] if v is not None)
+
+ return BaseModelOutputWithNoAttention(
+ last_hidden_state=output,
+ hidden_states=all_hidden_states,
+ )
+
+
+class SuperPointInterestPointDecoder(nn.Module):
+ """
+ The SuperPointInterestPointDecoder uses the output of the SuperPointEncoder to compute the keypoint with scores.
+ The scores are first computed by a convolutional layer, then a softmax is applied to get a probability distribution
+ over the 65 possible keypoint classes. The keypoints are then extracted from the scores by thresholding and
+ non-maximum suppression. Post-processing is then applied to remove keypoints too close to the image borders as well
+ as to keep only the k keypoints with highest score.
+ """
+
+ def __init__(self, config: SuperPointConfig) -> None:
+ super().__init__()
+ self.keypoint_threshold = config.keypoint_threshold
+ self.max_keypoints = config.max_keypoints
+ self.nms_radius = config.nms_radius
+ self.border_removal_distance = config.border_removal_distance
+
+ self.relu = nn.ReLU(inplace=True)
+ self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
+ self.conv_score_a = nn.Conv2d(
+ config.encoder_hidden_sizes[-1],
+ config.decoder_hidden_size,
+ kernel_size=3,
+ stride=1,
+ padding=1,
+ )
+ self.conv_score_b = nn.Conv2d(
+ config.decoder_hidden_size, config.keypoint_decoder_dim, kernel_size=1, stride=1, padding=0
+ )
+
+ def forward(self, encoded: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+ scores = self._get_pixel_scores(encoded)
+ keypoints, scores = self._extract_keypoints(scores)
+
+ return keypoints, scores
+
+ def _get_pixel_scores(self, encoded: torch.Tensor) -> torch.Tensor:
+ """Based on the encoder output, compute the scores for each pixel of the image"""
+ scores = self.relu(self.conv_score_a(encoded))
+ scores = self.conv_score_b(scores)
+ scores = nn.functional.softmax(scores, 1)[:, :-1]
+ batch_size, _, height, width = scores.shape
+ scores = scores.permute(0, 2, 3, 1).reshape(batch_size, height, width, 8, 8)
+ scores = scores.permute(0, 1, 3, 2, 4).reshape(batch_size, height * 8, width * 8)
+ scores = simple_nms(scores, self.nms_radius)
+ return scores
+
+ def _extract_keypoints(self, scores: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+ """
+ Based on their scores, extract the pixels that represent the keypoints that will be used for descriptors computation.
+ The keypoints are in the form of relative (x, y) coordinates.
+ """
+ _, height, width = scores.shape
+
+ # Threshold keypoints by score value
+ keypoints = torch.nonzero(scores[0] > self.keypoint_threshold)
+ scores = scores[0][tuple(keypoints.t())]
+
+ # Discard keypoints near the image borders
+ keypoints, scores = remove_keypoints_from_borders(
+ keypoints, scores, self.border_removal_distance, height * 8, width * 8
+ )
+
+ # Keep the k keypoints with highest score
+ if self.max_keypoints >= 0:
+ keypoints, scores = top_k_keypoints(keypoints, scores, self.max_keypoints)
+
+ # Convert (y, x) to (x, y)
+ keypoints = torch.flip(keypoints, [1]).to(scores.dtype)
+
+ return keypoints, scores
+
+
+class SuperPointDescriptorDecoder(nn.Module):
+ """
+ The SuperPointDescriptorDecoder uses the outputs of both the SuperPointEncoder and the
+ SuperPointInterestPointDecoder to compute the descriptors at the keypoints locations.
+
+ The descriptors are first computed by a convolutional layer, then normalized to have a norm of 1. The descriptors
+ are then interpolated at the keypoints locations.
+ """
+
+ def __init__(self, config: SuperPointConfig) -> None:
+ super().__init__()
+
+ self.relu = nn.ReLU(inplace=True)
+ self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
+ self.conv_descriptor_a = nn.Conv2d(
+ config.encoder_hidden_sizes[-1],
+ config.decoder_hidden_size,
+ kernel_size=3,
+ stride=1,
+ padding=1,
+ )
+ self.conv_descriptor_b = nn.Conv2d(
+ config.decoder_hidden_size,
+ config.descriptor_decoder_dim,
+ kernel_size=1,
+ stride=1,
+ padding=0,
+ )
+
+ def forward(self, encoded: torch.Tensor, keypoints: torch.Tensor) -> torch.Tensor:
+ """Based on the encoder output and the keypoints, compute the descriptors for each keypoint"""
+ descriptors = self.conv_descriptor_b(self.relu(self.conv_descriptor_a(encoded)))
+ descriptors = nn.functional.normalize(descriptors, p=2, dim=1)
+
+ descriptors = self._sample_descriptors(keypoints[None], descriptors[0][None], 8)[0]
+
+ # [descriptor_dim, num_keypoints] -> [num_keypoints, descriptor_dim]
+ descriptors = torch.transpose(descriptors, 0, 1)
+
+ return descriptors
+
+ @staticmethod
+ def _sample_descriptors(keypoints, descriptors, scale: int = 8) -> torch.Tensor:
+ """Interpolate descriptors at keypoint locations"""
+ batch_size, num_channels, height, width = descriptors.shape
+ keypoints = keypoints - scale / 2 + 0.5
+ divisor = torch.tensor([[(width * scale - scale / 2 - 0.5), (height * scale - scale / 2 - 0.5)]])
+ divisor = divisor.to(keypoints)
+ keypoints /= divisor
+ keypoints = keypoints * 2 - 1 # normalize to (-1, 1)
+ kwargs = {"align_corners": True}
+ # [batch_size, num_channels, num_keypoints, 2] -> [batch_size, num_channels, num_keypoints, 2]
+ keypoints = keypoints.view(batch_size, 1, -1, 2)
+ descriptors = nn.functional.grid_sample(descriptors, keypoints, mode="bilinear", **kwargs)
+ # [batch_size, descriptor_decoder_dim, num_channels, num_keypoints] -> [batch_size, descriptor_decoder_dim, num_keypoints]
+ descriptors = descriptors.reshape(batch_size, num_channels, -1)
+ descriptors = nn.functional.normalize(descriptors, p=2, dim=1)
+ return descriptors
+
+
+@auto_docstring
+class SuperPointPreTrainedModel(PreTrainedModel):
+ config: SuperPointConfig
+ base_model_prefix = "superpoint"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = False
+
+ def extract_one_channel_pixel_values(self, pixel_values: torch.FloatTensor) -> torch.FloatTensor:
+ """
+ Assuming pixel_values has shape (batch_size, 3, height, width), and that all channels values are the same,
+ extract the first channel value to get a tensor of shape (batch_size, 1, height, width) for SuperPoint. This is
+ a workaround for the issue discussed in :
+ https://github.com/huggingface/transformers/pull/25786#issuecomment-1730176446
+
+ Args:
+ pixel_values: torch.FloatTensor of shape (batch_size, 3, height, width)
+
+ Returns:
+ pixel_values: torch.FloatTensor of shape (batch_size, 1, height, width)
+
+ """
+ return pixel_values[:, 0, :, :][:, None, :, :]
+
+
+@auto_docstring(
+ custom_intro="""
+ SuperPoint model outputting keypoints and descriptors.
+ """
+)
+class SuperPointForKeypointDetection(SuperPointPreTrainedModel):
+ """
+ SuperPoint model. It consists of a SuperPointEncoder, a SuperPointInterestPointDecoder and a
+ SuperPointDescriptorDecoder. SuperPoint was proposed in `SuperPoint: Self-Supervised Interest Point Detection and
+ Description <https://huggingface.co/papers/1712.07629>`__ by Daniel DeTone, Tomasz Malisiewicz, and Andrew Rabinovich. It
+ is a fully convolutional neural network that extracts keypoints and descriptors from an image. It is trained in a
+ self-supervised manner, using a combination of a photometric loss and a loss based on the homographic adaptation of
+ keypoints. It is made of a convolutional encoder and two decoders: one for keypoints and one for descriptors.
+ """
+
+ def __init__(self, config: SuperPointConfig) -> None:
+ super().__init__(config)
+
+ self.config = config
+
+ self.encoder = SuperPointEncoder(config)
+ self.keypoint_decoder = SuperPointInterestPointDecoder(config)
+ self.descriptor_decoder = SuperPointDescriptorDecoder(config)
+
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ labels: torch.LongTensor | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | SuperPointKeypointDescriptionOutput:
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, SuperPointForKeypointDetection
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> processor = AutoImageProcessor.from_pretrained("magic-leap-community/superpoint")
+ >>> model = SuperPointForKeypointDetection.from_pretrained("magic-leap-community/superpoint")
+
+ >>> inputs = processor(image, return_tensors="pt")
+ >>> outputs = model(**inputs)
+ ```"""
+ loss = None
+ if labels is not None:
+ raise ValueError("SuperPoint does not support training for now.")
+
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ pixel_values = self.extract_one_channel_pixel_values(pixel_values)
+
+ batch_size, _, height, width = pixel_values.shape
+
+ encoder_outputs = self.encoder(
+ pixel_values,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ last_hidden_state = encoder_outputs[0]
+
+ list_keypoints_scores = [
+ self.keypoint_decoder(last_hidden_state[None, ...]) for last_hidden_state in last_hidden_state
+ ]
+
+ list_keypoints = [keypoints_scores[0] for keypoints_scores in list_keypoints_scores]
+ list_scores = [keypoints_scores[1] for keypoints_scores in list_keypoints_scores]
+
+ list_descriptors = [
+ self.descriptor_decoder(last_hidden_state[None, ...], keypoints[None, ...])
+ for last_hidden_state, keypoints in zip(last_hidden_state, list_keypoints)
+ ]
+
+ maximum_num_keypoints = max(keypoints.shape[0] for keypoints in list_keypoints)
+
+ keypoints = torch.zeros((batch_size, maximum_num_keypoints, 2), device=pixel_values.device)
+ scores = torch.zeros((batch_size, maximum_num_keypoints), device=pixel_values.device)
+ descriptors = torch.zeros(
+ (batch_size, maximum_num_keypoints, self.config.descriptor_decoder_dim),
+ device=pixel_values.device,
+ )
+ mask = torch.zeros((batch_size, maximum_num_keypoints), device=pixel_values.device, dtype=torch.int)
+
+ for i, (_keypoints, _scores, _descriptors) in enumerate(zip(list_keypoints, list_scores, list_descriptors)):
+ keypoints[i, : _keypoints.shape[0]] = _keypoints
+ scores[i, : _scores.shape[0]] = _scores
+ descriptors[i, : _descriptors.shape[0]] = _descriptors
+ mask[i, : _scores.shape[0]] = 1
+
+ # Convert to relative coordinates
+ keypoints = keypoints / torch.tensor([width, height], device=keypoints.device)
+
+ hidden_states = encoder_outputs[1] if output_hidden_states else None
+ if not return_dict:
+ return tuple(v for v in [loss, keypoints, scores, descriptors, mask, hidden_states] if v is not None)
+
+ return SuperPointKeypointDescriptionOutput(
+ loss=loss,
+ keypoints=keypoints,
+ scores=scores,
+ descriptors=descriptors,
+ mask=mask,
+ hidden_states=hidden_states,
+ )
+
+
+__all__ = ["SuperPointForKeypointDetection", "SuperPointPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/swiftformer/__init__.py b/lib/python3.11/site-packages/transformers/models/swiftformer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b239996fb976c5135453f784d7483eb81eee2d3d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swiftformer/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_swiftformer import *
+ from .modeling_swiftformer import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/swiftformer/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swiftformer/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e4ba0b62d65ec8eb76448bcf419073c4dc15237
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swiftformer/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swiftformer/__pycache__/configuration_swiftformer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swiftformer/__pycache__/configuration_swiftformer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2e54cc9604fb543dec652ac9f3fa0b7501b4f42
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swiftformer/__pycache__/configuration_swiftformer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swiftformer/__pycache__/modeling_swiftformer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swiftformer/__pycache__/modeling_swiftformer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..707056541a9394386c48ed9795b41ad529c741a6
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swiftformer/__pycache__/modeling_swiftformer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swiftformer/configuration_swiftformer.py b/lib/python3.11/site-packages/transformers/models/swiftformer/configuration_swiftformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8940c68dd96c9da87ef4f7ad33a922a11630118
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swiftformer/configuration_swiftformer.py
@@ -0,0 +1,78 @@
+# Copyright 2023 MBZUAI and The HuggingFace Inc. 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.
+"""SwiftFormer model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="MBZUAI/swiftformer-xs")
+@strict
+class SwiftFormerConfig(PreTrainedConfig):
+ r"""
+ embed_dims (`list[int]`, *optional*, defaults to `[48, 56, 112, 220]`):
+ The embedding dimension at each stage
+ downsamples (`list[bool]`, *optional*, defaults to `[True, True, True, True]`):
+ Whether or not to downsample inputs between two stages.
+ down_patch_size (`int`, *optional*, defaults to 3):
+ The size of patches in downsampling layers.
+ down_stride (`int`, *optional*, defaults to 2):
+ The stride of convolution kernels in downsampling layers.
+ down_pad (`int`, *optional*, defaults to 1):
+ Padding in downsampling layers.
+ drop_mlp_rate (`float`, *optional*, defaults to 0.0):
+ Dropout rate for the MLP component of SwiftFormer.
+ drop_conv_encoder_rate (`float`, *optional*, defaults to 0.0):
+ Dropout rate for the ConvEncoder component of SwiftFormer.
+ use_layer_scale (`bool`, *optional*, defaults to `True`):
+ Whether to scale outputs from token mixers.
+
+ Example:
+
+ ```python
+ >>> from transformers import SwiftFormerConfig, SwiftFormerModel
+
+ >>> # Initializing a SwiftFormer swiftformer-base-patch16-224 style configuration
+ >>> configuration = SwiftFormerConfig()
+
+ >>> # Initializing a model (with random weights) from the swiftformer-base-patch16-224 style configuration
+ >>> model = SwiftFormerModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "swiftformer"
+
+ image_size: int | list[int] | tuple[int, int] = 224
+ num_channels: int = 3
+ depths: list[int] | tuple[int, ...] = (3, 3, 6, 4)
+ embed_dims: list[int] | tuple[int, ...] = (48, 56, 112, 220)
+ mlp_ratio: int = 4
+ downsamples: list[bool] | tuple[bool, ...] = (True, True, True, True)
+ hidden_act: str = "gelu"
+ down_patch_size: int | list[int] | tuple[int, int] = 3
+ down_stride: int = 2
+ down_pad: int = 1
+ drop_path_rate: float | int = 0.0
+ drop_mlp_rate: float | int = 0.0
+ drop_conv_encoder_rate: float | int = 0.0
+ use_layer_scale: bool = True
+ layer_scale_init_value: float = 1e-5
+ batch_norm_eps: float = 1e-5
+
+
+__all__ = ["SwiftFormerConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/swiftformer/modeling_swiftformer.py b/lib/python3.11/site-packages/transformers/models/swiftformer/modeling_swiftformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d16e85c0bb2f7d1acea2f6c0b6a02ca287b2783
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swiftformer/modeling_swiftformer.py
@@ -0,0 +1,521 @@
+# Copyright 2023 MBZUAI and The HuggingFace Inc. 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.
+"""PyTorch SwiftFormer model."""
+
+import collections.abc
+
+import torch
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2CLS
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutputWithNoAttention, ImageClassifierOutputWithNoAttention
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring, logging
+from .configuration_swiftformer import SwiftFormerConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+class SwiftFormerPatchEmbedding(nn.Module):
+ """
+ Patch Embedding Layer constructed of two 2D convolutional layers.
+
+ Input: tensor of shape `[batch_size, in_channels, height, width]`
+
+ Output: tensor of shape `[batch_size, out_channels, height/4, width/4]`
+ """
+
+ def __init__(self, config: SwiftFormerConfig):
+ super().__init__()
+
+ in_chs = config.num_channels
+ out_chs = config.embed_dims[0]
+ self.patch_embedding = nn.Sequential(
+ nn.Conv2d(in_chs, out_chs // 2, kernel_size=3, stride=2, padding=1),
+ nn.BatchNorm2d(out_chs // 2, eps=config.batch_norm_eps),
+ nn.ReLU(),
+ nn.Conv2d(out_chs // 2, out_chs, kernel_size=3, stride=2, padding=1),
+ nn.BatchNorm2d(out_chs, eps=config.batch_norm_eps),
+ nn.ReLU(),
+ )
+
+ def forward(self, x):
+ return self.patch_embedding(x)
+
+
+class SwiftFormerEmbeddings(nn.Module):
+ """
+ Embeddings layer consisting of a single 2D convolutional and batch normalization layer.
+
+ Input: tensor of shape `[batch_size, channels, height, width]`
+
+ Output: tensor of shape `[batch_size, channels, height/stride, width/stride]`
+ """
+
+ def __init__(self, config: SwiftFormerConfig, index: int):
+ super().__init__()
+
+ patch_size = config.down_patch_size
+ stride = config.down_stride
+ padding = config.down_pad
+ embed_dims = config.embed_dims
+
+ in_chans = embed_dims[index]
+ embed_dim = embed_dims[index + 1]
+
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+ stride = stride if isinstance(stride, collections.abc.Iterable) else (stride, stride)
+ padding = padding if isinstance(padding, collections.abc.Iterable) else (padding, padding)
+
+ self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=stride, padding=padding)
+ self.norm = nn.BatchNorm2d(embed_dim, eps=config.batch_norm_eps)
+
+ def forward(self, x):
+ x = self.proj(x)
+ x = self.norm(x)
+ return x
+
+
+class SwiftFormerConvEncoder(nn.Module):
+ """
+ `SwiftFormerConvEncoder` with 3*3 and 1*1 convolutions.
+
+ Input: tensor of shape `[batch_size, channels, height, width]`
+
+ Output: tensor of shape `[batch_size, channels, height, width]`
+ """
+
+ def __init__(self, config: SwiftFormerConfig, dim: int):
+ super().__init__()
+ hidden_dim = int(config.mlp_ratio * dim)
+
+ self.depth_wise_conv = nn.Conv2d(dim, dim, kernel_size=3, padding=1, groups=dim)
+ self.norm = nn.BatchNorm2d(dim, eps=config.batch_norm_eps)
+ self.point_wise_conv1 = nn.Conv2d(dim, hidden_dim, kernel_size=1)
+ self.act = nn.GELU()
+ self.point_wise_conv2 = nn.Conv2d(hidden_dim, dim, kernel_size=1)
+ self.drop_path = nn.Dropout(p=config.drop_conv_encoder_rate)
+ self.layer_scale = nn.Parameter(torch.ones(dim).unsqueeze(-1).unsqueeze(-1), requires_grad=True)
+
+ def forward(self, x):
+ input = x
+ x = self.depth_wise_conv(x)
+ x = self.norm(x)
+ x = self.point_wise_conv1(x)
+ x = self.act(x)
+ x = self.point_wise_conv2(x)
+ x = input + self.drop_path(self.layer_scale * x)
+ return x
+
+
+class SwiftFormerMlp(nn.Module):
+ """
+ MLP layer with 1*1 convolutions.
+
+ Input: tensor of shape `[batch_size, channels, height, width]`
+
+ Output: tensor of shape `[batch_size, channels, height, width]`
+ """
+
+ def __init__(self, config: SwiftFormerConfig, in_features: int):
+ super().__init__()
+ hidden_features = int(in_features * config.mlp_ratio)
+ self.norm1 = nn.BatchNorm2d(in_features, eps=config.batch_norm_eps)
+ self.fc1 = nn.Conv2d(in_features, hidden_features, 1)
+ act_layer = ACT2CLS[config.hidden_act]
+ self.act = act_layer()
+ self.fc2 = nn.Conv2d(hidden_features, in_features, 1)
+ self.drop = nn.Dropout(p=config.drop_mlp_rate)
+
+ def forward(self, x):
+ x = self.norm1(x)
+ x = self.fc1(x)
+ x = self.act(x)
+ x = self.drop(x)
+ x = self.fc2(x)
+ x = self.drop(x)
+ return x
+
+
+class SwiftFormerEfficientAdditiveAttention(nn.Module):
+ """
+ Efficient Additive Attention module for SwiftFormer.
+
+ Input: tensor of shape `[batch_size, channels, height, width]`
+
+ Output: tensor of shape `[batch_size, channels, height, width]`
+ """
+
+ def __init__(self, config: SwiftFormerConfig, dim: int = 512):
+ super().__init__()
+
+ self.to_query = nn.Linear(dim, dim)
+ self.to_key = nn.Linear(dim, dim)
+
+ self.w_g = nn.Parameter(torch.randn(dim, 1))
+ self.scale_factor = dim**-0.5
+ self.proj = nn.Linear(dim, dim)
+ self.final = nn.Linear(dim, dim)
+
+ def forward(self, x):
+ query = self.to_query(x)
+ key = self.to_key(x)
+
+ query = torch.nn.functional.normalize(query, dim=-1)
+ key = torch.nn.functional.normalize(key, dim=-1)
+
+ query_weight = query @ self.w_g
+ scaled_query_weight = query_weight * self.scale_factor
+ scaled_query_weight = scaled_query_weight.softmax(dim=-1)
+
+ global_queries = torch.sum(scaled_query_weight * query, dim=1)
+ global_queries = global_queries.unsqueeze(1).repeat(1, key.shape[1], 1)
+
+ out = self.proj(global_queries * key) + query
+ out = self.final(out)
+
+ return out
+
+
+class SwiftFormerLocalRepresentation(nn.Module):
+ """
+ Local Representation module for SwiftFormer that is implemented by 3*3 depth-wise and point-wise convolutions.
+
+ Input: tensor of shape `[batch_size, channels, height, width]`
+
+ Output: tensor of shape `[batch_size, channels, height, width]`
+ """
+
+ def __init__(self, config: SwiftFormerConfig, dim: int):
+ super().__init__()
+
+ self.depth_wise_conv = nn.Conv2d(dim, dim, kernel_size=3, padding=1, groups=dim)
+ self.norm = nn.BatchNorm2d(dim, eps=config.batch_norm_eps)
+ self.point_wise_conv1 = nn.Conv2d(dim, dim, kernel_size=1)
+ self.act = nn.GELU()
+ self.point_wise_conv2 = nn.Conv2d(dim, dim, kernel_size=1)
+ self.drop_path = nn.Identity()
+ self.layer_scale = nn.Parameter(torch.ones(dim).unsqueeze(-1).unsqueeze(-1), requires_grad=True)
+
+ def forward(self, x):
+ input = x
+ x = self.depth_wise_conv(x)
+ x = self.norm(x)
+ x = self.point_wise_conv1(x)
+ x = self.act(x)
+ x = self.point_wise_conv2(x)
+ x = input + self.drop_path(self.layer_scale * x)
+ return x
+
+
+# Copied from transformers.models.swin.modular_swin.SwinDropPath with SwinDropPath->SwiftFormerDropPath
+class SwiftFormerDropPath(nn.Module):
+ """Stochastic depth (DropPath) per sample, for residual blocks.
+
+ Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
+ <https://arxiv.org/abs/1603.09382>`_.
+ """
+
+ def __init__(self, drop_prob: float = 0.0) -> None:
+ super().__init__()
+ self.drop_prob = drop_prob
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ if self.drop_prob == 0.0 or not self.training:
+ return hidden_states
+ keep_prob = 1 - self.drop_prob
+ shape = (hidden_states.shape[0],) + (1,) * (hidden_states.ndim - 1)
+ random_tensor = torch.rand(shape, dtype=hidden_states.dtype, device=hidden_states.device)
+ random_tensor = torch.floor(random_tensor + keep_prob)
+ return hidden_states.div(keep_prob) * random_tensor
+
+ def extra_repr(self) -> str:
+ return f"p={self.drop_prob}"
+
+
+class SwiftFormerEncoderBlock(nn.Module):
+ """
+ SwiftFormer Encoder Block for SwiftFormer. It consists of (1) Local representation module, (2)
+ SwiftFormerEfficientAdditiveAttention, and (3) MLP block.
+
+ Input: tensor of shape `[batch_size, channels, height, width]`
+
+ Output: tensor of shape `[batch_size, channels,height, width]`
+ """
+
+ def __init__(self, config: SwiftFormerConfig, dim: int, drop_path: float = 0.0) -> None:
+ super().__init__()
+
+ layer_scale_init_value = config.layer_scale_init_value
+ use_layer_scale = config.use_layer_scale
+
+ self.local_representation = SwiftFormerLocalRepresentation(config, dim=dim)
+ self.attn = SwiftFormerEfficientAdditiveAttention(config, dim=dim)
+ self.linear = SwiftFormerMlp(config, in_features=dim)
+ self.drop_path = SwiftFormerDropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+ self.use_layer_scale = use_layer_scale
+ if use_layer_scale:
+ self.layer_scale_1 = nn.Parameter(
+ layer_scale_init_value * torch.ones(dim).unsqueeze(-1).unsqueeze(-1), requires_grad=True
+ )
+ self.layer_scale_2 = nn.Parameter(
+ layer_scale_init_value * torch.ones(dim).unsqueeze(-1).unsqueeze(-1), requires_grad=True
+ )
+
+ def forward(self, x):
+ x = self.local_representation(x)
+ batch_size, channels, height, width = x.shape
+ res = self.attn(x.permute(0, 2, 3, 1).reshape(batch_size, height * width, channels))
+ res = res.reshape(batch_size, height, width, channels).permute(0, 3, 1, 2)
+ if self.use_layer_scale:
+ x = x + self.drop_path(self.layer_scale_1 * res)
+ x = x + self.drop_path(self.layer_scale_2 * self.linear(x))
+ else:
+ x = x + self.drop_path(res)
+ x = x + self.drop_path(self.linear(x))
+ return x
+
+
+class SwiftFormerStage(GradientCheckpointingLayer):
+ """
+ A Swiftformer stage consisting of a series of `SwiftFormerConvEncoder` blocks and a final
+ `SwiftFormerEncoderBlock`.
+
+ Input: tensor in shape `[batch_size, channels, height, width]`
+
+ Output: tensor in shape `[batch_size, channels, height, width]`
+ """
+
+ def __init__(self, config: SwiftFormerConfig, index: int) -> None:
+ super().__init__()
+
+ layer_depths = config.depths
+ dim = config.embed_dims[index]
+ depth = layer_depths[index]
+
+ blocks = []
+ for block_idx in range(depth):
+ block_dpr = config.drop_path_rate * (block_idx + sum(layer_depths[:index])) / (sum(layer_depths) - 1)
+
+ if depth - block_idx <= 1:
+ blocks.append(SwiftFormerEncoderBlock(config, dim=dim, drop_path=block_dpr))
+ else:
+ blocks.append(SwiftFormerConvEncoder(config, dim=dim))
+
+ self.blocks = nn.ModuleList(blocks)
+
+ def forward(self, input):
+ for block in self.blocks:
+ input = block(input)
+ return input
+
+
+class SwiftFormerEncoder(nn.Module):
+ def __init__(self, config: SwiftFormerConfig) -> None:
+ super().__init__()
+ self.config = config
+
+ embed_dims = config.embed_dims
+ downsamples = config.downsamples
+ layer_depths = config.depths
+
+ # Transformer model
+ network = []
+ for i in range(len(layer_depths)):
+ stage = SwiftFormerStage(config=config, index=i)
+ network.append(stage)
+ if i >= len(layer_depths) - 1:
+ break
+ if downsamples[i] or embed_dims[i] != embed_dims[i + 1]:
+ # downsampling between two stages
+ network.append(SwiftFormerEmbeddings(config, index=i))
+ self.network = nn.ModuleList(network)
+
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ ) -> tuple | BaseModelOutputWithNoAttention:
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ all_hidden_states = (hidden_states,) if output_hidden_states else None
+
+ for block in self.network:
+ hidden_states = block(hidden_states)
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states] if v is not None)
+
+ return BaseModelOutputWithNoAttention(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ )
+
+
+@auto_docstring
+class SwiftFormerPreTrainedModel(PreTrainedModel):
+ config: SwiftFormerConfig
+ base_model_prefix = "swiftformer"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["SwiftFormerEncoderBlock"]
+
+ @torch.no_grad()
+ def _init_weights(self, module: nn.Module) -> None:
+ """Initialize the weights"""
+ if isinstance(module, (nn.Conv2d, nn.Linear)):
+ init.trunc_normal_(module.weight, std=0.02)
+ if module.bias is not None:
+ init.constant_(module.bias, 0)
+ elif isinstance(module, (nn.LayerNorm, nn.BatchNorm2d)):
+ init.constant_(module.bias, 0)
+ init.constant_(module.weight, 1.0)
+ if getattr(module, "running_mean", None) is not None:
+ init.zeros_(module.running_mean)
+ init.ones_(module.running_var)
+ init.zeros_(module.num_batches_tracked)
+ elif isinstance(module, (SwiftFormerConvEncoder, SwiftFormerLocalRepresentation)):
+ init.ones_(module.layer_scale)
+ elif isinstance(module, SwiftFormerEncoderBlock):
+ if self.config.use_layer_scale:
+ init.constant_(module.layer_scale_1, self.config.layer_scale_init_value)
+ init.constant_(module.layer_scale_2, self.config.layer_scale_init_value)
+ elif isinstance(module, SwiftFormerEfficientAdditiveAttention):
+ init.normal_(module.w_g)
+
+
+@auto_docstring
+class SwiftFormerModel(SwiftFormerPreTrainedModel):
+ def __init__(self, config: SwiftFormerConfig):
+ super().__init__(config)
+ self.config = config
+
+ self.patch_embed = SwiftFormerPatchEmbedding(config)
+ self.encoder = SwiftFormerEncoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutputWithNoAttention:
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if pixel_values is None:
+ raise ValueError("You have to specify pixel_values")
+
+ embedding_output = self.patch_embed(pixel_values)
+ encoder_outputs = self.encoder(
+ embedding_output,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if not return_dict:
+ return tuple(v for v in encoder_outputs if v is not None)
+
+ return BaseModelOutputWithNoAttention(
+ last_hidden_state=encoder_outputs.last_hidden_state,
+ hidden_states=encoder_outputs.hidden_states,
+ )
+
+
+@auto_docstring
+class SwiftFormerForImageClassification(SwiftFormerPreTrainedModel):
+ def __init__(self, config: SwiftFormerConfig) -> None:
+ super().__init__(config)
+
+ embed_dims = config.embed_dims
+
+ self.num_labels = config.num_labels
+ self.swiftformer = SwiftFormerModel(config)
+
+ # Classifier head
+ self.norm = nn.BatchNorm2d(embed_dims[-1], eps=config.batch_norm_eps)
+ self.head = nn.Linear(embed_dims[-1], self.num_labels) if self.num_labels > 0 else nn.Identity()
+ self.dist_head = nn.Linear(embed_dims[-1], self.num_labels) if self.num_labels > 0 else nn.Identity()
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor | None = None,
+ labels: torch.Tensor | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | ImageClassifierOutputWithNoAttention:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # run base model
+ outputs = self.swiftformer(
+ pixel_values,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = outputs.last_hidden_state if return_dict else outputs[0]
+
+ # run classification head
+ sequence_output = self.norm(sequence_output)
+ sequence_output = sequence_output.flatten(2).mean(-1)
+ cls_out = self.head(sequence_output)
+ distillation_out = self.dist_head(sequence_output)
+ logits = (cls_out + distillation_out) / 2
+
+ # calculate loss
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config)
+
+ if not return_dict:
+ output = (logits,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return ImageClassifierOutputWithNoAttention(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ )
+
+
+__all__ = ["SwiftFormerForImageClassification", "SwiftFormerModel", "SwiftFormerPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/swin/__init__.py b/lib/python3.11/site-packages/transformers/models/swin/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf351e817fdfa519d1fdc84cb0084214fb37bd4f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swin/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_swin import *
+ from .modeling_swin import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/swin/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swin/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..38f9ed6bfcee03103fc95c1897c0f76944c40be1
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swin/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swin/__pycache__/configuration_swin.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swin/__pycache__/configuration_swin.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..672b571ae4006a20df6064fd75a70a1ba674fdef
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swin/__pycache__/configuration_swin.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swin/__pycache__/modeling_swin.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swin/__pycache__/modeling_swin.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f881389de1ae5f7a155ae0ed6c50d21503ad7715
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swin/__pycache__/modeling_swin.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swin/__pycache__/modular_swin.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swin/__pycache__/modular_swin.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f184c525cc3f9523467a7027faa78cd3d50ed59f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swin/__pycache__/modular_swin.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swin/configuration_swin.py b/lib/python3.11/site-packages/transformers/models/swin/configuration_swin.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fc542f03a54c5d09c4c791d87b2cc109975c601
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swin/configuration_swin.py
@@ -0,0 +1,90 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""Swin Transformer model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import BackboneConfigMixin
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="microsoft/swin-tiny-patch4-window7-224")
+@strict
+class SwinConfig(BackboneConfigMixin, PreTrainedConfig):
+ r"""
+ depths (`list(int)`, *optional*, defaults to `[2, 2, 6, 2]`):
+ Depth of each layer in the Transformer encoder.
+ num_heads (`list(int)`, *optional*, defaults to `[3, 6, 12, 24]`):
+ Number of attention heads in each layer of the Transformer encoder.
+ window_size (`int`, *optional*, defaults to 7):
+ Size of windows.
+ encoder_stride (`int`, *optional*, defaults to 32):
+ Factor to increase the spatial resolution by in the decoder head for masked image modeling.
+
+ Example:
+
+ ```python
+ >>> from transformers import SwinConfig, SwinModel
+
+ >>> # Initializing a Swin microsoft/swin-tiny-patch4-window7-224 style configuration
+ >>> configuration = SwinConfig()
+
+ >>> # Initializing a model (with random weights) from the microsoft/swin-tiny-patch4-window7-224 style configuration
+ >>> model = SwinModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "swin"
+
+ attribute_map = {
+ "num_attention_heads": "num_heads",
+ "num_hidden_layers": "num_layers",
+ }
+
+ image_size: int | list[int] | tuple[int, int] = 224
+ patch_size: int | list[int] | tuple[int, int] = 4
+ num_channels: int = 3
+ embed_dim: int = 96
+ depths: list[int] | tuple[int, ...] = (2, 2, 6, 2)
+ num_heads: list[int] | tuple[int, ...] = (3, 6, 12, 24)
+ window_size: int = 7
+ mlp_ratio: float | int = 4.0
+ qkv_bias: bool = True
+ hidden_dropout_prob: float | int = 0.0
+ attention_probs_dropout_prob: float | int = 0.0
+ drop_path_rate: float | int = 0.1
+ hidden_act: str = "gelu"
+ use_absolute_embeddings: bool = False
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-5
+ encoder_stride: int = 32
+ _out_features: list[str] | None = None
+ _out_indices: list[int] | None = None
+
+ def __post_init__(self, **kwargs):
+ self.num_layers = len(self.depths)
+ # we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
+ # this indicates the channel dimension after the last stage of the model
+ self.hidden_size = int(self.embed_dim * 2 ** (len(self.depths) - 1))
+ self.stage_names = ["stem"] + [f"stage{idx}" for idx in range(1, len(self.depths) + 1)]
+ self.set_output_features_output_indices(
+ out_indices=kwargs.pop("out_indices", None), out_features=kwargs.pop("out_features", None)
+ )
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["SwinConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/swin/modeling_swin.py b/lib/python3.11/site-packages/transformers/models/swin/modeling_swin.py
new file mode 100644
index 0000000000000000000000000000000000000000..931fdaff839886d54aee5ea30c7f6258c035d7f7
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swin/modeling_swin.py
@@ -0,0 +1,1163 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/swin/modular_swin.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_swin.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2022 Microsoft Research and The HuggingFace Inc. 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 collections.abc
+import math
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...backbone_utils import BackboneMixin, filter_output_hidden_states
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BackboneOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import ModelOutput, TransformersKwargs, auto_docstring, torch_int
+from ...utils.generic import can_return_tuple, merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from .configuration_swin import SwinConfig
+
+
+class SwinDropPath(nn.Module):
+ """Stochastic depth (DropPath) per sample, for residual blocks.
+
+ Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
+ <https://arxiv.org/abs/1603.09382>`_.
+ """
+
+ def __init__(self, drop_prob: float = 0.0) -> None:
+ super().__init__()
+ self.drop_prob = drop_prob
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ if self.drop_prob == 0.0 or not self.training:
+ return hidden_states
+ keep_prob = 1 - self.drop_prob
+ shape = (hidden_states.shape[0],) + (1,) * (hidden_states.ndim - 1)
+ random_tensor = torch.rand(shape, dtype=hidden_states.dtype, device=hidden_states.device)
+ random_tensor = torch.floor(random_tensor + keep_prob)
+ return hidden_states.div(keep_prob) * random_tensor
+
+ def extra_repr(self) -> str:
+ return f"p={self.drop_prob}"
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin encoder's outputs, with potential hidden states and attentions.
+ """
+)
+@dataclass
+class SwinEncoderOutput(ModelOutput):
+ r"""
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin model's outputs that also contains a pooling of the last hidden states.
+ """
+)
+@dataclass
+class SwinModelOutput(ModelOutput):
+ r"""
+ pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`, *optional*, returned when `add_pooling_layer=True` is passed):
+ Average pooling of the last layer hidden-state.
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ last_hidden_state: torch.FloatTensor | None = None
+ pooler_output: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin masked image model outputs.
+ """
+)
+@dataclass
+class SwinMaskedImageModelingOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `bool_masked_pos` is provided):
+ Masked image modeling (MLM) loss.
+ reconstruction (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+ Reconstructed pixel values.
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ loss: torch.FloatTensor | None = None
+ reconstruction: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin outputs for image classification.
+ """
+)
+@dataclass
+class SwinImageClassifierOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+ Classification (or regression if config.num_labels==1) loss.
+ logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
+ Classification (or regression if config.num_labels==1) scores (before SoftMax).
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+class SwinEmbeddings(nn.Module):
+ """
+ Construct the patch and position embeddings. Optionally, also the mask token.
+ """
+
+ def __init__(self, config, use_mask_token=False):
+ super().__init__()
+
+ self.patch_embeddings = SwinPatchEmbeddings(config)
+ num_patches = self.patch_embeddings.num_patches
+ self.patch_grid = self.patch_embeddings.grid_size
+ self.mask_token = nn.Parameter(torch.zeros(1, 1, config.embed_dim)) if use_mask_token else None
+
+ self.position_embeddings = (
+ nn.Parameter(torch.zeros(1, num_patches, config.embed_dim)) if config.use_absolute_embeddings else None
+ )
+
+ self.norm = nn.LayerNorm(config.embed_dim)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+ self.patch_size = config.patch_size
+ self.config = config
+
+ def interpolate_pos_encoding(self, embeddings: torch.Tensor, height: int, width: int) -> torch.Tensor:
+ """
+ Interpolate pre-trained position encodings to support higher-resolution images at inference.
+ Unlike ViT, Swin has no CLS token, so position embeddings cover patch positions only.
+ """
+ num_patches = embeddings.shape[1]
+ num_positions = self.position_embeddings.shape[1]
+
+ # always interpolate when tracing to ensure the exported model works for dynamic input shapes
+ if not torch.jit.is_tracing() and num_patches == num_positions and height == width:
+ return self.position_embeddings
+
+ dim = embeddings.shape[-1]
+
+ new_height = height // self.patch_size
+ new_width = width // self.patch_size
+
+ sqrt_num_positions = torch_int(num_positions**0.5)
+ patch_pos_embed = self.position_embeddings.reshape(1, sqrt_num_positions, sqrt_num_positions, dim)
+ patch_pos_embed = patch_pos_embed.permute(0, 3, 1, 2)
+
+ patch_pos_embed = nn.functional.interpolate(
+ patch_pos_embed,
+ size=(new_height, new_width),
+ mode="bicubic",
+ align_corners=False,
+ )
+
+ return patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ ) -> tuple[torch.Tensor]:
+ _, num_channels, height, width = pixel_values.shape
+ embeddings, output_dimensions = self.patch_embeddings(pixel_values)
+ embeddings = self.norm(embeddings)
+ batch_size, seq_len, _ = embeddings.size()
+
+ if bool_masked_pos is not None:
+ mask_tokens = self.mask_token.expand(batch_size, seq_len, -1)
+ # replace the masked visual tokens by mask_tokens
+ mask = bool_masked_pos.unsqueeze(-1).type_as(mask_tokens)
+ embeddings = embeddings * (1.0 - mask) + mask_tokens * mask
+
+ if self.position_embeddings is not None:
+ if interpolate_pos_encoding:
+ embeddings = embeddings + self.interpolate_pos_encoding(embeddings, height, width)
+ else:
+ embeddings = embeddings + self.position_embeddings
+
+ embeddings = self.dropout(embeddings)
+
+ return embeddings, output_dimensions
+
+
+class SwinPatchEmbeddings(nn.Module):
+ """
+ This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
+ `hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
+ Transformer.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ image_size, patch_size = config.image_size, config.patch_size
+ num_channels, hidden_size = config.num_channels, config.embed_dim
+ image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+ num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
+ self.patch_size = patch_size
+ self.num_patches = num_patches
+ self.grid_size = (image_size[0] // patch_size[0], image_size[1] // patch_size[1])
+
+ self.projection = nn.Conv2d(num_channels, hidden_size, kernel_size=patch_size, stride=patch_size)
+
+ def maybe_pad(self, pixel_values, height, width):
+ """Pad pixel_values to be divisible by patch_size if needed."""
+ if width % self.patch_size[1] != 0:
+ pad_values = (0, self.patch_size[1] - width % self.patch_size[1])
+ pixel_values = nn.functional.pad(pixel_values, pad_values)
+ if height % self.patch_size[0] != 0:
+ pad_values = (0, 0, 0, self.patch_size[0] - height % self.patch_size[0])
+ pixel_values = nn.functional.pad(pixel_values, pad_values)
+ return pixel_values
+
+ def forward(self, pixel_values: torch.FloatTensor | None) -> tuple[torch.Tensor, tuple[int]]:
+ _, num_channels, height, width = pixel_values.shape
+ # pad the input to be divisible by self.patch_size, if needed
+ pixel_values = self.maybe_pad(pixel_values, height, width)
+ embeddings = self.projection(pixel_values)
+ _, _, height, width = embeddings.shape
+ output_dimensions = (height, width)
+ embeddings = embeddings.flatten(2).transpose(1, 2)
+
+ return embeddings, output_dimensions
+
+
+class SwinPatchMerging(nn.Module):
+ """
+ Patch Merging Layer.
+
+ Args:
+ dim (`int`):
+ Number of input channels.
+ """
+
+ def __init__(self, dim: int) -> None:
+ super().__init__()
+ self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+ self.norm = nn.LayerNorm(4 * dim)
+
+ def maybe_pad(self, input_feature: torch.Tensor, height: int, width: int) -> torch.Tensor:
+ """Pad input feature map to be divisible by 2 in both spatial dimensions if needed."""
+ if (height % 2 == 1) or (width % 2 == 1):
+ input_feature = nn.functional.pad(input_feature, (0, 0, 0, width % 2, 0, height % 2))
+ return input_feature
+
+ def forward(self, input_feature: torch.Tensor, input_dimensions: tuple[int, int]) -> torch.Tensor:
+ height, width = input_dimensions
+ # `dim` is height * width
+ batch_size, dim, num_channels = input_feature.shape
+
+ input_feature = input_feature.view(batch_size, height, width, num_channels)
+ # pad input to be divisible by width and height, if needed
+ input_feature = self.maybe_pad(input_feature, height, width)
+ # Interleave rows and columns to produce [batch_size, height/2*width/2, 4*num_channels]
+ input_feature = torch.cat(
+ [input_feature[:, row::2, col::2, :] for col in range(2) for row in range(2)], dim=-1
+ )
+ input_feature = input_feature.view(batch_size, -1, 4 * num_channels)
+
+ input_feature = self.norm(input_feature)
+ input_feature = self.reduction(input_feature)
+
+ return input_feature
+
+
+class SwinRelativePositionBias(nn.Module):
+ """
+ Relative position bias for Swin's window-based attention, following the style of BeitRelativePositionBias.
+
+ Unlike BeiT, Swin has no CLS token, so the table covers exactly (2*ws_h-1)*(2*ws_w-1) unique
+ relative positions. The lookup index is purely determined by window_size (static), so it is stored
+ as a non-persistent buffer (recomputed from config on load, never serialised). The table values
+ are learned parameters and must be re-read on every forward call.
+ """
+
+ def __init__(self, num_heads: int, window_size: tuple[int, int]):
+ super().__init__()
+ self.window_size = window_size
+ self.window_area = window_size[0] * window_size[1]
+ self.relative_position_bias_table = nn.Parameter(
+ torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)
+ )
+ # Non-persistent: fully determined by window_size, no need to serialise.
+ # Stored flat so forward avoids an extra .view() call.
+ self.register_buffer(
+ "relative_position_index",
+ self._create_relative_position_index().view(-1),
+ persistent=False,
+ )
+
+ def _create_relative_position_index(self) -> torch.Tensor:
+ coords_h = torch.arange(self.window_size[0])
+ coords_w = torch.arange(self.window_size[1])
+
+ coords = torch.stack(torch.meshgrid([coords_h, coords_w], indexing="ij")) # 2, Wh, Ww
+ coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww
+
+ relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww
+ relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2
+
+ # shift to start from 0 and compute a unique flat index for each (dh, dw) pair
+ relative_coords[:, :, 0] += self.window_size[0] - 1
+ relative_coords[:, :, 1] += self.window_size[1] - 1
+ relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+
+ return relative_coords.sum(-1) # Wh*Ww, Wh*Ww
+
+ def forward(self) -> torch.Tensor:
+ relative_position_bias = self.relative_position_bias_table[self.relative_position_index]
+ relative_position_bias = relative_position_bias.view(self.window_area, self.window_area, -1)
+ return relative_position_bias.permute(2, 0, 1).contiguous().unsqueeze(0) # 1, num_heads, Wh*Ww, Wh*Ww
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float | None = None,
+ dropout: float = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ if scaling is None:
+ scaling = query.size(-1) ** -0.5
+
+ # Take the dot product between "query" and "key" to get the raw attention scores.
+ attn_weights = torch.matmul(query, key.transpose(2, 3)) * scaling
+
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+class SwinAttention(nn.Module):
+ def __init__(self, config: SwinConfig, hidden_size: int, num_attention_heads: int, window_size: int):
+ super().__init__()
+ self.config = config
+ self.num_attention_heads = num_attention_heads
+ self.head_dim = hidden_size // num_attention_heads
+ self.attention_dropout = config.attention_probs_dropout_prob
+ self.scaling = self.head_dim**-0.5
+ self.is_causal = False
+
+ self.q_proj = nn.Linear(hidden_size, hidden_size, bias=config.qkv_bias)
+ self.k_proj = nn.Linear(hidden_size, hidden_size, bias=config.qkv_bias)
+ self.v_proj = nn.Linear(hidden_size, hidden_size, bias=config.qkv_bias)
+ self.o_proj = nn.Linear(hidden_size, hidden_size)
+
+ self.relative_position_bias = SwinRelativePositionBias(num_attention_heads, (window_size, window_size))
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ # hidden_states: (batch_size * num_windows, window_size * window_size, channels)
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ # Combine relative position bias with the cyclic-shift attention mask for SW-MSA
+ relative_position_bias = self.relative_position_bias() # 1, num_heads, ws*ws, ws*ws
+ if attention_mask is not None:
+ # attention_mask: (num_windows, ws*ws, ws*ws)
+ num_windows = attention_mask.shape[0]
+ batch_size = input_shape[0] // num_windows
+ seq_len = input_shape[1]
+ # Expand to (batch * num_windows, 1, ws*ws, ws*ws) for broadcasting
+ attention_mask = (
+ attention_mask.unsqueeze(1) # (num_windows, 1, ws*ws, ws*ws)
+ .unsqueeze(0) # (1, num_windows, 1, ws*ws, ws*ws)
+ .expand(batch_size, -1, -1, -1, -1) # (batch, num_windows, 1, ws*ws, ws*ws)
+ .reshape(-1, 1, seq_len, seq_len) # (batch * num_windows, 1, ws*ws, ws*ws)
+ )
+ combined_mask = relative_position_bias + attention_mask
+ else:
+ combined_mask = relative_position_bias
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ combined_mask,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ scaling=self.scaling,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+class SwinMLP(nn.Module):
+ def __init__(self, config: SwinConfig, dim: int):
+ super().__init__()
+ self.activation_fn = ACT2FN[config.hidden_act]
+ self.fc1 = nn.Linear(dim, int(config.mlp_ratio * dim))
+ self.fc2 = nn.Linear(int(config.mlp_ratio * dim), dim)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.fc1(hidden_states)
+ hidden_states = self.activation_fn(hidden_states)
+ hidden_states = self.fc2(hidden_states)
+
+ return hidden_states
+
+
+def window_partition(input_feature, window_size):
+ """
+ Partitions the given input into windows.
+ """
+ batch_size, height, width, num_channels = input_feature.shape
+ input_feature = input_feature.view(
+ batch_size, height // window_size, window_size, width // window_size, window_size, num_channels
+ )
+ windows = input_feature.transpose(2, 3).contiguous().view(-1, window_size, window_size, num_channels)
+ return windows
+
+
+def window_reverse(windows, window_size, height, width):
+ """
+ Merges windows to produce higher resolution features.
+ """
+ num_channels = windows.shape[-1]
+ windows = windows.view(-1, height // window_size, width // window_size, window_size, window_size, num_channels)
+ windows = windows.transpose(2, 3).contiguous().view(-1, height, width, num_channels)
+ return windows
+
+
+class SwinLayer(GradientCheckpointingLayer):
+ def __init__(
+ self,
+ config: SwinConfig,
+ dim: int,
+ input_resolution: tuple[int, int],
+ num_heads: int,
+ drop_path_rate: float = 0.0,
+ shift_size: int = 0,
+ ):
+ super().__init__()
+ self.attention = SwinAttention(config, dim, num_heads, window_size=config.window_size)
+ self.layernorm_before = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+ self.layernorm_after = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+ self.mlp = SwinMLP(config, dim)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+ self.window_size = config.window_size
+ self.shift_size = shift_size
+ self.input_resolution = input_resolution
+ self.drop_path = SwinDropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity()
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ always_partition: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ if not always_partition:
+ self.set_shift_and_window_size(input_dimensions)
+ height, width = input_dimensions
+ batch_size, _, channels = hidden_states.size()
+ shortcut = hidden_states
+
+ hidden_states = self.layernorm_before(hidden_states)
+ hidden_states = hidden_states.view(batch_size, height, width, channels)
+
+ # pad hidden_states to multiples of window size
+ hidden_states, pad_values = self.maybe_pad(hidden_states, height, width)
+ _, height_pad, width_pad, _ = hidden_states.shape
+
+ hidden_states_windows = window_partition(self.cyclic_shift(hidden_states), self.window_size)
+ hidden_states_windows = hidden_states_windows.view(-1, self.window_size * self.window_size, channels)
+ attn_mask = self.get_attn_mask(
+ height_pad, width_pad, dtype=hidden_states.dtype, device=hidden_states_windows.device
+ )
+
+ attention_output, attn_weights = self.attention(hidden_states_windows, attn_mask, **kwargs)
+ attention_output = self.dropout(attention_output)
+
+ attention_windows = attention_output.view(-1, self.window_size, self.window_size, channels)
+ attention_windows = self.cyclic_shift(
+ window_reverse(attention_windows, self.window_size, height_pad, width_pad), reverse=True
+ )
+
+ if pad_values[3] > 0 or pad_values[5] > 0:
+ attention_windows = attention_windows[:, :height, :width, :].contiguous()
+
+ attention_windows = attention_windows.view(batch_size, height * width, channels)
+ hidden_states = shortcut + self.drop_path(attention_windows)
+
+ residual = hidden_states
+ hidden_states = self.layernorm_after(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.dropout(hidden_states) + residual
+
+ return hidden_states, attn_weights
+
+ def set_shift_and_window_size(self, input_resolution: tuple[int, int]) -> None:
+ """Clamp window and shift sizes when the window is larger than the input resolution."""
+ if min(input_resolution) <= self.window_size:
+ self.shift_size = torch_int(0)
+ self.window_size = (
+ torch.min(torch.tensor(input_resolution)) if torch.jit.is_tracing() else min(input_resolution)
+ )
+
+ def get_attn_mask(self, height: int, width: int, dtype: torch.dtype, device: torch.device) -> torch.Tensor | None:
+ """Build the cyclic-shift attention mask for shifted-window MSA; returns None when shift_size is 0."""
+ if self.shift_size > 0:
+ img_mask = torch.zeros((1, height, width, 1), dtype=dtype, device=device)
+ height_slices = (
+ slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None),
+ )
+ width_slices = (
+ slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None),
+ )
+ count = 0
+ for height_slice in height_slices:
+ for width_slice in width_slices:
+ img_mask[:, height_slice, width_slice, :] = count
+ count += 1
+
+ mask_windows = window_partition(img_mask, self.window_size)
+ mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+ attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+ attn_mask = attn_mask.masked_fill(attn_mask != 0, -100.0).masked_fill(attn_mask == 0, 0.0)
+ else:
+ attn_mask = None
+ return attn_mask
+
+ def maybe_pad(self, hidden_states: torch.Tensor, height: int, width: int) -> tuple[torch.Tensor, tuple[int, ...]]:
+ """Pad feature map so both spatial dimensions are divisible by window_size."""
+ pad_right = (self.window_size - width % self.window_size) % self.window_size
+ pad_bottom = (self.window_size - height % self.window_size) % self.window_size
+ pad_values = (0, 0, 0, pad_right, 0, pad_bottom)
+ hidden_states = nn.functional.pad(hidden_states, pad_values)
+ return hidden_states, pad_values
+
+ def cyclic_shift(self, hidden_states: torch.Tensor, reverse: bool = False) -> torch.Tensor:
+ """Apply a cyclic shift along the spatial dimensions for shifted-window attention."""
+ if self.shift_size > 0:
+ direction = 1 if reverse else -1
+ hidden_states = torch.roll(
+ hidden_states,
+ shifts=(direction * self.shift_size, direction * self.shift_size),
+ dims=(1, 2),
+ )
+ return hidden_states
+
+
+class SwinStage(GradientCheckpointingLayer):
+ def __init__(
+ self,
+ config: SwinConfig,
+ dim: int,
+ input_resolution: tuple[int, int],
+ depth: int,
+ num_heads: int,
+ drop_path: list[float],
+ downsample,
+ ):
+ super().__init__()
+ self.config = config
+ self.blocks = nn.ModuleList(
+ [
+ SwinLayer(
+ config=config,
+ dim=dim,
+ input_resolution=input_resolution,
+ num_heads=num_heads,
+ drop_path_rate=drop_path[i],
+ shift_size=0 if (i % 2 == 0) else config.window_size // 2,
+ )
+ for i in range(depth)
+ ]
+ )
+
+ self.downsample = downsample(dim=dim) if downsample is not None else None
+
+ def get_reshaped_hidden_states(
+ self,
+ hidden_states: torch.Tensor,
+ hidden_states_before_downsampling: torch.Tensor,
+ height: int,
+ width: int,
+ output_hidden_states_before_downsampling: bool,
+ ) -> torch.Tensor:
+ """
+ Select the spatial hidden states for this stage and reshape from (B, L, C) to (B, C, H, W).
+
+ The chosen state and its resolution depend on output_hidden_states_before_downsampling:
+ - True → pre-downsampling states at (height, width) — used by the backbone.
+ - False → post-downsampling states at half the resolution (if a downsampler exists).
+ """
+ if output_hidden_states_before_downsampling:
+ spatial_state, h, w = hidden_states_before_downsampling, height, width
+ elif self.downsample is not None:
+ spatial_state, h, w = hidden_states, (height + 1) // 2, (width + 1) // 2
+ else:
+ spatial_state, h, w = hidden_states, height, width
+
+ batch_size, _, hidden_size = spatial_state.shape
+ return spatial_state.view(batch_size, h, w, hidden_size).permute(0, 3, 1, 2).contiguous()
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ always_partition: bool = False,
+ output_hidden_states_before_downsampling: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None]:
+ height, width = input_dimensions
+ last_attn_weights = None
+ for layer_module in self.blocks:
+ hidden_states, last_attn_weights = layer_module(
+ hidden_states, input_dimensions, always_partition=always_partition, **kwargs
+ )
+
+ hidden_states_before_downsampling = hidden_states
+ if self.downsample is not None:
+ hidden_states = self.downsample(hidden_states_before_downsampling, input_dimensions)
+
+ reshaped_hidden_states = self.get_reshaped_hidden_states(
+ hidden_states, hidden_states_before_downsampling, height, width, output_hidden_states_before_downsampling
+ )
+
+ return hidden_states, reshaped_hidden_states, last_attn_weights
+
+
+@auto_docstring
+class SwinPreTrainedModel(PreTrainedModel):
+ config: SwinConfig
+ base_model_prefix = "swin"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["SwinStage"]
+ _supports_sdpa = True
+ _supports_flash_attn = False
+ _supports_flex_attn = False
+ _supports_attention_backend = True
+ _can_compile_fullgraph = True
+ _can_record_outputs = {
+ # capture_initial_hidden_state=True: prepend the embedding input (args[0] of SwinStage 0) so that
+ # hidden_states[0] has the same shape as the patch embeddings (num_patches, embed_dim).
+ "hidden_states": OutputRecorder(SwinStage, index=0, capture_initial_hidden_state=True),
+ # reshaped_hidden_states are collected explicitly by SwinEncoder (per stage) and the stem
+ # is prepended in SwinModel.forward, so they are NOT captured via hooks here.
+ # index=2: SwinStage returns (hidden_states, reshaped_hidden_states, last_attn_weights);
+ # capture the last block's attention weights at index 2, giving one entry per stage.
+ "attentions": OutputRecorder(SwinStage, index=2, capture_initial_hidden_state=False),
+ }
+ _input_embed_layer = "patch_embeddings"
+ # relative_position_index is now a non-persistent buffer (recomputed from window_size in __init__).
+ _keys_to_ignore_on_load_unexpected = [
+ r"attention\.self\.relative_position_index",
+ r"attention\.relative_position_bias\.relative_position_index",
+ ]
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ super()._init_weights(module)
+ if isinstance(module, SwinEmbeddings):
+ if module.mask_token is not None:
+ init.zeros_(module.mask_token)
+ if module.position_embeddings is not None:
+ init.zeros_(module.position_embeddings)
+ elif isinstance(module, SwinRelativePositionBias):
+ init.zeros_(module.relative_position_bias_table)
+ init.copy_(module.relative_position_index, module._create_relative_position_index().view(-1))
+
+
+class SwinEncoder(SwinPreTrainedModel):
+ def __init__(self, config: SwinConfig, grid_size: tuple[int, int]):
+ super().__init__(config)
+ self.num_layers = len(config.depths)
+ self.config = config
+ dpr = [config.drop_path_rate * i / max(sum(config.depths) - 1, 1) for i in range(sum(config.depths))]
+ self.layers = nn.ModuleList(
+ [
+ SwinStage(
+ config=config,
+ dim=int(config.embed_dim * 2**layer_idx),
+ input_resolution=(grid_size[0] // (2**layer_idx), grid_size[1] // (2**layer_idx)),
+ depth=config.depths[layer_idx],
+ num_heads=config.num_heads[layer_idx],
+ drop_path=dpr[sum(config.depths[:layer_idx]) : sum(config.depths[: layer_idx + 1])],
+ downsample=SwinPatchMerging if (layer_idx < self.num_layers - 1) else None,
+ )
+ for layer_idx in range(self.num_layers)
+ ]
+ )
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ always_partition: bool = False,
+ output_hidden_states: bool = False,
+ output_hidden_states_before_downsampling: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SwinEncoderOutput:
+ r"""
+ input_dimensions (`tuple[int, int]`):
+ Spatial `(height, width)` of the patch grid entering the encoder.
+ always_partition (`bool`, *optional*, defaults to `False`):
+ If `True`, always apply window partitioning regardless of input resolution.
+ output_hidden_states_before_downsampling (`bool`, *optional*, defaults to `False`):
+ If `True`, `reshaped_hidden_states` contains pre-downsampling feature maps.
+ """
+ all_reshaped_hidden_states = None
+ if output_hidden_states:
+ # Prepend the stem: hidden_states is the patch embedding output (B, N, C),
+ # reshape it to spatial (B, C, H, W) as the first reshaped hidden state.
+ batch_size, _, hidden_size = hidden_states.shape
+ stem_spatial = (
+ hidden_states.view(batch_size, *input_dimensions, hidden_size).permute(0, 3, 1, 2).contiguous()
+ )
+ all_reshaped_hidden_states = (stem_spatial,)
+
+ for layer_module in self.layers:
+ hidden_states, reshaped_hidden_state, _ = layer_module(
+ hidden_states,
+ input_dimensions,
+ always_partition=always_partition,
+ output_hidden_states_before_downsampling=output_hidden_states_before_downsampling,
+ **kwargs,
+ )
+ if output_hidden_states:
+ all_reshaped_hidden_states += (reshaped_hidden_state,)
+ if layer_module.downsample is not None:
+ input_dimensions = ((input_dimensions[0] + 1) // 2, (input_dimensions[1] + 1) // 2)
+
+ return SwinEncoderOutput(
+ last_hidden_state=hidden_states,
+ reshaped_hidden_states=all_reshaped_hidden_states,
+ )
+
+
+@auto_docstring
+class SwinModel(SwinPreTrainedModel):
+ def __init__(self, config, add_pooling_layer=True, use_mask_token=False):
+ r"""
+ add_pooling_layer (`bool`, *optional*, defaults to `True`):
+ Whether or not to apply pooling layer.
+ use_mask_token (`bool`, *optional*, defaults to `False`):
+ Whether or not to create and apply mask tokens in the embedding layer.
+ """
+ super().__init__(config)
+ self.config = config
+ self.num_layers = len(config.depths)
+ self.num_features = int(config.embed_dim * 2 ** (self.num_layers - 1))
+
+ self.embeddings = SwinEmbeddings(config, use_mask_token=use_mask_token)
+ self.encoder = SwinEncoder(config, self.embeddings.patch_grid)
+
+ self.layernorm = nn.LayerNorm(self.num_features, eps=config.layer_norm_eps)
+ self.pooler = nn.AdaptiveAvgPool1d(1) if add_pooling_layer else None
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SwinModelOutput:
+ r"""
+ bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`, *optional*):
+ Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).
+ """
+ # FIXME: output_hidden_states must be popped manually here because SwinEncoder takes it as an
+ # explicit argument (not via **kwargs), so it is not captured by the @capture_outputs decorator.
+ output_hidden_states = kwargs.pop("output_hidden_states", self.config.output_hidden_states)
+
+ embedding_output, input_dimensions = self.embeddings(
+ pixel_values, bool_masked_pos=bool_masked_pos, interpolate_pos_encoding=interpolate_pos_encoding
+ )
+
+ encoder_outputs = self.encoder(
+ embedding_output,
+ input_dimensions,
+ output_hidden_states=output_hidden_states,
+ **kwargs,
+ )
+
+ sequence_output = encoder_outputs.last_hidden_state
+ sequence_output = self.layernorm(sequence_output)
+
+ pooled_output = None
+ if self.pooler is not None:
+ pooled_output = self.pooler(sequence_output.transpose(1, 2))
+ pooled_output = torch.flatten(pooled_output, 1)
+
+ return SwinModelOutput(
+ last_hidden_state=sequence_output,
+ pooler_output=pooled_output,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ reshaped_hidden_states=encoder_outputs.reshaped_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin Model with a decoder on top for masked image modeling, as proposed in [SimMIM](https://huggingface.co/papers/2111.09886).
+
+ <Tip>
+
+ Note that we provide a script to pre-train this model on custom data in our [examples
+ directory](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-pretraining).
+
+ </Tip>
+ """
+)
+class SwinForMaskedImageModeling(SwinPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.swin = SwinModel(config, add_pooling_layer=False, use_mask_token=True)
+
+ num_features = int(config.embed_dim * 2 ** (config.num_layers - 1))
+ self.decoder = nn.Sequential(
+ nn.Conv2d(
+ in_channels=num_features, out_channels=config.encoder_stride**2 * config.num_channels, kernel_size=1
+ ),
+ nn.PixelShuffle(config.encoder_stride),
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SwinMaskedImageModelingOutput:
+ r"""
+ bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`):
+ Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).
+
+ Examples:
+ ```python
+ >>> from transformers import AutoImageProcessor, SwinForMaskedImageModeling
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swin-base-simmim-window6-192")
+ >>> model = SwinForMaskedImageModeling.from_pretrained("microsoft/swin-base-simmim-window6-192")
+
+ >>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
+ >>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
+ >>> # create random boolean mask of shape (batch_size, num_patches)
+ >>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()
+
+ >>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
+ >>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
+ >>> list(reconstructed_pixel_values.shape)
+ [1, 3, 192, 192]
+ ```"""
+ outputs = self.swin(
+ pixel_values,
+ bool_masked_pos=bool_masked_pos,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ **kwargs,
+ )
+
+ sequence_output = outputs.last_hidden_state
+ # Reshape to (batch_size, num_channels, height, width)
+ sequence_output = sequence_output.transpose(1, 2)
+ batch_size, num_channels, sequence_length = sequence_output.shape
+ height = width = math.floor(sequence_length**0.5)
+ sequence_output = sequence_output.reshape(batch_size, num_channels, height, width)
+
+ # Reconstruct pixel values
+ reconstructed_pixel_values = self.decoder(sequence_output)
+
+ masked_im_loss = None
+ if bool_masked_pos is not None:
+ size = self.config.image_size // self.config.patch_size
+ bool_masked_pos = bool_masked_pos.reshape(-1, size, size)
+ mask = (
+ bool_masked_pos.repeat_interleave(self.config.patch_size, 1)
+ .repeat_interleave(self.config.patch_size, 2)
+ .unsqueeze(1)
+ .contiguous()
+ )
+ reconstruction_loss = nn.functional.l1_loss(pixel_values, reconstructed_pixel_values, reduction="none")
+ masked_im_loss = (reconstruction_loss * mask).sum() / (mask.sum() + 1e-5) / self.config.num_channels
+
+ return SwinMaskedImageModelingOutput(
+ loss=masked_im_loss,
+ reconstruction=reconstructed_pixel_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ reshaped_hidden_states=outputs.reshaped_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin Model transformer with an image classification head on top (a linear layer on top of the final hidden state of
+ the [CLS] token) e.g. for ImageNet.
+
+ <Tip>
+
+ Note that it's possible to fine-tune Swin on higher resolution images than the ones it has been trained on, by
+ setting `interpolate_pos_encoding` to `True` in the forward of the model. This will interpolate the pre-trained
+ position embeddings to the higher resolution.
+
+ </Tip>
+ """
+)
+class SwinForImageClassification(SwinPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.num_labels = config.num_labels
+ self.swin = SwinModel(config)
+
+ # Classifier head
+ self.classifier = (
+ nn.Linear(self.swin.num_features, config.num_labels) if config.num_labels > 0 else nn.Identity()
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SwinImageClassifierOutput:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ outputs = self.swin(
+ pixel_values,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ **kwargs,
+ )
+
+ pooled_output = outputs.pooler_output
+
+ logits = self.classifier(pooled_output)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config, **kwargs)
+
+ return SwinImageClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ reshaped_hidden_states=outputs.reshaped_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin backbone, to be used with frameworks like DETR and MaskFormer.
+ """
+)
+class SwinBackbone(BackboneMixin, SwinPreTrainedModel):
+ _keys_to_ignore_on_load_missing = [r"swin.layernorm.*"]
+
+ def __init__(self, config: SwinConfig):
+ super().__init__(config)
+
+ self.num_features = [config.embed_dim] + [int(config.embed_dim * 2**i) for i in range(len(config.depths))]
+ self.swin = SwinModel(config, add_pooling_layer=False)
+
+ # Add layer norms to hidden states of out_features
+ hidden_states_norms = {}
+ for stage, num_channels in zip(self.out_features, self.channels):
+ hidden_states_norms[stage] = nn.LayerNorm(num_channels)
+ self.hidden_states_norms = nn.ModuleDict(hidden_states_norms)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @filter_output_hidden_states
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BackboneOutput:
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, AutoBackbone
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> processor = AutoImageProcessor.from_pretrained("shi-labs/nat-mini-in1k-224")
+ >>> model = AutoBackbone.from_pretrained(
+ ... "microsoft/swin-tiny-patch4-window7-224", out_features=["stage1", "stage2", "stage3", "stage4"]
+ ... )
+
+ >>> inputs = processor(image, return_tensors="pt")
+ >>> outputs = model(**inputs)
+ >>> feature_maps = outputs.feature_maps
+ >>> list(feature_maps[-1].shape)
+ [1, 768, 7, 7]
+ ```
+ """
+ kwargs["output_hidden_states"] = True # required to extract layers for the stages
+ # always_partition=True preserves shifted-window attention at all resolutions.
+ # output_hidden_states_before_downsampling=True captures pre-downsampling feature maps per stage.
+ outputs = self.swin(
+ pixel_values,
+ always_partition=True,
+ output_hidden_states_before_downsampling=True,
+ **kwargs,
+ )
+
+ feature_maps = ()
+ for stage, hidden_state in zip(self.stage_names, outputs.reshaped_hidden_states):
+ if stage in self.out_features:
+ batch_size, num_channels, height, width = hidden_state.shape
+ hidden_state = hidden_state.permute(0, 2, 3, 1).contiguous()
+ hidden_state = hidden_state.view(batch_size, height * width, num_channels)
+ hidden_state = self.hidden_states_norms[stage](hidden_state)
+ hidden_state = hidden_state.view(batch_size, height, width, num_channels)
+ hidden_state = hidden_state.permute(0, 3, 1, 2).contiguous()
+ feature_maps += (hidden_state,)
+
+ return BackboneOutput(
+ feature_maps=feature_maps,
+ hidden_states=outputs.reshaped_hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "SwinForImageClassification",
+ "SwinForMaskedImageModeling",
+ "SwinModel",
+ "SwinPreTrainedModel",
+ "SwinBackbone",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/swin/modular_swin.py b/lib/python3.11/site-packages/transformers/models/swin/modular_swin.py
new file mode 100644
index 0000000000000000000000000000000000000000..94325cd8ae06b15e250c1f9361e8c97efc250dd5
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swin/modular_swin.py
@@ -0,0 +1,1122 @@
+# Copyright 2022 Microsoft Research and The HuggingFace Inc. 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.
+"""PyTorch Swin Transformer model."""
+
+import collections.abc
+import math
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...backbone_utils import BackboneMixin, filter_output_hidden_states
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BackboneOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS
+from ...processing_utils import Unpack
+from ...utils import ModelOutput, TransformersKwargs, auto_docstring, logging, torch_int
+from ...utils.generic import can_return_tuple, merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from ..vit.modeling_vit import (
+ PreTrainedModel,
+ ViTAttention,
+ ViTLayer,
+ ViTMLP,
+ ViTPreTrainedModel,
+ eager_attention_forward,
+)
+from .configuration_swin import SwinConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+class SwinDropPath(nn.Module):
+ """Stochastic depth (DropPath) per sample, for residual blocks.
+
+ Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
+ <https://arxiv.org/abs/1603.09382>`_.
+ """
+
+ def __init__(self, drop_prob: float = 0.0) -> None:
+ super().__init__()
+ self.drop_prob = drop_prob
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ if self.drop_prob == 0.0 or not self.training:
+ return hidden_states
+ keep_prob = 1 - self.drop_prob
+ shape = (hidden_states.shape[0],) + (1,) * (hidden_states.ndim - 1)
+ random_tensor = torch.rand(shape, dtype=hidden_states.dtype, device=hidden_states.device)
+ random_tensor = torch.floor(random_tensor + keep_prob)
+ return hidden_states.div(keep_prob) * random_tensor
+
+ def extra_repr(self) -> str:
+ return f"p={self.drop_prob}"
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin encoder's outputs, with potential hidden states and attentions.
+ """
+)
+@dataclass
+class SwinEncoderOutput(ModelOutput):
+ r"""
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin model's outputs that also contains a pooling of the last hidden states.
+ """
+)
+@dataclass
+class SwinModelOutput(ModelOutput):
+ r"""
+ pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`, *optional*, returned when `add_pooling_layer=True` is passed):
+ Average pooling of the last layer hidden-state.
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ last_hidden_state: torch.FloatTensor | None = None
+ pooler_output: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin masked image model outputs.
+ """
+)
+@dataclass
+class SwinMaskedImageModelingOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `bool_masked_pos` is provided):
+ Masked image modeling (MLM) loss.
+ reconstruction (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+ Reconstructed pixel values.
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ loss: torch.FloatTensor | None = None
+ reconstruction: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin outputs for image classification.
+ """
+)
+@dataclass
+class SwinImageClassifierOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+ Classification (or regression if config.num_labels==1) loss.
+ logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
+ Classification (or regression if config.num_labels==1) scores (before SoftMax).
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+def window_partition(input_feature, window_size):
+ """
+ Partitions the given input into windows.
+ """
+ batch_size, height, width, num_channels = input_feature.shape
+ input_feature = input_feature.view(
+ batch_size, height // window_size, window_size, width // window_size, window_size, num_channels
+ )
+ windows = input_feature.transpose(2, 3).contiguous().view(-1, window_size, window_size, num_channels)
+ return windows
+
+
+def window_reverse(windows, window_size, height, width):
+ """
+ Merges windows to produce higher resolution features.
+ """
+ num_channels = windows.shape[-1]
+ windows = windows.view(-1, height // window_size, width // window_size, window_size, window_size, num_channels)
+ windows = windows.transpose(2, 3).contiguous().view(-1, height, width, num_channels)
+ return windows
+
+
+class SwinEmbeddings(nn.Module):
+ """
+ Construct the patch and position embeddings. Optionally, also the mask token.
+ """
+
+ def __init__(self, config, use_mask_token=False):
+ super().__init__()
+
+ self.patch_embeddings = SwinPatchEmbeddings(config)
+ num_patches = self.patch_embeddings.num_patches
+ self.patch_grid = self.patch_embeddings.grid_size
+ self.mask_token = nn.Parameter(torch.zeros(1, 1, config.embed_dim)) if use_mask_token else None
+
+ self.position_embeddings = (
+ nn.Parameter(torch.zeros(1, num_patches, config.embed_dim)) if config.use_absolute_embeddings else None
+ )
+
+ self.norm = nn.LayerNorm(config.embed_dim)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+ self.patch_size = config.patch_size
+ self.config = config
+
+ def interpolate_pos_encoding(self, embeddings: torch.Tensor, height: int, width: int) -> torch.Tensor:
+ """
+ Interpolate pre-trained position encodings to support higher-resolution images at inference.
+ Unlike ViT, Swin has no CLS token, so position embeddings cover patch positions only.
+ """
+ num_patches = embeddings.shape[1]
+ num_positions = self.position_embeddings.shape[1]
+
+ # always interpolate when tracing to ensure the exported model works for dynamic input shapes
+ if not torch.jit.is_tracing() and num_patches == num_positions and height == width:
+ return self.position_embeddings
+
+ dim = embeddings.shape[-1]
+
+ new_height = height // self.patch_size
+ new_width = width // self.patch_size
+
+ sqrt_num_positions = torch_int(num_positions**0.5)
+ patch_pos_embed = self.position_embeddings.reshape(1, sqrt_num_positions, sqrt_num_positions, dim)
+ patch_pos_embed = patch_pos_embed.permute(0, 3, 1, 2)
+
+ patch_pos_embed = nn.functional.interpolate(
+ patch_pos_embed,
+ size=(new_height, new_width),
+ mode="bicubic",
+ align_corners=False,
+ )
+
+ return patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ ) -> tuple[torch.Tensor]:
+ _, num_channels, height, width = pixel_values.shape
+ embeddings, output_dimensions = self.patch_embeddings(pixel_values)
+ embeddings = self.norm(embeddings)
+ batch_size, seq_len, _ = embeddings.size()
+
+ if bool_masked_pos is not None:
+ mask_tokens = self.mask_token.expand(batch_size, seq_len, -1)
+ # replace the masked visual tokens by mask_tokens
+ mask = bool_masked_pos.unsqueeze(-1).type_as(mask_tokens)
+ embeddings = embeddings * (1.0 - mask) + mask_tokens * mask
+
+ if self.position_embeddings is not None:
+ if interpolate_pos_encoding:
+ embeddings = embeddings + self.interpolate_pos_encoding(embeddings, height, width)
+ else:
+ embeddings = embeddings + self.position_embeddings
+
+ embeddings = self.dropout(embeddings)
+
+ return embeddings, output_dimensions
+
+
+class SwinPatchEmbeddings(nn.Module):
+ """
+ This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
+ `hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
+ Transformer.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ image_size, patch_size = config.image_size, config.patch_size
+ num_channels, hidden_size = config.num_channels, config.embed_dim
+ image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+ num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
+ self.patch_size = patch_size
+ self.num_patches = num_patches
+ self.grid_size = (image_size[0] // patch_size[0], image_size[1] // patch_size[1])
+
+ self.projection = nn.Conv2d(num_channels, hidden_size, kernel_size=patch_size, stride=patch_size)
+
+ def maybe_pad(self, pixel_values, height, width):
+ """Pad pixel_values to be divisible by patch_size if needed."""
+ if width % self.patch_size[1] != 0:
+ pad_values = (0, self.patch_size[1] - width % self.patch_size[1])
+ pixel_values = nn.functional.pad(pixel_values, pad_values)
+ if height % self.patch_size[0] != 0:
+ pad_values = (0, 0, 0, self.patch_size[0] - height % self.patch_size[0])
+ pixel_values = nn.functional.pad(pixel_values, pad_values)
+ return pixel_values
+
+ def forward(self, pixel_values: torch.FloatTensor | None) -> tuple[torch.Tensor, tuple[int]]:
+ _, num_channels, height, width = pixel_values.shape
+ # pad the input to be divisible by self.patch_size, if needed
+ pixel_values = self.maybe_pad(pixel_values, height, width)
+ embeddings = self.projection(pixel_values)
+ _, _, height, width = embeddings.shape
+ output_dimensions = (height, width)
+ embeddings = embeddings.flatten(2).transpose(1, 2)
+
+ return embeddings, output_dimensions
+
+
+class SwinPatchMerging(nn.Module):
+ """
+ Patch Merging Layer.
+
+ Args:
+ dim (`int`):
+ Number of input channels.
+ """
+
+ def __init__(self, dim: int) -> None:
+ super().__init__()
+ self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+ self.norm = nn.LayerNorm(4 * dim)
+
+ def maybe_pad(self, input_feature: torch.Tensor, height: int, width: int) -> torch.Tensor:
+ """Pad input feature map to be divisible by 2 in both spatial dimensions if needed."""
+ if (height % 2 == 1) or (width % 2 == 1):
+ input_feature = nn.functional.pad(input_feature, (0, 0, 0, width % 2, 0, height % 2))
+ return input_feature
+
+ def forward(self, input_feature: torch.Tensor, input_dimensions: tuple[int, int]) -> torch.Tensor:
+ height, width = input_dimensions
+ # `dim` is height * width
+ batch_size, dim, num_channels = input_feature.shape
+
+ input_feature = input_feature.view(batch_size, height, width, num_channels)
+ # pad input to be divisible by width and height, if needed
+ input_feature = self.maybe_pad(input_feature, height, width)
+ # Interleave rows and columns to produce [batch_size, height/2*width/2, 4*num_channels]
+ input_feature = torch.cat(
+ [input_feature[:, row::2, col::2, :] for col in range(2) for row in range(2)], dim=-1
+ )
+ input_feature = input_feature.view(batch_size, -1, 4 * num_channels)
+
+ input_feature = self.norm(input_feature)
+ input_feature = self.reduction(input_feature)
+
+ return input_feature
+
+
+class SwinRelativePositionBias(nn.Module):
+ """
+ Relative position bias for Swin's window-based attention, following the style of BeitRelativePositionBias.
+
+ Unlike BeiT, Swin has no CLS token, so the table covers exactly (2*ws_h-1)*(2*ws_w-1) unique
+ relative positions. The lookup index is purely determined by window_size (static), so it is stored
+ as a non-persistent buffer (recomputed from config on load, never serialised). The table values
+ are learned parameters and must be re-read on every forward call.
+ """
+
+ def __init__(self, num_heads: int, window_size: tuple[int, int]):
+ super().__init__()
+ self.window_size = window_size
+ self.window_area = window_size[0] * window_size[1]
+ self.relative_position_bias_table = nn.Parameter(
+ torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)
+ )
+ # Non-persistent: fully determined by window_size, no need to serialise.
+ # Stored flat so forward avoids an extra .view() call.
+ self.register_buffer(
+ "relative_position_index",
+ self._create_relative_position_index().view(-1),
+ persistent=False,
+ )
+
+ def _create_relative_position_index(self) -> torch.Tensor:
+ coords_h = torch.arange(self.window_size[0])
+ coords_w = torch.arange(self.window_size[1])
+
+ coords = torch.stack(torch.meshgrid([coords_h, coords_w], indexing="ij")) # 2, Wh, Ww
+ coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww
+
+ relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww
+ relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2
+
+ # shift to start from 0 and compute a unique flat index for each (dh, dw) pair
+ relative_coords[:, :, 0] += self.window_size[0] - 1
+ relative_coords[:, :, 1] += self.window_size[1] - 1
+ relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+
+ return relative_coords.sum(-1) # Wh*Ww, Wh*Ww
+
+ def forward(self) -> torch.Tensor:
+ relative_position_bias = self.relative_position_bias_table[self.relative_position_index]
+ relative_position_bias = relative_position_bias.view(self.window_area, self.window_area, -1)
+ return relative_position_bias.permute(2, 0, 1).contiguous().unsqueeze(0) # 1, num_heads, Wh*Ww, Wh*Ww
+
+
+class SwinAttention(ViTAttention):
+ def __init__(self, config: SwinConfig, hidden_size: int, num_attention_heads: int, window_size: int):
+ super().__init__(config)
+ self.num_attention_heads = num_attention_heads
+ self.head_dim = hidden_size // num_attention_heads
+ self.scaling = self.head_dim**-0.5
+
+ self.q_proj = nn.Linear(hidden_size, hidden_size, bias=config.qkv_bias)
+ self.k_proj = nn.Linear(hidden_size, hidden_size, bias=config.qkv_bias)
+ self.v_proj = nn.Linear(hidden_size, hidden_size, bias=config.qkv_bias)
+ self.o_proj = nn.Linear(hidden_size, hidden_size)
+
+ self.relative_position_bias = SwinRelativePositionBias(num_attention_heads, (window_size, window_size))
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ # hidden_states: (batch_size * num_windows, window_size * window_size, channels)
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ # Combine relative position bias with the cyclic-shift attention mask for SW-MSA
+ relative_position_bias = self.relative_position_bias() # 1, num_heads, ws*ws, ws*ws
+ if attention_mask is not None:
+ # attention_mask: (num_windows, ws*ws, ws*ws)
+ num_windows = attention_mask.shape[0]
+ batch_size = input_shape[0] // num_windows
+ seq_len = input_shape[1]
+ # Expand to (batch * num_windows, 1, ws*ws, ws*ws) for broadcasting
+ attention_mask = (
+ attention_mask.unsqueeze(1) # (num_windows, 1, ws*ws, ws*ws)
+ .unsqueeze(0) # (1, num_windows, 1, ws*ws, ws*ws)
+ .expand(batch_size, -1, -1, -1, -1) # (batch, num_windows, 1, ws*ws, ws*ws)
+ .reshape(-1, 1, seq_len, seq_len) # (batch * num_windows, 1, ws*ws, ws*ws)
+ )
+ combined_mask = relative_position_bias + attention_mask
+ else:
+ combined_mask = relative_position_bias
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ combined_mask,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ scaling=self.scaling,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+class SwinMLP(ViTMLP):
+ def __init__(self, config: SwinConfig, dim: int):
+ nn.Module.__init__(self)
+ self.activation_fn = ACT2FN[config.hidden_act]
+ self.fc1 = nn.Linear(dim, int(config.mlp_ratio * dim))
+ self.fc2 = nn.Linear(int(config.mlp_ratio * dim), dim)
+
+
+class SwinLayer(ViTLayer):
+ def __init__(
+ self,
+ config: SwinConfig,
+ dim: int,
+ input_resolution: tuple[int, int],
+ num_heads: int,
+ drop_path_rate: float = 0.0,
+ shift_size: int = 0,
+ ):
+ super().__init__()
+ self.window_size = config.window_size
+ self.attention = SwinAttention(config, dim, num_heads, window_size=config.window_size)
+ self.layernorm_before = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+ self.layernorm_after = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+ self.mlp = SwinMLP(config, dim)
+ self.shift_size = shift_size
+ self.input_resolution = input_resolution
+ self.drop_path = SwinDropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity()
+
+ def set_shift_and_window_size(self, input_resolution: tuple[int, int]) -> None:
+ """Clamp window and shift sizes when the window is larger than the input resolution."""
+ if min(input_resolution) <= self.window_size:
+ self.shift_size = torch_int(0)
+ self.window_size = (
+ torch.min(torch.tensor(input_resolution)) if torch.jit.is_tracing() else min(input_resolution)
+ )
+
+ def get_attn_mask(self, height: int, width: int, dtype: torch.dtype, device: torch.device) -> torch.Tensor | None:
+ """Build the cyclic-shift attention mask for shifted-window MSA; returns None when shift_size is 0."""
+ if self.shift_size > 0:
+ img_mask = torch.zeros((1, height, width, 1), dtype=dtype, device=device)
+ height_slices = (
+ slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None),
+ )
+ width_slices = (
+ slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None),
+ )
+ count = 0
+ for height_slice in height_slices:
+ for width_slice in width_slices:
+ img_mask[:, height_slice, width_slice, :] = count
+ count += 1
+
+ mask_windows = window_partition(img_mask, self.window_size)
+ mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+ attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+ attn_mask = attn_mask.masked_fill(attn_mask != 0, -100.0).masked_fill(attn_mask == 0, 0.0)
+ else:
+ attn_mask = None
+ return attn_mask
+
+ def maybe_pad(self, hidden_states: torch.Tensor, height: int, width: int) -> tuple[torch.Tensor, tuple[int, ...]]:
+ """Pad feature map so both spatial dimensions are divisible by window_size."""
+ pad_right = (self.window_size - width % self.window_size) % self.window_size
+ pad_bottom = (self.window_size - height % self.window_size) % self.window_size
+ pad_values = (0, 0, 0, pad_right, 0, pad_bottom)
+ hidden_states = nn.functional.pad(hidden_states, pad_values)
+ return hidden_states, pad_values
+
+ def cyclic_shift(self, hidden_states: torch.Tensor, reverse: bool = False) -> torch.Tensor:
+ """Apply a cyclic shift along the spatial dimensions for shifted-window attention."""
+ if self.shift_size > 0:
+ direction = 1 if reverse else -1
+ hidden_states = torch.roll(
+ hidden_states,
+ shifts=(direction * self.shift_size, direction * self.shift_size),
+ dims=(1, 2),
+ )
+ return hidden_states
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ always_partition: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ if not always_partition:
+ self.set_shift_and_window_size(input_dimensions)
+ height, width = input_dimensions
+ batch_size, _, channels = hidden_states.size()
+ shortcut = hidden_states
+
+ hidden_states = self.layernorm_before(hidden_states)
+ hidden_states = hidden_states.view(batch_size, height, width, channels)
+
+ # pad hidden_states to multiples of window size
+ hidden_states, pad_values = self.maybe_pad(hidden_states, height, width)
+ _, height_pad, width_pad, _ = hidden_states.shape
+
+ hidden_states_windows = window_partition(self.cyclic_shift(hidden_states), self.window_size)
+ hidden_states_windows = hidden_states_windows.view(-1, self.window_size * self.window_size, channels)
+ attn_mask = self.get_attn_mask(
+ height_pad, width_pad, dtype=hidden_states.dtype, device=hidden_states_windows.device
+ )
+
+ attention_output, attn_weights = self.attention(hidden_states_windows, attn_mask, **kwargs)
+ attention_output = self.dropout(attention_output)
+
+ attention_windows = attention_output.view(-1, self.window_size, self.window_size, channels)
+ attention_windows = self.cyclic_shift(
+ window_reverse(attention_windows, self.window_size, height_pad, width_pad), reverse=True
+ )
+
+ if pad_values[3] > 0 or pad_values[5] > 0:
+ attention_windows = attention_windows[:, :height, :width, :].contiguous()
+
+ attention_windows = attention_windows.view(batch_size, height * width, channels)
+ hidden_states = shortcut + self.drop_path(attention_windows)
+
+ residual = hidden_states
+ hidden_states = self.layernorm_after(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.dropout(hidden_states) + residual
+
+ return hidden_states, attn_weights
+
+
+class SwinStage(GradientCheckpointingLayer):
+ def __init__(
+ self,
+ config: SwinConfig,
+ dim: int,
+ input_resolution: tuple[int, int],
+ depth: int,
+ num_heads: int,
+ drop_path: list[float],
+ downsample,
+ ):
+ super().__init__()
+ self.config = config
+ self.blocks = nn.ModuleList(
+ [
+ SwinLayer(
+ config=config,
+ dim=dim,
+ input_resolution=input_resolution,
+ num_heads=num_heads,
+ drop_path_rate=drop_path[i],
+ shift_size=0 if (i % 2 == 0) else config.window_size // 2,
+ )
+ for i in range(depth)
+ ]
+ )
+
+ self.downsample = downsample(dim=dim) if downsample is not None else None
+
+ def get_reshaped_hidden_states(
+ self,
+ hidden_states: torch.Tensor,
+ hidden_states_before_downsampling: torch.Tensor,
+ height: int,
+ width: int,
+ output_hidden_states_before_downsampling: bool,
+ ) -> torch.Tensor:
+ """
+ Select the spatial hidden states for this stage and reshape from (B, L, C) to (B, C, H, W).
+
+ The chosen state and its resolution depend on output_hidden_states_before_downsampling:
+ - True → pre-downsampling states at (height, width) — used by the backbone.
+ - False → post-downsampling states at half the resolution (if a downsampler exists).
+ """
+ if output_hidden_states_before_downsampling:
+ spatial_state, h, w = hidden_states_before_downsampling, height, width
+ elif self.downsample is not None:
+ spatial_state, h, w = hidden_states, (height + 1) // 2, (width + 1) // 2
+ else:
+ spatial_state, h, w = hidden_states, height, width
+
+ batch_size, _, hidden_size = spatial_state.shape
+ return spatial_state.view(batch_size, h, w, hidden_size).permute(0, 3, 1, 2).contiguous()
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ always_partition: bool = False,
+ output_hidden_states_before_downsampling: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None]:
+ height, width = input_dimensions
+ last_attn_weights = None
+ for layer_module in self.blocks:
+ hidden_states, last_attn_weights = layer_module(
+ hidden_states, input_dimensions, always_partition=always_partition, **kwargs
+ )
+
+ hidden_states_before_downsampling = hidden_states
+ if self.downsample is not None:
+ hidden_states = self.downsample(hidden_states_before_downsampling, input_dimensions)
+
+ reshaped_hidden_states = self.get_reshaped_hidden_states(
+ hidden_states, hidden_states_before_downsampling, height, width, output_hidden_states_before_downsampling
+ )
+
+ return hidden_states, reshaped_hidden_states, last_attn_weights
+
+
+@auto_docstring
+class SwinPreTrainedModel(ViTPreTrainedModel):
+ config: SwinConfig
+ _no_split_modules = ["SwinStage"]
+ _supports_flash_attn = False
+ _supports_flex_attn = False
+ # relative_position_index is now a non-persistent buffer (recomputed from window_size in __init__).
+ _keys_to_ignore_on_load_unexpected = [
+ r"attention\.self\.relative_position_index",
+ r"attention\.relative_position_bias\.relative_position_index",
+ ]
+ _can_record_outputs = {
+ # capture_initial_hidden_state=True: prepend the embedding input (args[0] of SwinStage 0) so that
+ # hidden_states[0] has the same shape as the patch embeddings (num_patches, embed_dim).
+ "hidden_states": OutputRecorder(SwinStage, index=0, capture_initial_hidden_state=True),
+ # reshaped_hidden_states are collected explicitly by SwinEncoder (per stage) and the stem
+ # is prepended in SwinModel.forward, so they are NOT captured via hooks here.
+ # index=2: SwinStage returns (hidden_states, reshaped_hidden_states, last_attn_weights);
+ # capture the last block's attention weights at index 2, giving one entry per stage.
+ "attentions": OutputRecorder(SwinStage, index=2, capture_initial_hidden_state=False),
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ PreTrainedModel._init_weights(self, module)
+ if isinstance(module, SwinEmbeddings):
+ if module.mask_token is not None:
+ init.zeros_(module.mask_token)
+ if module.position_embeddings is not None:
+ init.zeros_(module.position_embeddings)
+ elif isinstance(module, SwinRelativePositionBias):
+ init.zeros_(module.relative_position_bias_table)
+ init.copy_(module.relative_position_index, module._create_relative_position_index().view(-1))
+
+
+class SwinEncoder(SwinPreTrainedModel):
+ def __init__(self, config: SwinConfig, grid_size: tuple[int, int]):
+ super().__init__(config)
+ self.num_layers = len(config.depths)
+ self.config = config
+ dpr = [config.drop_path_rate * i / max(sum(config.depths) - 1, 1) for i in range(sum(config.depths))]
+ self.layers = nn.ModuleList(
+ [
+ SwinStage(
+ config=config,
+ dim=int(config.embed_dim * 2**layer_idx),
+ input_resolution=(grid_size[0] // (2**layer_idx), grid_size[1] // (2**layer_idx)),
+ depth=config.depths[layer_idx],
+ num_heads=config.num_heads[layer_idx],
+ drop_path=dpr[sum(config.depths[:layer_idx]) : sum(config.depths[: layer_idx + 1])],
+ downsample=SwinPatchMerging if (layer_idx < self.num_layers - 1) else None,
+ )
+ for layer_idx in range(self.num_layers)
+ ]
+ )
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ always_partition: bool = False,
+ output_hidden_states: bool = False,
+ output_hidden_states_before_downsampling: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SwinEncoderOutput:
+ r"""
+ input_dimensions (`tuple[int, int]`):
+ Spatial `(height, width)` of the patch grid entering the encoder.
+ always_partition (`bool`, *optional*, defaults to `False`):
+ If `True`, always apply window partitioning regardless of input resolution.
+ output_hidden_states_before_downsampling (`bool`, *optional*, defaults to `False`):
+ If `True`, `reshaped_hidden_states` contains pre-downsampling feature maps.
+ """
+ all_reshaped_hidden_states = None
+ if output_hidden_states:
+ # Prepend the stem: hidden_states is the patch embedding output (B, N, C),
+ # reshape it to spatial (B, C, H, W) as the first reshaped hidden state.
+ batch_size, _, hidden_size = hidden_states.shape
+ stem_spatial = (
+ hidden_states.view(batch_size, *input_dimensions, hidden_size).permute(0, 3, 1, 2).contiguous()
+ )
+ all_reshaped_hidden_states = (stem_spatial,)
+
+ for layer_module in self.layers:
+ hidden_states, reshaped_hidden_state, _ = layer_module(
+ hidden_states,
+ input_dimensions,
+ always_partition=always_partition,
+ output_hidden_states_before_downsampling=output_hidden_states_before_downsampling,
+ **kwargs,
+ )
+ if output_hidden_states:
+ all_reshaped_hidden_states += (reshaped_hidden_state,)
+ if layer_module.downsample is not None:
+ input_dimensions = ((input_dimensions[0] + 1) // 2, (input_dimensions[1] + 1) // 2)
+
+ return SwinEncoderOutput(
+ last_hidden_state=hidden_states,
+ reshaped_hidden_states=all_reshaped_hidden_states,
+ )
+
+
+@auto_docstring
+class SwinModel(SwinPreTrainedModel):
+ def __init__(self, config, add_pooling_layer=True, use_mask_token=False):
+ r"""
+ add_pooling_layer (`bool`, *optional*, defaults to `True`):
+ Whether or not to apply pooling layer.
+ use_mask_token (`bool`, *optional*, defaults to `False`):
+ Whether or not to create and apply mask tokens in the embedding layer.
+ """
+ super().__init__(config)
+ self.config = config
+ self.num_layers = len(config.depths)
+ self.num_features = int(config.embed_dim * 2 ** (self.num_layers - 1))
+
+ self.embeddings = SwinEmbeddings(config, use_mask_token=use_mask_token)
+ self.encoder = SwinEncoder(config, self.embeddings.patch_grid)
+
+ self.layernorm = nn.LayerNorm(self.num_features, eps=config.layer_norm_eps)
+ self.pooler = nn.AdaptiveAvgPool1d(1) if add_pooling_layer else None
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SwinModelOutput:
+ r"""
+ bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`, *optional*):
+ Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).
+ """
+ # FIXME: output_hidden_states must be popped manually here because SwinEncoder takes it as an
+ # explicit argument (not via **kwargs), so it is not captured by the @capture_outputs decorator.
+ output_hidden_states = kwargs.pop("output_hidden_states", self.config.output_hidden_states)
+
+ embedding_output, input_dimensions = self.embeddings(
+ pixel_values, bool_masked_pos=bool_masked_pos, interpolate_pos_encoding=interpolate_pos_encoding
+ )
+
+ encoder_outputs = self.encoder(
+ embedding_output,
+ input_dimensions,
+ output_hidden_states=output_hidden_states,
+ **kwargs,
+ )
+
+ sequence_output = encoder_outputs.last_hidden_state
+ sequence_output = self.layernorm(sequence_output)
+
+ pooled_output = None
+ if self.pooler is not None:
+ pooled_output = self.pooler(sequence_output.transpose(1, 2))
+ pooled_output = torch.flatten(pooled_output, 1)
+
+ return SwinModelOutput(
+ last_hidden_state=sequence_output,
+ pooler_output=pooled_output,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ reshaped_hidden_states=encoder_outputs.reshaped_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin Model with a decoder on top for masked image modeling, as proposed in [SimMIM](https://huggingface.co/papers/2111.09886).
+
+ <Tip>
+
+ Note that we provide a script to pre-train this model on custom data in our [examples
+ directory](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-pretraining).
+
+ </Tip>
+ """
+)
+class SwinForMaskedImageModeling(SwinPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.swin = SwinModel(config, add_pooling_layer=False, use_mask_token=True)
+
+ num_features = int(config.embed_dim * 2 ** (config.num_layers - 1))
+ self.decoder = nn.Sequential(
+ nn.Conv2d(
+ in_channels=num_features, out_channels=config.encoder_stride**2 * config.num_channels, kernel_size=1
+ ),
+ nn.PixelShuffle(config.encoder_stride),
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SwinMaskedImageModelingOutput:
+ r"""
+ bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`):
+ Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).
+
+ Examples:
+ ```python
+ >>> from transformers import AutoImageProcessor, SwinForMaskedImageModeling
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swin-base-simmim-window6-192")
+ >>> model = SwinForMaskedImageModeling.from_pretrained("microsoft/swin-base-simmim-window6-192")
+
+ >>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
+ >>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
+ >>> # create random boolean mask of shape (batch_size, num_patches)
+ >>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()
+
+ >>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
+ >>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
+ >>> list(reconstructed_pixel_values.shape)
+ [1, 3, 192, 192]
+ ```"""
+ outputs = self.swin(
+ pixel_values,
+ bool_masked_pos=bool_masked_pos,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ **kwargs,
+ )
+
+ sequence_output = outputs.last_hidden_state
+ # Reshape to (batch_size, num_channels, height, width)
+ sequence_output = sequence_output.transpose(1, 2)
+ batch_size, num_channels, sequence_length = sequence_output.shape
+ height = width = math.floor(sequence_length**0.5)
+ sequence_output = sequence_output.reshape(batch_size, num_channels, height, width)
+
+ # Reconstruct pixel values
+ reconstructed_pixel_values = self.decoder(sequence_output)
+
+ masked_im_loss = None
+ if bool_masked_pos is not None:
+ size = self.config.image_size // self.config.patch_size
+ bool_masked_pos = bool_masked_pos.reshape(-1, size, size)
+ mask = (
+ bool_masked_pos.repeat_interleave(self.config.patch_size, 1)
+ .repeat_interleave(self.config.patch_size, 2)
+ .unsqueeze(1)
+ .contiguous()
+ )
+ reconstruction_loss = nn.functional.l1_loss(pixel_values, reconstructed_pixel_values, reduction="none")
+ masked_im_loss = (reconstruction_loss * mask).sum() / (mask.sum() + 1e-5) / self.config.num_channels
+
+ return SwinMaskedImageModelingOutput(
+ loss=masked_im_loss,
+ reconstruction=reconstructed_pixel_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ reshaped_hidden_states=outputs.reshaped_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin Model transformer with an image classification head on top (a linear layer on top of the final hidden state of
+ the [CLS] token) e.g. for ImageNet.
+
+ <Tip>
+
+ Note that it's possible to fine-tune Swin on higher resolution images than the ones it has been trained on, by
+ setting `interpolate_pos_encoding` to `True` in the forward of the model. This will interpolate the pre-trained
+ position embeddings to the higher resolution.
+
+ </Tip>
+ """
+)
+class SwinForImageClassification(SwinPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.num_labels = config.num_labels
+ self.swin = SwinModel(config)
+
+ # Classifier head
+ self.classifier = (
+ nn.Linear(self.swin.num_features, config.num_labels) if config.num_labels > 0 else nn.Identity()
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SwinImageClassifierOutput:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ outputs = self.swin(
+ pixel_values,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ **kwargs,
+ )
+
+ pooled_output = outputs.pooler_output
+
+ logits = self.classifier(pooled_output)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config, **kwargs)
+
+ return SwinImageClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ reshaped_hidden_states=outputs.reshaped_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin backbone, to be used with frameworks like DETR and MaskFormer.
+ """
+)
+class SwinBackbone(BackboneMixin, SwinPreTrainedModel):
+ _keys_to_ignore_on_load_missing = [r"swin.layernorm.*"]
+
+ def __init__(self, config: SwinConfig):
+ super().__init__(config)
+
+ self.num_features = [config.embed_dim] + [int(config.embed_dim * 2**i) for i in range(len(config.depths))]
+ self.swin = SwinModel(config, add_pooling_layer=False)
+
+ # Add layer norms to hidden states of out_features
+ hidden_states_norms = {}
+ for stage, num_channels in zip(self.out_features, self.channels):
+ hidden_states_norms[stage] = nn.LayerNorm(num_channels)
+ self.hidden_states_norms = nn.ModuleDict(hidden_states_norms)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @filter_output_hidden_states
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BackboneOutput:
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, AutoBackbone
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> processor = AutoImageProcessor.from_pretrained("shi-labs/nat-mini-in1k-224")
+ >>> model = AutoBackbone.from_pretrained(
+ ... "microsoft/swin-tiny-patch4-window7-224", out_features=["stage1", "stage2", "stage3", "stage4"]
+ ... )
+
+ >>> inputs = processor(image, return_tensors="pt")
+ >>> outputs = model(**inputs)
+ >>> feature_maps = outputs.feature_maps
+ >>> list(feature_maps[-1].shape)
+ [1, 768, 7, 7]
+ ```
+ """
+ kwargs["output_hidden_states"] = True # required to extract layers for the stages
+ # always_partition=True preserves shifted-window attention at all resolutions.
+ # output_hidden_states_before_downsampling=True captures pre-downsampling feature maps per stage.
+ outputs = self.swin(
+ pixel_values,
+ always_partition=True,
+ output_hidden_states_before_downsampling=True,
+ **kwargs,
+ )
+
+ feature_maps = ()
+ for stage, hidden_state in zip(self.stage_names, outputs.reshaped_hidden_states):
+ if stage in self.out_features:
+ batch_size, num_channels, height, width = hidden_state.shape
+ hidden_state = hidden_state.permute(0, 2, 3, 1).contiguous()
+ hidden_state = hidden_state.view(batch_size, height * width, num_channels)
+ hidden_state = self.hidden_states_norms[stage](hidden_state)
+ hidden_state = hidden_state.view(batch_size, height, width, num_channels)
+ hidden_state = hidden_state.permute(0, 3, 1, 2).contiguous()
+ feature_maps += (hidden_state,)
+
+ return BackboneOutput(
+ feature_maps=feature_maps,
+ hidden_states=outputs.reshaped_hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "SwinForImageClassification",
+ "SwinForMaskedImageModeling",
+ "SwinModel",
+ "SwinPreTrainedModel",
+ "SwinBackbone",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/__init__.py b/lib/python3.11/site-packages/transformers/models/swin2sr/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6505f232548f28283946d57c6a4317f3f83cb36e
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swin2sr/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2024 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_swin2sr import *
+ from .image_processing_pil_swin2sr import *
+ from .image_processing_swin2sr import *
+ from .modeling_swin2sr import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..942c15bf2d187ebc48fb2af8cf604ee99e299142
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/configuration_swin2sr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/configuration_swin2sr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0c0b00e1a0eb45d7982c994a6b4b649562c4ef37
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/configuration_swin2sr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/image_processing_pil_swin2sr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/image_processing_pil_swin2sr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c253969a79af9d71a4348cb7dc804c08a35216a5
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/image_processing_pil_swin2sr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/image_processing_swin2sr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/image_processing_swin2sr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0be6ac048cd39a52dd45f1b22bc16ec233eb5458
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/image_processing_swin2sr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/modeling_swin2sr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/modeling_swin2sr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e8e9ba29d37f89859f7a12c16d4ca2b641d0617
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swin2sr/__pycache__/modeling_swin2sr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/configuration_swin2sr.py b/lib/python3.11/site-packages/transformers/models/swin2sr/configuration_swin2sr.py
new file mode 100644
index 0000000000000000000000000000000000000000..627a37587fd6cc9a0bbbf378d0dd4c1bc75f0c30
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swin2sr/configuration_swin2sr.py
@@ -0,0 +1,95 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""Swin2SR Transformer model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="caidas/swin2sr-classicalsr-x2-64")
+@strict
+class Swin2SRConfig(PreTrainedConfig):
+ r"""
+ num_channels_out (`int`, *optional*, defaults to `num_channels`):
+ The number of output channels. If not set, it will be set to `num_channels`.
+ depths (`list(int)`, *optional*, defaults to `[6, 6, 6, 6, 6, 6]`):
+ Depth of each layer in the Transformer encoder.
+ num_heads (`list(int)`, *optional*, defaults to `[6, 6, 6, 6, 6, 6]`):
+ Number of attention heads in each layer of the Transformer encoder.
+ window_size (`int`, *optional*, defaults to 8):
+ Size of windows.
+ upscale (`int`, *optional*, defaults to 2):
+ The upscale factor for the image. 2/3/4/8 for image super resolution, 1 for denoising and compress artifact
+ reduction
+ img_range (`float`, *optional*, defaults to 1.0):
+ The range of the values of the input image.
+ resi_connection (`str`, *optional*, defaults to `"1conv"`):
+ The convolutional block to use before the residual connection in each stage.
+ upsampler (`str`, *optional*, defaults to `"pixelshuffle"`):
+ The reconstruction reconstruction module. Can be 'pixelshuffle'/'pixelshuffledirect'/'nearest+conv'/None.
+
+ Example:
+
+ ```python
+ >>> from transformers import Swin2SRConfig, Swin2SRModel
+
+ >>> # Initializing a Swin2SR caidas/swin2sr-classicalsr-x2-64 style configuration
+ >>> configuration = Swin2SRConfig()
+
+ >>> # Initializing a model (with random weights) from the caidas/swin2sr-classicalsr-x2-64 style configuration
+ >>> model = Swin2SRModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "swin2sr"
+
+ attribute_map = {
+ "hidden_size": "embed_dim",
+ "num_attention_heads": "num_heads",
+ "num_hidden_layers": "num_layers",
+ }
+
+ image_size: int | list[int] | tuple[int, int] = 64
+ patch_size: int | list[int] | tuple[int, int] = 1
+ num_channels: int = 3
+ num_channels_out: int | None = None
+ embed_dim: int = 180
+ depths: list[int] | tuple[int, ...] = (6, 6, 6, 6, 6, 6)
+ num_heads: list[int] | tuple[int, ...] = (6, 6, 6, 6, 6, 6)
+ window_size: int = 8
+ mlp_ratio: float = 2.0
+ qkv_bias: bool = True
+ hidden_dropout_prob: float | int = 0.0
+ attention_probs_dropout_prob: float | int = 0.0
+ drop_path_rate: float | int = 0.1
+ hidden_act: str = "gelu"
+ use_absolute_embeddings: bool = False
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-5
+ upscale: int = 2
+ img_range: float = 1.0
+ resi_connection: str = "1conv"
+ upsampler: str = "pixelshuffle"
+
+ def __post_init__(self, **kwargs):
+ self.num_channels_out = self.num_channels if self.num_channels_out is None else self.num_channels_out
+ self.num_layers = len(self.depths)
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["Swin2SRConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/image_processing_pil_swin2sr.py b/lib/python3.11/site-packages/transformers/models/swin2sr/image_processing_pil_swin2sr.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b1b5c566a5789257c276dd43dc17e1026665d41
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swin2sr/image_processing_pil_swin2sr.py
@@ -0,0 +1,116 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""Image processor class for Swin2SR."""
+
+import numpy as np
+
+from ...image_processing_backends import PilBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import pad as np_pad
+from ...image_utils import (
+ ChannelDimension,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+# Adapted from transformers.models.swin2sr.image_processing_swin2sr.Swin2SRImageProcessorKwargs
+class Swin2SRImageProcessorKwargs(ImagesKwargs, total=False):
+ """
+ size_divisor (`int`, *optional*, defaults to `self.size_divisor`):
+ The size to make the height and width divisible by when padding.
+ """
+
+ size_divisor: int
+
+
+@auto_docstring
+class Swin2SRImageProcessorPil(PilBackend):
+ """PIL backend for Swin2SR with custom pad."""
+
+ valid_kwargs = Swin2SRImageProcessorKwargs
+
+ do_rescale = True
+ rescale_factor = 1 / 255
+ do_pad = True
+ size_divisor = 8
+
+ def __init__(self, **kwargs: Unpack[Swin2SRImageProcessorKwargs]):
+ # Handle legacy pad_size parameter
+ pad_size = kwargs.pop("pad_size", None)
+ if pad_size is not None:
+ kwargs.setdefault("size_divisor", pad_size)
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(
+ self,
+ images: ImageInput,
+ **kwargs: Unpack[Swin2SRImageProcessorKwargs],
+ ) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def pad(
+ self,
+ image: np.ndarray,
+ pad_size: SizeDict | None,
+ size_divisor: int = 8,
+ **kwargs,
+ ) -> np.ndarray:
+ """Pad image to make height and width divisible by size_divisor using symmetric padding."""
+ height, width = image.shape[-2:]
+ pad_height = (height // size_divisor + 1) * size_divisor - height
+ pad_width = (width // size_divisor + 1) * size_divisor - width
+ return np_pad(
+ image,
+ padding=((0, pad_height), (0, pad_width)),
+ mode="symmetric",
+ data_format=ChannelDimension.FIRST,
+ input_data_format=ChannelDimension.FIRST,
+ )
+
+ def _preprocess(
+ self,
+ images: list[np.ndarray],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | None",
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_pad: bool | None,
+ pad_size: SizeDict | None,
+ return_tensors: str | TensorType | None,
+ size_divisor: int = 8,
+ **kwargs,
+ ) -> BatchFeature:
+ """Custom preprocessing for Swin2SR."""
+ processed_images = []
+ for image in images:
+ if do_rescale:
+ image = self.rescale(image, rescale_factor)
+ if do_pad:
+ image = self.pad(image, pad_size=pad_size, size_divisor=size_divisor)
+ processed_images.append(image)
+ return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+
+__all__ = ["Swin2SRImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/image_processing_swin2sr.py b/lib/python3.11/site-packages/transformers/models/swin2sr/image_processing_swin2sr.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c1a3ce7466f6c4d1f6268098aef20f514c56e0d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swin2sr/image_processing_swin2sr.py
@@ -0,0 +1,112 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""Image processor class for Swin2SR."""
+
+import torch
+from torchvision.transforms.v2 import functional as tvF
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import (
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+class Swin2SRImageProcessorKwargs(ImagesKwargs, total=False):
+ """
+ size_divisor (`int`, *optional*, defaults to `self.size_divisor`):
+ The size to make the height and width divisible by when padding.
+ """
+
+ size_divisor: int
+
+
+@auto_docstring
+class Swin2SRImageProcessor(TorchvisionBackend):
+ """Torchvision backend for Swin2SR with custom pad."""
+
+ valid_kwargs = Swin2SRImageProcessorKwargs
+
+ do_rescale = True
+ rescale_factor = 1 / 255
+ do_pad = True
+ size_divisor = 8
+
+ def __init__(self, **kwargs: Unpack[Swin2SRImageProcessorKwargs]):
+ # Handle legacy pad_size parameter
+ pad_size = kwargs.pop("pad_size", None)
+ if pad_size is not None:
+ kwargs.setdefault("size_divisor", pad_size)
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(
+ self,
+ images: ImageInput,
+ **kwargs: Unpack[Swin2SRImageProcessorKwargs],
+ ) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def pad(
+ self,
+ images: "torch.Tensor",
+ pad_size: SizeDict | None,
+ size_divisor: int = 8,
+ **kwargs,
+ ) -> "torch.Tensor":
+ """Pad images to make height and width divisible by size_divisor using symmetric padding."""
+ height, width = images.shape[-2:]
+ pad_height = (height // size_divisor + 1) * size_divisor - height
+ pad_width = (width // size_divisor + 1) * size_divisor - width
+ return tvF.pad(images, (0, 0, pad_width, pad_height), padding_mode="symmetric")
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_pad: bool | None,
+ pad_size: SizeDict | None,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ size_divisor: int = 8,
+ **kwargs,
+ ) -> BatchFeature:
+ """Custom preprocessing for Swin2SR."""
+ grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+ processed_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_rescale:
+ stacked_images = self.rescale(stacked_images, rescale_factor)
+ if do_pad:
+ stacked_images = self.pad(stacked_images, pad_size=pad_size, size_divisor=size_divisor)
+ processed_images_grouped[shape] = stacked_images
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index)
+ return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+
+__all__ = ["Swin2SRImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/swin2sr/modeling_swin2sr.py b/lib/python3.11/site-packages/transformers/models/swin2sr/modeling_swin2sr.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb24adbc2a5d01f1d0fc49e280db54f8cb9526a5
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swin2sr/modeling_swin2sr.py
@@ -0,0 +1,1062 @@
+# Copyright 2022 Microsoft Research and The HuggingFace Inc. 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.
+"""PyTorch Swin2SR Transformer model."""
+
+import collections.abc
+import math
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, ImageSuperResolutionOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import ModelOutput, auto_docstring, logging
+from .configuration_swin2sr import Swin2SRConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin2SR encoder's outputs, with potential hidden states and attentions.
+ """
+)
+@dataclass
+class Swin2SREncoderOutput(ModelOutput):
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+# Copied from transformers.models.swin.modeling_swin.window_partition
+def window_partition(input_feature, window_size):
+ """
+ Partitions the given input into windows.
+ """
+ batch_size, height, width, num_channels = input_feature.shape
+ input_feature = input_feature.view(
+ batch_size, height // window_size, window_size, width // window_size, window_size, num_channels
+ )
+ windows = input_feature.transpose(2, 3).contiguous().view(-1, window_size, window_size, num_channels)
+ return windows
+
+
+# Copied from transformers.models.swin.modeling_swin.window_reverse
+def window_reverse(windows, window_size, height, width):
+ """
+ Merges windows to produce higher resolution features.
+ """
+ num_channels = windows.shape[-1]
+ windows = windows.view(-1, height // window_size, width // window_size, window_size, window_size, num_channels)
+ windows = windows.transpose(2, 3).contiguous().view(-1, height, width, num_channels)
+ return windows
+
+
+class Swin2SREmbeddings(nn.Module):
+ """
+ Construct the patch and optional position embeddings.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+
+ self.patch_embeddings = Swin2SRPatchEmbeddings(config)
+ num_patches = self.patch_embeddings.num_patches
+
+ if config.use_absolute_embeddings:
+ self.position_embeddings = nn.Parameter(torch.zeros(1, num_patches + 1, config.embed_dim))
+ else:
+ self.position_embeddings = None
+
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+ self.window_size = config.window_size
+
+ def forward(self, pixel_values: torch.FloatTensor | None) -> tuple[torch.Tensor]:
+ embeddings, output_dimensions = self.patch_embeddings(pixel_values)
+
+ if self.position_embeddings is not None:
+ embeddings = embeddings + self.position_embeddings
+
+ embeddings = self.dropout(embeddings)
+
+ return embeddings, output_dimensions
+
+
+class Swin2SRPatchEmbeddings(nn.Module):
+ def __init__(self, config, normalize_patches=True):
+ super().__init__()
+ num_channels = config.embed_dim
+ image_size, patch_size = config.image_size, config.patch_size
+
+ image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+ patches_resolution = [image_size[0] // patch_size[0], image_size[1] // patch_size[1]]
+ self.patches_resolution = patches_resolution
+ self.num_patches = patches_resolution[0] * patches_resolution[1]
+
+ self.projection = nn.Conv2d(num_channels, config.embed_dim, kernel_size=patch_size, stride=patch_size)
+ self.layernorm = nn.LayerNorm(config.embed_dim) if normalize_patches else None
+
+ def forward(self, embeddings: torch.FloatTensor | None) -> tuple[torch.Tensor, tuple[int]]:
+ embeddings = self.projection(embeddings)
+ _, _, height, width = embeddings.shape
+ output_dimensions = (height, width)
+ embeddings = embeddings.flatten(2).transpose(1, 2)
+
+ if self.layernorm is not None:
+ embeddings = self.layernorm(embeddings)
+
+ return embeddings, output_dimensions
+
+
+class Swin2SRPatchUnEmbeddings(nn.Module):
+ r"""Image to Patch Unembedding"""
+
+ def __init__(self, config):
+ super().__init__()
+
+ self.embed_dim = config.embed_dim
+
+ def forward(self, embeddings, x_size):
+ batch_size, height_width, num_channels = embeddings.shape
+ embeddings = embeddings.transpose(1, 2).view(batch_size, self.embed_dim, x_size[0], x_size[1]) # B Ph*Pw C
+ return embeddings
+
+
+# Copied from transformers.models.swinv2.modeling_swinv2.Swinv2PatchMerging with Swinv2->Swin2SR
+class Swin2SRPatchMerging(nn.Module):
+ """
+ Patch Merging Layer.
+
+ Args:
+ input_resolution (`tuple[int]`):
+ Resolution of input feature.
+ dim (`int`):
+ Number of input channels.
+ norm_layer (`nn.Module`, *optional*, defaults to `nn.LayerNorm`):
+ Normalization layer class.
+ """
+
+ def __init__(self, input_resolution: tuple[int], dim: int, norm_layer: nn.Module = nn.LayerNorm) -> None:
+ super().__init__()
+ self.input_resolution = input_resolution
+ self.dim = dim
+ self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+ self.norm = norm_layer(2 * dim)
+
+ def maybe_pad(self, input_feature, height, width):
+ should_pad = (height % 2 == 1) or (width % 2 == 1)
+ if should_pad:
+ pad_values = (0, 0, 0, width % 2, 0, height % 2)
+ input_feature = nn.functional.pad(input_feature, pad_values)
+
+ return input_feature
+
+ def forward(self, input_feature: torch.Tensor, input_dimensions: tuple[int, int]) -> torch.Tensor:
+ height, width = input_dimensions
+ # `dim` is height * width
+ batch_size, dim, num_channels = input_feature.shape
+
+ input_feature = input_feature.view(batch_size, height, width, num_channels)
+ # pad input to be divisible by width and height, if needed
+ input_feature = self.maybe_pad(input_feature, height, width)
+ # [batch_size, height/2, width/2, num_channels]
+ input_feature_0 = input_feature[:, 0::2, 0::2, :]
+ # [batch_size, height/2, width/2, num_channels]
+ input_feature_1 = input_feature[:, 1::2, 0::2, :]
+ # [batch_size, height/2, width/2, num_channels]
+ input_feature_2 = input_feature[:, 0::2, 1::2, :]
+ # [batch_size, height/2, width/2, num_channels]
+ input_feature_3 = input_feature[:, 1::2, 1::2, :]
+ # [batch_size, height/2 * width/2, 4*num_channels]
+ input_feature = torch.cat([input_feature_0, input_feature_1, input_feature_2, input_feature_3], -1)
+ input_feature = input_feature.view(batch_size, -1, 4 * num_channels) # [batch_size, height/2 * width/2, 4*C]
+
+ input_feature = self.reduction(input_feature)
+ input_feature = self.norm(input_feature)
+
+ return input_feature
+
+
+# Copied from transformers.models.swinv2.modeling_swinv2.Swinv2SelfAttention with Swinv2->Swin2SR
+class Swin2SRSelfAttention(nn.Module):
+ def __init__(self, config, dim, num_heads, window_size, pretrained_window_size=[0, 0]):
+ super().__init__()
+ if dim % num_heads != 0:
+ raise ValueError(
+ f"The hidden size ({dim}) is not a multiple of the number of attention heads ({num_heads})"
+ )
+
+ self.num_attention_heads = num_heads
+ self.attention_head_size = int(dim / num_heads)
+ self.all_head_size = self.num_attention_heads * self.attention_head_size
+ self.window_size = (
+ window_size if isinstance(window_size, collections.abc.Iterable) else (window_size, window_size)
+ )
+ self.pretrained_window_size = pretrained_window_size
+ self.logit_scale = nn.Parameter(torch.log(10 * torch.ones((num_heads, 1, 1))))
+ # mlp to generate continuous relative position bias
+ self.continuous_position_bias_mlp = nn.Sequential(
+ nn.Linear(2, 512, bias=True), nn.ReLU(inplace=True), nn.Linear(512, num_heads, bias=False)
+ )
+
+ relative_coords_table, relative_position_index = self.create_coords_table_and_index()
+ self.register_buffer("relative_coords_table", relative_coords_table, persistent=False)
+ self.register_buffer("relative_position_index", relative_position_index, persistent=False)
+
+ self.query = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)
+ self.key = nn.Linear(self.all_head_size, self.all_head_size, bias=False)
+ self.value = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)
+ self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor]:
+ batch_size, dim, num_channels = hidden_states.shape
+ query_layer = (
+ self.query(hidden_states)
+ .view(batch_size, -1, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ )
+ key_layer = (
+ self.key(hidden_states)
+ .view(batch_size, -1, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ )
+ value_layer = (
+ self.value(hidden_states)
+ .view(batch_size, -1, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ )
+
+ # cosine attention
+ attention_scores = nn.functional.normalize(query_layer, dim=-1) @ nn.functional.normalize(
+ key_layer, dim=-1
+ ).transpose(-2, -1)
+ logit_scale = torch.clamp(self.logit_scale, max=math.log(1.0 / 0.01)).exp()
+ attention_scores = attention_scores * logit_scale
+ relative_position_bias_table = self.continuous_position_bias_mlp(self.relative_coords_table).view(
+ -1, self.num_attention_heads
+ )
+ # [window_height*window_width,window_height*window_width,num_attention_heads]
+ relative_position_bias = relative_position_bias_table[self.relative_position_index.view(-1)].view(
+ self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1
+ )
+ # [num_attention_heads,window_height*window_width,window_height*window_width]
+ relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww
+ relative_position_bias = 16 * torch.sigmoid(relative_position_bias)
+ attention_scores = attention_scores + relative_position_bias.unsqueeze(0)
+
+ if attention_mask is not None:
+ # Apply the attention mask is (precomputed for all layers in Swin2SRModel forward() function)
+ mask_shape = attention_mask.shape[0]
+ attention_scores = attention_scores.view(
+ batch_size // mask_shape, mask_shape, self.num_attention_heads, dim, dim
+ ) + attention_mask.unsqueeze(1).unsqueeze(0)
+ attention_scores = attention_scores + attention_mask.unsqueeze(1).unsqueeze(0)
+ attention_scores = attention_scores.view(-1, self.num_attention_heads, dim, dim)
+
+ # Normalize the attention scores to probabilities.
+ attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+ # This is actually dropping out entire tokens to attend to, which might
+ # seem a bit unusual, but is taken from the original Transformer paper.
+ attention_probs = self.dropout(attention_probs)
+
+ # Mask heads if we want to
+
+ context_layer = torch.matmul(attention_probs, value_layer)
+ context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+ new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+ context_layer = context_layer.view(new_context_layer_shape)
+
+ outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+ return outputs
+
+ def create_coords_table_and_index(self):
+ # get relative_coords_table
+ relative_coords_h = torch.arange(-(self.window_size[0] - 1), self.window_size[0], dtype=torch.int64).float()
+ relative_coords_w = torch.arange(-(self.window_size[1] - 1), self.window_size[1], dtype=torch.int64).float()
+ relative_coords_table = (
+ torch.stack(torch.meshgrid([relative_coords_h, relative_coords_w], indexing="ij"))
+ .permute(1, 2, 0)
+ .contiguous()
+ .unsqueeze(0)
+ ) # [1, 2*window_height - 1, 2*window_width - 1, 2]
+ if self.pretrained_window_size[0] > 0:
+ relative_coords_table[:, :, :, 0] /= self.pretrained_window_size[0] - 1
+ relative_coords_table[:, :, :, 1] /= self.pretrained_window_size[1] - 1
+ elif self.window_size[0] > 1:
+ relative_coords_table[:, :, :, 0] /= self.window_size[0] - 1
+ relative_coords_table[:, :, :, 1] /= self.window_size[1] - 1
+ relative_coords_table *= 8 # normalize to -8, 8
+ relative_coords_table = (
+ torch.sign(relative_coords_table) * torch.log2(torch.abs(relative_coords_table) + 1.0) / math.log2(8)
+ )
+ # set to same dtype as mlp weight
+ relative_coords_table = relative_coords_table.to(next(self.continuous_position_bias_mlp.parameters()).dtype)
+
+ # get pair-wise relative position index for each token inside the window
+ coords_h = torch.arange(self.window_size[0])
+ coords_w = torch.arange(self.window_size[1])
+ coords = torch.stack(torch.meshgrid([coords_h, coords_w], indexing="ij"))
+ coords_flatten = torch.flatten(coords, 1)
+ relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]
+ relative_coords = relative_coords.permute(1, 2, 0).contiguous()
+ relative_coords[:, :, 0] += self.window_size[0] - 1
+ relative_coords[:, :, 1] += self.window_size[1] - 1
+ relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+ relative_position_index = relative_coords.sum(-1)
+
+ return relative_coords_table, relative_position_index
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinSelfOutput with Swin->Swin2SR
+class Swin2SRSelfOutput(nn.Module):
+ def __init__(self, config, dim):
+ super().__init__()
+ self.dense = nn.Linear(dim, dim)
+ self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ return hidden_states
+
+
+# Copied from transformers.models.swinv2.modeling_swinv2.Swinv2Attention with Swinv2->Swin2SR
+class Swin2SRAttention(nn.Module):
+ def __init__(self, config, dim, num_heads, window_size, pretrained_window_size=0):
+ super().__init__()
+ self.self = Swin2SRSelfAttention(
+ config=config,
+ dim=dim,
+ num_heads=num_heads,
+ window_size=window_size,
+ pretrained_window_size=pretrained_window_size
+ if isinstance(pretrained_window_size, collections.abc.Iterable)
+ else (pretrained_window_size, pretrained_window_size),
+ )
+ self.output = Swin2SRSelfOutput(config, dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor]:
+ self_outputs = self.self(hidden_states, attention_mask, output_attentions)
+ attention_output = self.output(self_outputs[0], hidden_states)
+ outputs = (attention_output,) + self_outputs[1:] # add attentions if we output them
+ return outputs
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinIntermediate with Swin->Swin2SR
+class Swin2SRIntermediate(nn.Module):
+ def __init__(self, config, dim):
+ super().__init__()
+ self.dense = nn.Linear(dim, int(config.mlp_ratio * dim))
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ return hidden_states
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinOutput with Swin->Swin2SR
+class Swin2SROutput(nn.Module):
+ def __init__(self, config, dim):
+ super().__init__()
+ self.dense = nn.Linear(int(config.mlp_ratio * dim), dim)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.swin.modular_swin.SwinDropPath with SwinDropPath->Swin2SRDropPath
+class Swin2SRDropPath(nn.Module):
+ """Stochastic depth (DropPath) per sample, for residual blocks.
+
+ Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
+ <https://arxiv.org/abs/1603.09382>`_.
+ """
+
+ def __init__(self, drop_prob: float = 0.0) -> None:
+ super().__init__()
+ self.drop_prob = drop_prob
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ if self.drop_prob == 0.0 or not self.training:
+ return hidden_states
+ keep_prob = 1 - self.drop_prob
+ shape = (hidden_states.shape[0],) + (1,) * (hidden_states.ndim - 1)
+ random_tensor = torch.rand(shape, dtype=hidden_states.dtype, device=hidden_states.device)
+ random_tensor = torch.floor(random_tensor + keep_prob)
+ return hidden_states.div(keep_prob) * random_tensor
+
+ def extra_repr(self) -> str:
+ return f"p={self.drop_prob}"
+
+
+# Copied from transformers.models.swinv2.modeling_swinv2.Swinv2Layer with Swinv2->Swin2SR
+class Swin2SRLayer(nn.Module):
+ def __init__(
+ self, config, dim, input_resolution, num_heads, drop_path_rate=0.0, shift_size=0, pretrained_window_size=0
+ ):
+ super().__init__()
+ self.input_resolution = input_resolution
+ window_size, shift_size = self._compute_window_shift(
+ (config.window_size, config.window_size), (shift_size, shift_size)
+ )
+ self.window_size = window_size[0]
+ self.shift_size = shift_size[0]
+ self.attention = Swin2SRAttention(
+ config=config,
+ dim=dim,
+ num_heads=num_heads,
+ window_size=self.window_size,
+ pretrained_window_size=pretrained_window_size
+ if isinstance(pretrained_window_size, collections.abc.Iterable)
+ else (pretrained_window_size, pretrained_window_size),
+ )
+ self.layernorm_before = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+ self.drop_path = Swin2SRDropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity()
+ self.intermediate = Swin2SRIntermediate(config, dim)
+ self.output = Swin2SROutput(config, dim)
+ self.layernorm_after = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+
+ def _compute_window_shift(self, target_window_size, target_shift_size) -> tuple[tuple[int, int], tuple[int, int]]:
+ window_size = [min(r, w) for r, w in zip(self.input_resolution, target_window_size)]
+ shift_size = [0 if r <= w else s for r, w, s in zip(self.input_resolution, window_size, target_shift_size)]
+ return window_size, shift_size
+
+ def get_attn_mask(self, height, width, dtype):
+ if self.shift_size > 0:
+ # calculate attention mask for shifted window multihead self attention
+ img_mask = torch.zeros((1, height, width, 1), dtype=dtype)
+ height_slices = (
+ slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None),
+ )
+ width_slices = (
+ slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None),
+ )
+ count = 0
+ for height_slice in height_slices:
+ for width_slice in width_slices:
+ img_mask[:, height_slice, width_slice, :] = count
+ count += 1
+
+ mask_windows = window_partition(img_mask, self.window_size)
+ mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+ attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+ attn_mask = attn_mask.masked_fill(attn_mask != 0, -100.0).masked_fill(attn_mask == 0, 0.0)
+ else:
+ attn_mask = None
+ return attn_mask
+
+ def maybe_pad(self, hidden_states, height, width):
+ pad_right = (self.window_size - width % self.window_size) % self.window_size
+ pad_bottom = (self.window_size - height % self.window_size) % self.window_size
+ pad_values = (0, 0, 0, pad_right, 0, pad_bottom)
+ hidden_states = nn.functional.pad(hidden_states, pad_values)
+ return hidden_states, pad_values
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ height, width = input_dimensions
+ batch_size, _, channels = hidden_states.size()
+ shortcut = hidden_states
+
+ # pad hidden_states to multiples of window size
+ hidden_states = hidden_states.view(batch_size, height, width, channels)
+ hidden_states, pad_values = self.maybe_pad(hidden_states, height, width)
+ _, height_pad, width_pad, _ = hidden_states.shape
+ # cyclic shift
+ if self.shift_size > 0:
+ shifted_hidden_states = torch.roll(hidden_states, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
+ else:
+ shifted_hidden_states = hidden_states
+
+ # partition windows
+ hidden_states_windows = window_partition(shifted_hidden_states, self.window_size)
+ hidden_states_windows = hidden_states_windows.view(-1, self.window_size * self.window_size, channels)
+ attn_mask = self.get_attn_mask(height_pad, width_pad, dtype=hidden_states.dtype)
+ if attn_mask is not None:
+ attn_mask = attn_mask.to(hidden_states_windows.device)
+
+ attention_outputs = self.attention(hidden_states_windows, attn_mask, output_attentions=output_attentions)
+
+ attention_output = attention_outputs[0]
+
+ attention_windows = attention_output.view(-1, self.window_size, self.window_size, channels)
+ shifted_windows = window_reverse(attention_windows, self.window_size, height_pad, width_pad)
+
+ # reverse cyclic shift
+ if self.shift_size > 0:
+ attention_windows = torch.roll(shifted_windows, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
+ else:
+ attention_windows = shifted_windows
+
+ was_padded = pad_values[3] > 0 or pad_values[5] > 0
+ if was_padded:
+ attention_windows = attention_windows[:, :height, :width, :].contiguous()
+
+ attention_windows = attention_windows.view(batch_size, height * width, channels)
+ hidden_states = self.layernorm_before(attention_windows)
+ hidden_states = shortcut + self.drop_path(hidden_states)
+
+ layer_output = self.intermediate(hidden_states)
+ layer_output = self.output(layer_output)
+ layer_output = hidden_states + self.drop_path(self.layernorm_after(layer_output))
+
+ layer_outputs = (layer_output, attention_outputs[1]) if output_attentions else (layer_output,)
+ return layer_outputs
+
+
+class Swin2SRStage(GradientCheckpointingLayer):
+ """
+ This corresponds to the Residual Swin Transformer Block (RSTB) in the original implementation.
+ """
+
+ def __init__(self, config, dim, input_resolution, depth, num_heads, drop_path, pretrained_window_size=0):
+ super().__init__()
+ self.config = config
+ self.dim = dim
+ self.layers = nn.ModuleList(
+ [
+ Swin2SRLayer(
+ config=config,
+ dim=dim,
+ input_resolution=input_resolution,
+ num_heads=num_heads,
+ shift_size=0 if (i % 2 == 0) else config.window_size // 2,
+ pretrained_window_size=pretrained_window_size,
+ )
+ for i in range(depth)
+ ]
+ )
+
+ if config.resi_connection == "1conv":
+ self.conv = nn.Conv2d(dim, dim, 3, 1, 1)
+ elif config.resi_connection == "3conv":
+ # to save parameters and memory
+ self.conv = nn.Sequential(
+ nn.Conv2d(dim, dim // 4, 3, 1, 1),
+ nn.LeakyReLU(negative_slope=0.2, inplace=True),
+ nn.Conv2d(dim // 4, dim // 4, 1, 1, 0),
+ nn.LeakyReLU(negative_slope=0.2, inplace=True),
+ nn.Conv2d(dim // 4, dim, 3, 1, 1),
+ )
+
+ self.patch_embed = Swin2SRPatchEmbeddings(config, normalize_patches=False)
+
+ self.patch_unembed = Swin2SRPatchUnEmbeddings(config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor]:
+ residual = hidden_states
+
+ height, width = input_dimensions
+ for i, layer_module in enumerate(self.layers):
+ layer_outputs = layer_module(hidden_states, input_dimensions, output_attentions)
+
+ hidden_states = layer_outputs[0]
+
+ output_dimensions = (height, width, height, width)
+
+ hidden_states = self.patch_unembed(hidden_states, input_dimensions)
+ hidden_states = self.conv(hidden_states)
+ hidden_states, _ = self.patch_embed(hidden_states)
+
+ hidden_states = hidden_states + residual
+
+ stage_outputs = (hidden_states, output_dimensions)
+
+ if output_attentions:
+ stage_outputs += layer_outputs[1:]
+ return stage_outputs
+
+
+class Swin2SREncoder(nn.Module):
+ def __init__(self, config, grid_size):
+ super().__init__()
+ self.num_stages = len(config.depths)
+ self.config = config
+ dpr = [x.item() for x in torch.linspace(0, config.drop_path_rate, sum(config.depths), device="cpu")]
+ self.stages = nn.ModuleList(
+ [
+ Swin2SRStage(
+ config=config,
+ dim=config.embed_dim,
+ input_resolution=(grid_size[0], grid_size[1]),
+ depth=config.depths[stage_idx],
+ num_heads=config.num_heads[stage_idx],
+ drop_path=dpr[sum(config.depths[:stage_idx]) : sum(config.depths[: stage_idx + 1])],
+ pretrained_window_size=0,
+ )
+ for stage_idx in range(self.num_stages)
+ ]
+ )
+
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ output_attentions: bool | None = False,
+ output_hidden_states: bool | None = False,
+ return_dict: bool | None = True,
+ ) -> tuple | Swin2SREncoderOutput:
+ all_input_dimensions = ()
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+
+ for i, stage_module in enumerate(self.stages):
+ layer_outputs = stage_module(hidden_states, input_dimensions, output_attentions)
+
+ hidden_states = layer_outputs[0]
+ output_dimensions = layer_outputs[1]
+
+ input_dimensions = (output_dimensions[-2], output_dimensions[-1])
+ all_input_dimensions += (input_dimensions,)
+
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+
+ if output_attentions:
+ all_self_attentions += layer_outputs[2:]
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+
+ return Swin2SREncoderOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+
+@auto_docstring
+class Swin2SRPreTrainedModel(PreTrainedModel):
+ config: Swin2SRConfig
+ base_model_prefix = "swin2sr"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = True
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ if isinstance(module, (nn.Linear, nn.Conv2d)):
+ init.trunc_normal_(module.weight, std=self.config.initializer_range)
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, nn.LayerNorm):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ elif isinstance(module, Swin2SRSelfAttention):
+ init.constant_(module.logit_scale, math.log(10))
+ relative_coords_table, relative_position_index = module.create_coords_table_and_index()
+ init.copy_(module.relative_coords_table, relative_coords_table)
+ init.copy_(module.relative_position_index, relative_position_index)
+ elif isinstance(module, Swin2SRModel):
+ if module.config.num_channels == 3 and module.config.num_channels_out == 3:
+ mean = torch.tensor([0.4488, 0.4371, 0.4040]).view(1, 3, 1, 1)
+ else:
+ mean = torch.zeros(1, 1, 1, 1)
+ init.copy_(module.mean, mean)
+
+
+@auto_docstring
+class Swin2SRModel(Swin2SRPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.config = config
+
+ if config.num_channels == 3 and config.num_channels_out == 3:
+ mean = torch.tensor([0.4488, 0.4371, 0.4040]).view(1, 3, 1, 1)
+ else:
+ mean = torch.zeros(1, 1, 1, 1)
+ self.register_buffer("mean", mean, persistent=False)
+
+ self.img_range = config.img_range
+
+ self.first_convolution = nn.Conv2d(config.num_channels, config.embed_dim, 3, 1, 1)
+ self.embeddings = Swin2SREmbeddings(config)
+ self.encoder = Swin2SREncoder(config, grid_size=self.embeddings.patch_embeddings.patches_resolution)
+
+ self.layernorm = nn.LayerNorm(config.embed_dim, eps=config.layer_norm_eps)
+ self.patch_unembed = Swin2SRPatchUnEmbeddings(config)
+ self.conv_after_body = nn.Conv2d(config.embed_dim, config.embed_dim, 3, 1, 1)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings.patch_embeddings
+
+ def pad_and_normalize(self, pixel_values):
+ _, _, height, width = pixel_values.size()
+
+ # 1. pad
+ window_size = self.config.window_size
+ modulo_pad_height = (window_size - height % window_size) % window_size
+ modulo_pad_width = (window_size - width % window_size) % window_size
+ pixel_values = nn.functional.pad(pixel_values, (0, modulo_pad_width, 0, modulo_pad_height), "reflect")
+
+ # 2. normalize
+ mean = self.mean.type_as(pixel_values)
+ pixel_values = (pixel_values - mean) * self.img_range
+
+ return pixel_values
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutput:
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ _, _, height, width = pixel_values.shape
+
+ # some preprocessing: padding + normalization
+ pixel_values = self.pad_and_normalize(pixel_values)
+
+ embeddings = self.first_convolution(pixel_values)
+ embedding_output, input_dimensions = self.embeddings(embeddings)
+
+ encoder_outputs = self.encoder(
+ embedding_output,
+ input_dimensions,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = encoder_outputs[0]
+ sequence_output = self.layernorm(sequence_output)
+
+ sequence_output = self.patch_unembed(sequence_output, (height, width))
+ sequence_output = self.conv_after_body(sequence_output) + embeddings
+
+ if not return_dict:
+ output = (sequence_output,) + encoder_outputs[1:]
+
+ return output
+
+ return BaseModelOutput(
+ last_hidden_state=sequence_output,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ )
+
+
+class Upsample(nn.Module):
+ """Upsample module.
+
+ Args:
+ scale (`int`):
+ Scale factor. Supported scales: 2^n and 3.
+ num_features (`int`):
+ Channel number of intermediate features.
+ """
+
+ def __init__(self, scale, num_features):
+ super().__init__()
+
+ self.scale = scale
+ if (scale & (scale - 1)) == 0:
+ # scale = 2^n
+ for i in range(int(math.log2(scale))):
+ self.add_module(f"convolution_{i}", nn.Conv2d(num_features, 4 * num_features, 3, 1, 1))
+ self.add_module(f"pixelshuffle_{i}", nn.PixelShuffle(2))
+ elif scale == 3:
+ self.convolution = nn.Conv2d(num_features, 9 * num_features, 3, 1, 1)
+ self.pixelshuffle = nn.PixelShuffle(3)
+ else:
+ raise ValueError(f"Scale {scale} is not supported. Supported scales: 2^n and 3.")
+
+ def forward(self, hidden_state):
+ if (self.scale & (self.scale - 1)) == 0:
+ for i in range(int(math.log2(self.scale))):
+ hidden_state = self.__getattr__(f"convolution_{i}")(hidden_state)
+ hidden_state = self.__getattr__(f"pixelshuffle_{i}")(hidden_state)
+
+ elif self.scale == 3:
+ hidden_state = self.convolution(hidden_state)
+ hidden_state = self.pixelshuffle(hidden_state)
+
+ return hidden_state
+
+
+class UpsampleOneStep(nn.Module):
+ """UpsampleOneStep module (the difference with Upsample is that it always only has 1conv + 1pixelshuffle)
+
+ Used in lightweight SR to save parameters.
+
+ Args:
+ scale (int):
+ Scale factor. Supported scales: 2^n and 3.
+ in_channels (int):
+ Channel number of intermediate features.
+ out_channels (int):
+ Channel number of output features.
+ """
+
+ def __init__(self, scale, in_channels, out_channels):
+ super().__init__()
+
+ self.conv = nn.Conv2d(in_channels, (scale**2) * out_channels, 3, 1, 1)
+ self.pixel_shuffle = nn.PixelShuffle(scale)
+
+ def forward(self, x):
+ x = self.conv(x)
+ x = self.pixel_shuffle(x)
+
+ return x
+
+
+class PixelShuffleUpsampler(nn.Module):
+ def __init__(self, config, num_features):
+ super().__init__()
+ self.conv_before_upsample = nn.Conv2d(config.embed_dim, num_features, 3, 1, 1)
+ self.activation = nn.LeakyReLU(inplace=True)
+ self.upsample = Upsample(config.upscale, num_features)
+ self.final_convolution = nn.Conv2d(num_features, config.num_channels_out, 3, 1, 1)
+
+ def forward(self, sequence_output):
+ x = self.conv_before_upsample(sequence_output)
+ x = self.activation(x)
+ x = self.upsample(x)
+ x = self.final_convolution(x)
+
+ return x
+
+
+class NearestConvUpsampler(nn.Module):
+ def __init__(self, config, num_features):
+ super().__init__()
+ if config.upscale != 4:
+ raise ValueError("The nearest+conv upsampler only supports an upscale factor of 4 at the moment.")
+
+ self.conv_before_upsample = nn.Conv2d(config.embed_dim, num_features, 3, 1, 1)
+ self.activation = nn.LeakyReLU(inplace=True)
+ self.conv_up1 = nn.Conv2d(num_features, num_features, 3, 1, 1)
+ self.conv_up2 = nn.Conv2d(num_features, num_features, 3, 1, 1)
+ self.conv_hr = nn.Conv2d(num_features, num_features, 3, 1, 1)
+ self.final_convolution = nn.Conv2d(num_features, config.num_channels_out, 3, 1, 1)
+ self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
+
+ def forward(self, sequence_output):
+ sequence_output = self.conv_before_upsample(sequence_output)
+ sequence_output = self.activation(sequence_output)
+ sequence_output = self.lrelu(
+ self.conv_up1(torch.nn.functional.interpolate(sequence_output, scale_factor=2, mode="nearest"))
+ )
+ sequence_output = self.lrelu(
+ self.conv_up2(torch.nn.functional.interpolate(sequence_output, scale_factor=2, mode="nearest"))
+ )
+ reconstruction = self.final_convolution(self.lrelu(self.conv_hr(sequence_output)))
+ return reconstruction
+
+
+class PixelShuffleAuxUpsampler(nn.Module):
+ def __init__(self, config, num_features):
+ super().__init__()
+
+ self.upscale = config.upscale
+ self.conv_bicubic = nn.Conv2d(config.num_channels, num_features, 3, 1, 1)
+ self.conv_before_upsample = nn.Conv2d(config.embed_dim, num_features, 3, 1, 1)
+ self.activation = nn.LeakyReLU(inplace=True)
+ self.conv_aux = nn.Conv2d(num_features, config.num_channels, 3, 1, 1)
+ self.conv_after_aux = nn.Sequential(nn.Conv2d(3, num_features, 3, 1, 1), nn.LeakyReLU(inplace=True))
+ self.upsample = Upsample(config.upscale, num_features)
+ self.final_convolution = nn.Conv2d(num_features, config.num_channels_out, 3, 1, 1)
+
+ def forward(self, sequence_output, bicubic, height, width):
+ bicubic = self.conv_bicubic(bicubic)
+ sequence_output = self.conv_before_upsample(sequence_output)
+ sequence_output = self.activation(sequence_output)
+ aux = self.conv_aux(sequence_output)
+ sequence_output = self.conv_after_aux(aux)
+ sequence_output = (
+ self.upsample(sequence_output)[:, :, : height * self.upscale, : width * self.upscale]
+ + bicubic[:, :, : height * self.upscale, : width * self.upscale]
+ )
+ reconstruction = self.final_convolution(sequence_output)
+
+ return reconstruction, aux
+
+
+@auto_docstring(
+ custom_intro="""
+ Swin2SR Model transformer with an upsampler head on top for image super resolution and restoration.
+ """
+)
+class Swin2SRForImageSuperResolution(Swin2SRPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.swin2sr = Swin2SRModel(config)
+ self.upsampler = config.upsampler
+ self.upscale = config.upscale
+
+ # Upsampler
+ num_features = 64
+ if self.upsampler == "pixelshuffle":
+ self.upsample = PixelShuffleUpsampler(config, num_features)
+ elif self.upsampler == "pixelshuffle_aux":
+ self.upsample = PixelShuffleAuxUpsampler(config, num_features)
+ elif self.upsampler == "pixelshuffledirect":
+ # for lightweight SR (to save parameters)
+ self.upsample = UpsampleOneStep(config.upscale, config.embed_dim, config.num_channels_out)
+ elif self.upsampler == "nearest+conv":
+ # for real-world SR (less artifacts)
+ self.upsample = NearestConvUpsampler(config, num_features)
+ else:
+ # for image denoising and JPEG compression artifact reduction
+ self.final_convolution = nn.Conv2d(config.embed_dim, config.num_channels_out, 3, 1, 1)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | ImageSuperResolutionOutput:
+ r"""
+ Example:
+ ```python
+ >>> import torch
+ >>> import numpy as np
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> from transformers import AutoImageProcessor, Swin2SRForImageSuperResolution
+
+ >>> processor = AutoImageProcessor.from_pretrained("caidas/swin2SR-classical-sr-x2-64")
+ >>> model = Swin2SRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64")
+
+ >>> url = "https://huggingface.co/spaces/jjourney1125/swin2sr/resolve/main/samples/butterfly.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+ >>> # prepare image for the model
+ >>> inputs = processor(image, return_tensors="pt")
+
+ >>> # forward pass
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> output = outputs.reconstruction.data.squeeze().float().cpu().clamp_(0, 1).numpy()
+ >>> output = np.moveaxis(output, source=0, destination=-1)
+ >>> output = (output * 255.0).round().astype(np.uint8) # float32 to uint8
+ >>> # you can visualize `output` with `Image.fromarray`
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ loss = None
+ if labels is not None:
+ raise NotImplementedError("Training is not supported at the moment")
+
+ height, width = pixel_values.shape[2:]
+
+ if self.config.upsampler == "pixelshuffle_aux":
+ bicubic = nn.functional.interpolate(
+ pixel_values,
+ size=(height * self.upscale, width * self.upscale),
+ mode="bicubic",
+ align_corners=False,
+ )
+
+ outputs = self.swin2sr(
+ pixel_values,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = outputs[0]
+
+ if self.upsampler in ["pixelshuffle", "pixelshuffledirect", "nearest+conv"]:
+ reconstruction = self.upsample(sequence_output)
+ elif self.upsampler == "pixelshuffle_aux":
+ reconstruction, aux = self.upsample(sequence_output, bicubic, height, width)
+ aux = aux / self.swin2sr.img_range + self.swin2sr.mean
+ else:
+ reconstruction = pixel_values + self.final_convolution(sequence_output)
+
+ reconstruction = reconstruction / self.swin2sr.img_range + self.swin2sr.mean
+ reconstruction = reconstruction[:, :, : height * self.upscale, : width * self.upscale]
+
+ if not return_dict:
+ output = (reconstruction,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return ImageSuperResolutionOutput(
+ loss=loss,
+ reconstruction=reconstruction,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = ["Swin2SRForImageSuperResolution", "Swin2SRModel", "Swin2SRPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/swinv2/__init__.py b/lib/python3.11/site-packages/transformers/models/swinv2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..172f1573f1eb1bca4893b2495879346c0b044b9c
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swinv2/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_swinv2 import *
+ from .modeling_swinv2 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/swinv2/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swinv2/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0deed741c3fef301255830d59bd220c09543d944
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swinv2/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swinv2/__pycache__/configuration_swinv2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swinv2/__pycache__/configuration_swinv2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..da855c5f3488b9f03ee4465fabf4cdeb5a34c31f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swinv2/__pycache__/configuration_swinv2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swinv2/__pycache__/modeling_swinv2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/swinv2/__pycache__/modeling_swinv2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..552da4726eccffb2d986503c39622c3668635a7f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/swinv2/__pycache__/modeling_swinv2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/swinv2/configuration_swinv2.py b/lib/python3.11/site-packages/transformers/models/swinv2/configuration_swinv2.py
new file mode 100644
index 0000000000000000000000000000000000000000..81510e4e9e26bfb8a94c35f434034a0704d2e7ab
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swinv2/configuration_swinv2.py
@@ -0,0 +1,89 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""Swinv2 Transformer model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import BackboneConfigMixin
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="microsoft/swinv2-tiny-patch4-window8-256")
+@strict
+class Swinv2Config(BackboneConfigMixin, PreTrainedConfig):
+ r"""
+ window_size (`int`, *optional*, defaults to 7):
+ Size of windows.
+ pretrained_window_sizes (`list(int)`, *optional*, defaults to `[0, 0, 0, 0]`):
+ Size of windows during pretraining.
+ encoder_stride (`int`, *optional*, defaults to 32):
+ Factor to increase the spatial resolution by in the decoder head for masked image modeling.
+
+ Example:
+
+ ```python
+ >>> from transformers import Swinv2Config, Swinv2Model
+
+ >>> # Initializing a Swinv2 microsoft/swinv2-tiny-patch4-window8-256 style configuration
+ >>> configuration = Swinv2Config()
+
+ >>> # Initializing a model (with random weights) from the microsoft/swinv2-tiny-patch4-window8-256 style configuration
+ >>> model = Swinv2Model(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "swinv2"
+
+ attribute_map = {
+ "num_attention_heads": "num_heads",
+ "num_hidden_layers": "num_layers",
+ }
+
+ image_size: int | list[int] | tuple[int, int] = 224
+ patch_size: int | list[int] | tuple[int, int] = 4
+ num_channels: int = 3
+ embed_dim: int = 96
+ depths: list[int] | tuple[int, ...] = (2, 2, 6, 2)
+ num_heads: list[int] | tuple[int, ...] = (3, 6, 12, 24)
+ window_size: int = 7
+ pretrained_window_sizes: list[int] | tuple[int, ...] = (0, 0, 0, 0)
+ mlp_ratio: float = 4.0
+ qkv_bias: bool = True
+ hidden_dropout_prob: float | int = 0.0
+ attention_probs_dropout_prob: float | int = 0.0
+ drop_path_rate: float | int = 0.1
+ hidden_act: str = "gelu"
+ use_absolute_embeddings: bool = False
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-5
+ encoder_stride: int = 32
+ _out_features: list[str] | None = None
+ _out_indices: list[int] | None = None
+
+ def __post_init__(self, **kwargs):
+ self.num_layers = len(self.depths)
+ self.stage_names = ["stem"] + [f"stage{idx}" for idx in range(1, len(self.depths) + 1)]
+ self.set_output_features_output_indices(
+ out_indices=kwargs.pop("out_indices", None), out_features=kwargs.pop("out_features", None)
+ )
+ # we set the hidden_size attribute in order to make Swinv2 work with VisionEncoderDecoderModel
+ # this indicates the channel dimension after the last stage of the model
+ self.hidden_size = int(self.embed_dim * 2 ** (len(self.depths) - 1))
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["Swinv2Config"]
diff --git a/lib/python3.11/site-packages/transformers/models/swinv2/modeling_swinv2.py b/lib/python3.11/site-packages/transformers/models/swinv2/modeling_swinv2.py
new file mode 100644
index 0000000000000000000000000000000000000000..779e6f55f606be08fa6d47baa2ec3df82ac33f7f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/swinv2/modeling_swinv2.py
@@ -0,0 +1,1280 @@
+# Copyright 2022 Microsoft Research and The HuggingFace Inc. 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.
+"""PyTorch Swinv2 Transformer model."""
+
+import collections.abc
+import math
+from dataclasses import dataclass
+
+import torch
+from torch import Tensor, nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...backbone_utils import BackboneMixin, filter_output_hidden_states
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BackboneOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import ModelOutput, auto_docstring, logging, torch_int
+from ...utils.generic import can_return_tuple
+from .configuration_swinv2 import Swinv2Config
+
+
+logger = logging.get_logger(__name__)
+
+
+# Swinv2PatchEmbeddings and Swinv2PatchMerging are from https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/swin_transformer_v2.py.
+
+
+@auto_docstring(
+ custom_intro="""
+ Swinv2 encoder's outputs, with potential hidden states and attentions.
+ """
+)
+@dataclass
+# Copied from transformers.models.swin.modeling_swin.SwinEncoderOutput with Swin->Swinv2
+class Swinv2EncoderOutput(ModelOutput):
+ r"""
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Swinv2 model's outputs that also contains a pooling of the last hidden states.
+ """
+)
+@dataclass
+# Copied from transformers.models.swin.modeling_swin.SwinModelOutput with Swin->Swinv2
+class Swinv2ModelOutput(ModelOutput):
+ r"""
+ pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`, *optional*, returned when `add_pooling_layer=True` is passed):
+ Average pooling of the last layer hidden-state.
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ last_hidden_state: torch.FloatTensor | None = None
+ pooler_output: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Swinv2 masked image model outputs.
+ """
+)
+@dataclass
+# Copied from transformers.models.swin.modeling_swin.SwinMaskedImageModelingOutput with Swin->Swinv2
+class Swinv2MaskedImageModelingOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `bool_masked_pos` is provided):
+ Masked image modeling (MLM) loss.
+ reconstruction (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+ Reconstructed pixel values.
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ loss: torch.FloatTensor | None = None
+ reconstruction: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Swinv2 outputs for image classification.
+ """
+)
+@dataclass
+# Copied from transformers.models.swin.modeling_swin.SwinImageClassifierOutput with Swin->Swinv2
+class Swinv2ImageClassifierOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+ Classification (or regression if config.num_labels==1) loss.
+ logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
+ Classification (or regression if config.num_labels==1) scores (before SoftMax).
+ reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, hidden_size, height, width)`.
+
+ Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
+ include the spatial dimensions.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+ reshaped_hidden_states: tuple[torch.FloatTensor, ...] | None = None
+
+
+# Copied from transformers.models.swin.modeling_swin.window_partition
+def window_partition(input_feature, window_size):
+ """
+ Partitions the given input into windows.
+ """
+ batch_size, height, width, num_channels = input_feature.shape
+ input_feature = input_feature.view(
+ batch_size, height // window_size, window_size, width // window_size, window_size, num_channels
+ )
+ windows = input_feature.transpose(2, 3).contiguous().view(-1, window_size, window_size, num_channels)
+ return windows
+
+
+# Copied from transformers.models.swin.modeling_swin.window_reverse
+def window_reverse(windows, window_size, height, width):
+ """
+ Merges windows to produce higher resolution features.
+ """
+ num_channels = windows.shape[-1]
+ windows = windows.view(-1, height // window_size, width // window_size, window_size, window_size, num_channels)
+ windows = windows.transpose(2, 3).contiguous().view(-1, height, width, num_channels)
+ return windows
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinEmbeddings with Swin->Swinv2
+class Swinv2Embeddings(nn.Module):
+ """
+ Construct the patch and position embeddings. Optionally, also the mask token.
+ """
+
+ def __init__(self, config, use_mask_token=False):
+ super().__init__()
+
+ self.patch_embeddings = Swinv2PatchEmbeddings(config)
+ num_patches = self.patch_embeddings.num_patches
+ self.patch_grid = self.patch_embeddings.grid_size
+ self.mask_token = nn.Parameter(torch.zeros(1, 1, config.embed_dim)) if use_mask_token else None
+
+ if config.use_absolute_embeddings:
+ self.position_embeddings = nn.Parameter(torch.zeros(1, num_patches + 1, config.embed_dim))
+ else:
+ self.position_embeddings = None
+
+ self.norm = nn.LayerNorm(config.embed_dim)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+ self.patch_size = config.patch_size
+ self.config = config
+
+ # Copied from transformers.models.vit.modeling_vit.ViTEmbeddings.interpolate_pos_encoding
+ def interpolate_pos_encoding(self, embeddings: torch.Tensor, height: int, width: int) -> torch.Tensor:
+ """
+ This method allows to interpolate the pre-trained position encodings, to be able to use the model on higher resolution
+ images. This method is also adapted to support torch.jit tracing.
+
+ Adapted from:
+ - https://github.com/facebookresearch/dino/blob/de9ee3df6cf39fac952ab558447af1fa1365362a/vision_transformer.py#L174-L194, and
+ - https://github.com/facebookresearch/dinov2/blob/e1277af2ba9496fbadf7aec6eba56e8d882d1e35/dinov2/models/vision_transformer.py#L179-L211
+ """
+
+ num_patches = embeddings.shape[1] - 1
+ num_positions = self.position_embeddings.shape[1] - 1
+
+ # always interpolate when tracing to ensure the exported model works for dynamic input shapes
+ if not torch.jit.is_tracing() and num_patches == num_positions and height == width:
+ return self.position_embeddings
+
+ class_pos_embed = self.position_embeddings[:, :1]
+ patch_pos_embed = self.position_embeddings[:, 1:]
+
+ dim = embeddings.shape[-1]
+
+ new_height = height // self.patch_size
+ new_width = width // self.patch_size
+
+ sqrt_num_positions = torch_int(num_positions**0.5)
+ patch_pos_embed = patch_pos_embed.reshape(1, sqrt_num_positions, sqrt_num_positions, dim)
+ patch_pos_embed = patch_pos_embed.permute(0, 3, 1, 2)
+
+ patch_pos_embed = nn.functional.interpolate(
+ patch_pos_embed,
+ size=(new_height, new_width),
+ mode="bicubic",
+ align_corners=False,
+ )
+
+ patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+
+ return torch.cat((class_pos_embed, patch_pos_embed), dim=1)
+
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ interpolate_pos_encoding: bool = False,
+ ) -> tuple[torch.Tensor]:
+ _, num_channels, height, width = pixel_values.shape
+ embeddings, output_dimensions = self.patch_embeddings(pixel_values)
+ embeddings = self.norm(embeddings)
+ batch_size, seq_len, _ = embeddings.size()
+
+ if bool_masked_pos is not None:
+ mask_tokens = self.mask_token.expand(batch_size, seq_len, -1)
+ # replace the masked visual tokens by mask_tokens
+ mask = bool_masked_pos.unsqueeze(-1).type_as(mask_tokens)
+ embeddings = embeddings * (1.0 - mask) + mask_tokens * mask
+
+ if self.position_embeddings is not None:
+ if interpolate_pos_encoding:
+ embeddings = embeddings + self.interpolate_pos_encoding(embeddings, height, width)
+ else:
+ embeddings = embeddings + self.position_embeddings
+
+ embeddings = self.dropout(embeddings)
+
+ return embeddings, output_dimensions
+
+
+# Copied from transformers.models.swin.modeling_swin.SwinPatchEmbeddings with Swin->Swinv2
+class Swinv2PatchEmbeddings(nn.Module):
+ """
+ This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
+ `hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
+ Transformer.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ image_size, patch_size = config.image_size, config.patch_size
+ num_channels, hidden_size = config.num_channels, config.embed_dim
+ image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+ num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
+ self.patch_size = patch_size
+ self.num_patches = num_patches
+ self.grid_size = (image_size[0] // patch_size[0], image_size[1] // patch_size[1])
+
+ self.projection = nn.Conv2d(num_channels, hidden_size, kernel_size=patch_size, stride=patch_size)
+
+ def maybe_pad(self, pixel_values, height, width):
+ """Pad pixel_values to be divisible by patch_size if needed."""
+ if width % self.patch_size[1] != 0:
+ pad_values = (0, self.patch_size[1] - width % self.patch_size[1])
+ pixel_values = nn.functional.pad(pixel_values, pad_values)
+ if height % self.patch_size[0] != 0:
+ pad_values = (0, 0, 0, self.patch_size[0] - height % self.patch_size[0])
+ pixel_values = nn.functional.pad(pixel_values, pad_values)
+ return pixel_values
+
+ def forward(self, pixel_values: torch.FloatTensor | None) -> tuple[torch.Tensor, tuple[int]]:
+ _, num_channels, height, width = pixel_values.shape
+ # pad the input to be divisible by self.patch_size, if needed
+ pixel_values = self.maybe_pad(pixel_values, height, width)
+ embeddings = self.projection(pixel_values)
+ _, _, height, width = embeddings.shape
+ output_dimensions = (height, width)
+ embeddings = embeddings.flatten(2).transpose(1, 2)
+
+ return embeddings, output_dimensions
+
+
+class Swinv2PatchMerging(nn.Module):
+ """
+ Patch Merging Layer.
+
+ Args:
+ input_resolution (`tuple[int]`):
+ Resolution of input feature.
+ dim (`int`):
+ Number of input channels.
+ norm_layer (`nn.Module`, *optional*, defaults to `nn.LayerNorm`):
+ Normalization layer class.
+ """
+
+ def __init__(self, input_resolution: tuple[int], dim: int, norm_layer: nn.Module = nn.LayerNorm) -> None:
+ super().__init__()
+ self.input_resolution = input_resolution
+ self.dim = dim
+ self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+ self.norm = norm_layer(2 * dim)
+
+ def maybe_pad(self, input_feature, height, width):
+ should_pad = (height % 2 == 1) or (width % 2 == 1)
+ if should_pad:
+ pad_values = (0, 0, 0, width % 2, 0, height % 2)
+ input_feature = nn.functional.pad(input_feature, pad_values)
+
+ return input_feature
+
+ def forward(self, input_feature: torch.Tensor, input_dimensions: tuple[int, int]) -> torch.Tensor:
+ height, width = input_dimensions
+ # `dim` is height * width
+ batch_size, dim, num_channels = input_feature.shape
+
+ input_feature = input_feature.view(batch_size, height, width, num_channels)
+ # pad input to be divisible by width and height, if needed
+ input_feature = self.maybe_pad(input_feature, height, width)
+ # [batch_size, height/2, width/2, num_channels]
+ input_feature_0 = input_feature[:, 0::2, 0::2, :]
+ # [batch_size, height/2, width/2, num_channels]
+ input_feature_1 = input_feature[:, 1::2, 0::2, :]
+ # [batch_size, height/2, width/2, num_channels]
+ input_feature_2 = input_feature[:, 0::2, 1::2, :]
+ # [batch_size, height/2, width/2, num_channels]
+ input_feature_3 = input_feature[:, 1::2, 1::2, :]
+ # [batch_size, height/2 * width/2, 4*num_channels]
+ input_feature = torch.cat([input_feature_0, input_feature_1, input_feature_2, input_feature_3], -1)
+ input_feature = input_feature.view(batch_size, -1, 4 * num_channels) # [batch_size, height/2 * width/2, 4*C]
+
+ input_feature = self.reduction(input_feature)
+ input_feature = self.norm(input_feature)
+
+ return input_feature
+
+
+class Swinv2SelfAttention(nn.Module):
+ def __init__(self, config, dim, num_heads, window_size, pretrained_window_size=[0, 0]):
+ super().__init__()
+ if dim % num_heads != 0:
+ raise ValueError(
+ f"The hidden size ({dim}) is not a multiple of the number of attention heads ({num_heads})"
+ )
+
+ self.num_attention_heads = num_heads
+ self.attention_head_size = int(dim / num_heads)
+ self.all_head_size = self.num_attention_heads * self.attention_head_size
+ self.window_size = (
+ window_size if isinstance(window_size, collections.abc.Iterable) else (window_size, window_size)
+ )
+ self.pretrained_window_size = pretrained_window_size
+ self.logit_scale = nn.Parameter(torch.log(10 * torch.ones((num_heads, 1, 1))))
+ # mlp to generate continuous relative position bias
+ self.continuous_position_bias_mlp = nn.Sequential(
+ nn.Linear(2, 512, bias=True), nn.ReLU(inplace=True), nn.Linear(512, num_heads, bias=False)
+ )
+
+ relative_coords_table, relative_position_index = self.create_coords_table_and_index()
+ self.register_buffer("relative_coords_table", relative_coords_table, persistent=False)
+ self.register_buffer("relative_position_index", relative_position_index, persistent=False)
+
+ self.query = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)
+ self.key = nn.Linear(self.all_head_size, self.all_head_size, bias=False)
+ self.value = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)
+ self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor]:
+ batch_size, dim, num_channels = hidden_states.shape
+ query_layer = (
+ self.query(hidden_states)
+ .view(batch_size, -1, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ )
+ key_layer = (
+ self.key(hidden_states)
+ .view(batch_size, -1, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ )
+ value_layer = (
+ self.value(hidden_states)
+ .view(batch_size, -1, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ )
+
+ # cosine attention
+ attention_scores = nn.functional.normalize(query_layer, dim=-1) @ nn.functional.normalize(
+ key_layer, dim=-1
+ ).transpose(-2, -1)
+ logit_scale = torch.clamp(self.logit_scale, max=math.log(1.0 / 0.01)).exp()
+ attention_scores = attention_scores * logit_scale
+ relative_position_bias_table = self.continuous_position_bias_mlp(self.relative_coords_table).view(
+ -1, self.num_attention_heads
+ )
+ # [window_height*window_width,window_height*window_width,num_attention_heads]
+ relative_position_bias = relative_position_bias_table[self.relative_position_index.view(-1)].view(
+ self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1
+ )
+ # [num_attention_heads,window_height*window_width,window_height*window_width]
+ relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww
+ relative_position_bias = 16 * torch.sigmoid(relative_position_bias)
+ attention_scores = attention_scores + relative_position_bias.unsqueeze(0)
+
+ if attention_mask is not None:
+ # Apply the attention mask is (precomputed for all layers in Swinv2Model forward() function)
+ mask_shape = attention_mask.shape[0]
+ attention_scores = attention_scores.view(
+ batch_size // mask_shape, mask_shape, self.num_attention_heads, dim, dim
+ ) + attention_mask.unsqueeze(1).unsqueeze(0)
+ attention_scores = attention_scores + attention_mask.unsqueeze(1).unsqueeze(0)
+ attention_scores = attention_scores.view(-1, self.num_attention_heads, dim, dim)
+
+ # Normalize the attention scores to probabilities.
+ attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+ # This is actually dropping out entire tokens to attend to, which might
+ # seem a bit unusual, but is taken from the original Transformer paper.
+ attention_probs = self.dropout(attention_probs)
+
+ # Mask heads if we want to
+
+ context_layer = torch.matmul(attention_probs, value_layer)
+ context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+ new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+ context_layer = context_layer.view(new_context_layer_shape)
+
+ outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+ return outputs
+
+ def create_coords_table_and_index(self):
+ # get relative_coords_table
+ relative_coords_h = torch.arange(-(self.window_size[0] - 1), self.window_size[0], dtype=torch.int64).float()
+ relative_coords_w = torch.arange(-(self.window_size[1] - 1), self.window_size[1], dtype=torch.int64).float()
+ relative_coords_table = (
+ torch.stack(torch.meshgrid([relative_coords_h, relative_coords_w], indexing="ij"))
+ .permute(1, 2, 0)
+ .contiguous()
+ .unsqueeze(0)
+ ) # [1, 2*window_height - 1, 2*window_width - 1, 2]
+ if self.pretrained_window_size[0] > 0:
+ relative_coords_table[:, :, :, 0] /= self.pretrained_window_size[0] - 1
+ relative_coords_table[:, :, :, 1] /= self.pretrained_window_size[1] - 1
+ elif self.window_size[0] > 1:
+ relative_coords_table[:, :, :, 0] /= self.window_size[0] - 1
+ relative_coords_table[:, :, :, 1] /= self.window_size[1] - 1
+ relative_coords_table *= 8 # normalize to -8, 8
+ relative_coords_table = (
+ torch.sign(relative_coords_table) * torch.log2(torch.abs(relative_coords_table) + 1.0) / math.log2(8)
+ )
+ # set to same dtype as mlp weight
+ relative_coords_table = relative_coords_table.to(next(self.continuous_position_bias_mlp.parameters()).dtype)
+
+ # get pair-wise relative position index for each token inside the window
+ coords_h = torch.arange(self.window_size[0])
+ coords_w = torch.arange(self.window_size[1])
+ coords = torch.stack(torch.meshgrid([coords_h, coords_w], indexing="ij"))
+ coords_flatten = torch.flatten(coords, 1)
+ relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]
+ relative_coords = relative_coords.permute(1, 2, 0).contiguous()
+ relative_coords[:, :, 0] += self.window_size[0] - 1
+ relative_coords[:, :, 1] += self.window_size[1] - 1
+ relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+ relative_position_index = relative_coords.sum(-1)
+
+ return relative_coords_table, relative_position_index
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinSelfOutput with Swin->Swinv2
+class Swinv2SelfOutput(nn.Module):
+ def __init__(self, config, dim):
+ super().__init__()
+ self.dense = nn.Linear(dim, dim)
+ self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ return hidden_states
+
+
+class Swinv2Attention(nn.Module):
+ def __init__(self, config, dim, num_heads, window_size, pretrained_window_size=0):
+ super().__init__()
+ self.self = Swinv2SelfAttention(
+ config=config,
+ dim=dim,
+ num_heads=num_heads,
+ window_size=window_size,
+ pretrained_window_size=pretrained_window_size
+ if isinstance(pretrained_window_size, collections.abc.Iterable)
+ else (pretrained_window_size, pretrained_window_size),
+ )
+ self.output = Swinv2SelfOutput(config, dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor]:
+ self_outputs = self.self(hidden_states, attention_mask, output_attentions)
+ attention_output = self.output(self_outputs[0], hidden_states)
+ outputs = (attention_output,) + self_outputs[1:] # add attentions if we output them
+ return outputs
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinIntermediate with Swin->Swinv2
+class Swinv2Intermediate(nn.Module):
+ def __init__(self, config, dim):
+ super().__init__()
+ self.dense = nn.Linear(dim, int(config.mlp_ratio * dim))
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ return hidden_states
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinOutput with Swin->Swinv2
+class Swinv2Output(nn.Module):
+ def __init__(self, config, dim):
+ super().__init__()
+ self.dense = nn.Linear(int(config.mlp_ratio * dim), dim)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.swin.modular_swin.SwinDropPath with SwinDropPath->Swinv2DropPath
+class Swinv2DropPath(nn.Module):
+ """Stochastic depth (DropPath) per sample, for residual blocks.
+
+ Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
+ <https://arxiv.org/abs/1603.09382>`_.
+ """
+
+ def __init__(self, drop_prob: float = 0.0) -> None:
+ super().__init__()
+ self.drop_prob = drop_prob
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ if self.drop_prob == 0.0 or not self.training:
+ return hidden_states
+ keep_prob = 1 - self.drop_prob
+ shape = (hidden_states.shape[0],) + (1,) * (hidden_states.ndim - 1)
+ random_tensor = torch.rand(shape, dtype=hidden_states.dtype, device=hidden_states.device)
+ random_tensor = torch.floor(random_tensor + keep_prob)
+ return hidden_states.div(keep_prob) * random_tensor
+
+ def extra_repr(self) -> str:
+ return f"p={self.drop_prob}"
+
+
+class Swinv2Layer(nn.Module):
+ def __init__(
+ self, config, dim, input_resolution, num_heads, drop_path_rate=0.0, shift_size=0, pretrained_window_size=0
+ ):
+ super().__init__()
+ self.input_resolution = input_resolution
+ window_size, shift_size = self._compute_window_shift(
+ (config.window_size, config.window_size), (shift_size, shift_size)
+ )
+ self.window_size = window_size[0]
+ self.shift_size = shift_size[0]
+ self.attention = Swinv2Attention(
+ config=config,
+ dim=dim,
+ num_heads=num_heads,
+ window_size=self.window_size,
+ pretrained_window_size=pretrained_window_size
+ if isinstance(pretrained_window_size, collections.abc.Iterable)
+ else (pretrained_window_size, pretrained_window_size),
+ )
+ self.layernorm_before = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+ self.drop_path = Swinv2DropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity()
+ self.intermediate = Swinv2Intermediate(config, dim)
+ self.output = Swinv2Output(config, dim)
+ self.layernorm_after = nn.LayerNorm(dim, eps=config.layer_norm_eps)
+
+ def _compute_window_shift(self, target_window_size, target_shift_size) -> tuple[tuple[int, int], tuple[int, int]]:
+ window_size = [min(r, w) for r, w in zip(self.input_resolution, target_window_size)]
+ shift_size = [0 if r <= w else s for r, w, s in zip(self.input_resolution, window_size, target_shift_size)]
+ return window_size, shift_size
+
+ def get_attn_mask(self, height, width, dtype):
+ if self.shift_size > 0:
+ # calculate attention mask for shifted window multihead self attention
+ img_mask = torch.zeros((1, height, width, 1), dtype=dtype)
+ height_slices = (
+ slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None),
+ )
+ width_slices = (
+ slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None),
+ )
+ count = 0
+ for height_slice in height_slices:
+ for width_slice in width_slices:
+ img_mask[:, height_slice, width_slice, :] = count
+ count += 1
+
+ mask_windows = window_partition(img_mask, self.window_size)
+ mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+ attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+ attn_mask = attn_mask.masked_fill(attn_mask != 0, -100.0).masked_fill(attn_mask == 0, 0.0)
+ else:
+ attn_mask = None
+ return attn_mask
+
+ def maybe_pad(self, hidden_states, height, width):
+ pad_right = (self.window_size - width % self.window_size) % self.window_size
+ pad_bottom = (self.window_size - height % self.window_size) % self.window_size
+ pad_values = (0, 0, 0, pad_right, 0, pad_bottom)
+ hidden_states = nn.functional.pad(hidden_states, pad_values)
+ return hidden_states, pad_values
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ height, width = input_dimensions
+ batch_size, _, channels = hidden_states.size()
+ shortcut = hidden_states
+
+ # pad hidden_states to multiples of window size
+ hidden_states = hidden_states.view(batch_size, height, width, channels)
+ hidden_states, pad_values = self.maybe_pad(hidden_states, height, width)
+ _, height_pad, width_pad, _ = hidden_states.shape
+ # cyclic shift
+ if self.shift_size > 0:
+ shifted_hidden_states = torch.roll(hidden_states, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
+ else:
+ shifted_hidden_states = hidden_states
+
+ # partition windows
+ hidden_states_windows = window_partition(shifted_hidden_states, self.window_size)
+ hidden_states_windows = hidden_states_windows.view(-1, self.window_size * self.window_size, channels)
+ attn_mask = self.get_attn_mask(height_pad, width_pad, dtype=hidden_states.dtype)
+ if attn_mask is not None:
+ attn_mask = attn_mask.to(hidden_states_windows.device)
+
+ attention_outputs = self.attention(hidden_states_windows, attn_mask, output_attentions=output_attentions)
+
+ attention_output = attention_outputs[0]
+
+ attention_windows = attention_output.view(-1, self.window_size, self.window_size, channels)
+ shifted_windows = window_reverse(attention_windows, self.window_size, height_pad, width_pad)
+
+ # reverse cyclic shift
+ if self.shift_size > 0:
+ attention_windows = torch.roll(shifted_windows, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
+ else:
+ attention_windows = shifted_windows
+
+ was_padded = pad_values[3] > 0 or pad_values[5] > 0
+ if was_padded:
+ attention_windows = attention_windows[:, :height, :width, :].contiguous()
+
+ attention_windows = attention_windows.view(batch_size, height * width, channels)
+ hidden_states = self.layernorm_before(attention_windows)
+ hidden_states = shortcut + self.drop_path(hidden_states)
+
+ layer_output = self.intermediate(hidden_states)
+ layer_output = self.output(layer_output)
+ layer_output = hidden_states + self.drop_path(self.layernorm_after(layer_output))
+
+ layer_outputs = (layer_output, attention_outputs[1]) if output_attentions else (layer_output,)
+ return layer_outputs
+
+
+class Swinv2Stage(GradientCheckpointingLayer):
+ def __init__(
+ self, config, dim, input_resolution, depth, num_heads, drop_path, downsample, pretrained_window_size=0
+ ):
+ super().__init__()
+ self.config = config
+ self.dim = dim
+ blocks = []
+ for i in range(depth):
+ block = Swinv2Layer(
+ config=config,
+ dim=dim,
+ input_resolution=input_resolution,
+ num_heads=num_heads,
+ drop_path_rate=drop_path[i],
+ shift_size=0 if (i % 2 == 0) else config.window_size // 2,
+ pretrained_window_size=pretrained_window_size,
+ )
+ blocks.append(block)
+ self.blocks = nn.ModuleList(blocks)
+
+ # patch merging layer
+ if downsample is not None:
+ self.downsample = downsample(input_resolution, dim=dim, norm_layer=nn.LayerNorm)
+ else:
+ self.downsample = None
+
+ self.pointing = False
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ output_attentions: bool | None = False,
+ ) -> tuple[torch.Tensor]:
+ height, width = input_dimensions
+ for i, layer_module in enumerate(self.blocks):
+ layer_outputs = layer_module(
+ hidden_states,
+ input_dimensions,
+ output_attentions,
+ )
+
+ hidden_states = layer_outputs[0]
+
+ hidden_states_before_downsampling = hidden_states
+ if self.downsample is not None:
+ height_downsampled, width_downsampled = (height + 1) // 2, (width + 1) // 2
+ output_dimensions = (height, width, height_downsampled, width_downsampled)
+ hidden_states = self.downsample(hidden_states_before_downsampling, input_dimensions)
+ else:
+ output_dimensions = (height, width, height, width)
+
+ stage_outputs = (hidden_states, hidden_states_before_downsampling, output_dimensions)
+
+ if output_attentions:
+ stage_outputs += layer_outputs[1:]
+ return stage_outputs
+
+
+class Swinv2Encoder(nn.Module):
+ def __init__(self, config, grid_size, pretrained_window_sizes=(0, 0, 0, 0)):
+ super().__init__()
+ self.num_layers = len(config.depths)
+ self.config = config
+ if self.config.pretrained_window_sizes is not None:
+ pretrained_window_sizes = config.pretrained_window_sizes
+ dpr = [x.item() for x in torch.linspace(0, config.drop_path_rate, sum(config.depths), device="cpu")]
+
+ layers = []
+ for i_layer in range(self.num_layers):
+ stage = Swinv2Stage(
+ config=config,
+ dim=int(config.embed_dim * 2**i_layer),
+ input_resolution=(grid_size[0] // (2**i_layer), grid_size[1] // (2**i_layer)),
+ depth=config.depths[i_layer],
+ num_heads=config.num_heads[i_layer],
+ drop_path=dpr[sum(config.depths[:i_layer]) : sum(config.depths[: i_layer + 1])],
+ downsample=Swinv2PatchMerging if (i_layer < self.num_layers - 1) else None,
+ pretrained_window_size=pretrained_window_sizes[i_layer],
+ )
+ layers.append(stage)
+ self.layers = nn.ModuleList(layers)
+
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ input_dimensions: tuple[int, int],
+ output_attentions: bool | None = False,
+ output_hidden_states: bool | None = False,
+ output_hidden_states_before_downsampling: bool | None = False,
+ return_dict: bool | None = True,
+ ) -> tuple | Swinv2EncoderOutput:
+ all_hidden_states = () if output_hidden_states else None
+ all_reshaped_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ if output_hidden_states:
+ batch_size, _, hidden_size = hidden_states.shape
+ # rearrange b (h w) c -> b c h w
+ reshaped_hidden_state = hidden_states.view(batch_size, *input_dimensions, hidden_size)
+ reshaped_hidden_state = reshaped_hidden_state.permute(0, 3, 1, 2)
+ all_hidden_states += (hidden_states,)
+ all_reshaped_hidden_states += (reshaped_hidden_state,)
+
+ for i, layer_module in enumerate(self.layers):
+ layer_outputs = layer_module(
+ hidden_states,
+ input_dimensions,
+ output_attentions,
+ )
+
+ hidden_states = layer_outputs[0]
+ hidden_states_before_downsampling = layer_outputs[1]
+ output_dimensions = layer_outputs[2]
+
+ input_dimensions = (output_dimensions[-2], output_dimensions[-1])
+
+ if output_hidden_states and output_hidden_states_before_downsampling:
+ batch_size, _, hidden_size = hidden_states_before_downsampling.shape
+ # rearrange b (h w) c -> b c h w
+ # here we use the original (not downsampled) height and width
+ reshaped_hidden_state = hidden_states_before_downsampling.view(
+ batch_size, *(output_dimensions[0], output_dimensions[1]), hidden_size
+ )
+ reshaped_hidden_state = reshaped_hidden_state.permute(0, 3, 1, 2)
+ all_hidden_states += (hidden_states_before_downsampling,)
+ all_reshaped_hidden_states += (reshaped_hidden_state,)
+ elif output_hidden_states and not output_hidden_states_before_downsampling:
+ batch_size, _, hidden_size = hidden_states.shape
+ # rearrange b (h w) c -> b c h w
+ reshaped_hidden_state = hidden_states.view(batch_size, *input_dimensions, hidden_size)
+ reshaped_hidden_state = reshaped_hidden_state.permute(0, 3, 1, 2)
+ all_hidden_states += (hidden_states,)
+ all_reshaped_hidden_states += (reshaped_hidden_state,)
+
+ if output_attentions:
+ all_self_attentions += layer_outputs[3:]
+
+ if not return_dict:
+ return tuple(
+ v
+ for v in [hidden_states, all_hidden_states, all_self_attentions, all_reshaped_hidden_states]
+ if v is not None
+ )
+
+ return Swinv2EncoderOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ reshaped_hidden_states=all_reshaped_hidden_states,
+ )
+
+
+@auto_docstring
+class Swinv2PreTrainedModel(PreTrainedModel):
+ config: Swinv2Config
+ base_model_prefix = "swinv2"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["Swinv2Stage"]
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ if isinstance(module, (nn.Linear, nn.Conv2d)):
+ init.normal_(module.weight, mean=0.0, std=self.config.initializer_range)
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, nn.LayerNorm):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ elif isinstance(module, Swinv2Embeddings):
+ if module.mask_token is not None:
+ init.zeros_(module.mask_token)
+ if module.position_embeddings is not None:
+ init.zeros_(module.position_embeddings)
+ elif isinstance(module, Swinv2SelfAttention):
+ init.constant_(module.logit_scale, math.log(10))
+ relative_coords_table, relative_position_index = module.create_coords_table_and_index()
+ init.copy_(module.relative_coords_table, relative_coords_table)
+ init.copy_(module.relative_position_index, relative_position_index)
+
+
+@auto_docstring
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinModel with SWIN->SWINV2,Swin->Swinv2
+class Swinv2Model(Swinv2PreTrainedModel):
+ def __init__(self, config, add_pooling_layer=True, use_mask_token=False):
+ r"""
+ add_pooling_layer (`bool`, *optional*, defaults to `True`):
+ Whether or not to apply pooling layer.
+ use_mask_token (`bool`, *optional*, defaults to `False`):
+ Whether or not to create and apply mask tokens in the embedding layer.
+ """
+ super().__init__(config)
+ self.config = config
+ self.num_layers = len(config.depths)
+ self.num_features = int(config.embed_dim * 2 ** (self.num_layers - 1))
+
+ self.embeddings = Swinv2Embeddings(config, use_mask_token=use_mask_token)
+ self.encoder = Swinv2Encoder(config, self.embeddings.patch_grid)
+
+ self.layernorm = nn.LayerNorm(self.num_features, eps=config.layer_norm_eps)
+ self.pooler = nn.AdaptiveAvgPool1d(1) if add_pooling_layer else None
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings.patch_embeddings
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ interpolate_pos_encoding: bool = False,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | Swinv2ModelOutput:
+ r"""
+ bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`, *optional*):
+ Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if pixel_values is None:
+ raise ValueError("You have to specify pixel_values")
+
+ embedding_output, input_dimensions = self.embeddings(
+ pixel_values, bool_masked_pos=bool_masked_pos, interpolate_pos_encoding=interpolate_pos_encoding
+ )
+
+ encoder_outputs = self.encoder(
+ embedding_output,
+ input_dimensions,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = encoder_outputs[0]
+ sequence_output = self.layernorm(sequence_output)
+
+ pooled_output = None
+ if self.pooler is not None:
+ pooled_output = self.pooler(sequence_output.transpose(1, 2))
+ pooled_output = torch.flatten(pooled_output, 1)
+
+ if not return_dict:
+ output = (sequence_output, pooled_output) + encoder_outputs[1:]
+
+ return output
+
+ return Swinv2ModelOutput(
+ last_hidden_state=sequence_output,
+ pooler_output=pooled_output,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ reshaped_hidden_states=encoder_outputs.reshaped_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Swinv2 Model with a decoder on top for masked image modeling, as proposed in
+ [SimMIM](https://huggingface.co/papers/2111.09886).
+
+ <Tip>
+
+ Note that we provide a script to pre-train this model on custom data in our [examples
+ directory](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-pretraining).
+
+ </Tip>
+ """
+)
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinForMaskedImageModeling with swin->swinv2, base-simmim-window6-192->tiny-patch4-window8-256,SWIN->SWINV2,Swin->Swinv2,192->256
+class Swinv2ForMaskedImageModeling(Swinv2PreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.swinv2 = Swinv2Model(config, add_pooling_layer=False, use_mask_token=True)
+
+ num_features = int(config.embed_dim * 2 ** (config.num_layers - 1))
+ self.decoder = nn.Sequential(
+ nn.Conv2d(
+ in_channels=num_features, out_channels=config.encoder_stride**2 * config.num_channels, kernel_size=1
+ ),
+ nn.PixelShuffle(config.encoder_stride),
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ interpolate_pos_encoding: bool = False,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | Swinv2MaskedImageModelingOutput:
+ r"""
+ bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`):
+ Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).
+
+ Examples:
+ ```python
+ >>> from transformers import AutoImageProcessor, Swinv2ForMaskedImageModeling
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swinv2-tiny-patch4-window8-256")
+ >>> model = Swinv2ForMaskedImageModeling.from_pretrained("microsoft/swinv2-tiny-patch4-window8-256")
+
+ >>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
+ >>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
+ >>> # create random boolean mask of shape (batch_size, num_patches)
+ >>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()
+
+ >>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
+ >>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
+ >>> list(reconstructed_pixel_values.shape)
+ [1, 3, 256, 256]
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.swinv2(
+ pixel_values,
+ bool_masked_pos=bool_masked_pos,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ return_dict=return_dict,
+ )
+
+ sequence_output = outputs[0]
+ # Reshape to (batch_size, num_channels, height, width)
+ sequence_output = sequence_output.transpose(1, 2)
+ batch_size, num_channels, sequence_length = sequence_output.shape
+ height = width = math.floor(sequence_length**0.5)
+ sequence_output = sequence_output.reshape(batch_size, num_channels, height, width)
+
+ # Reconstruct pixel values
+ reconstructed_pixel_values = self.decoder(sequence_output)
+
+ masked_im_loss = None
+ if bool_masked_pos is not None:
+ size = self.config.image_size // self.config.patch_size
+ bool_masked_pos = bool_masked_pos.reshape(-1, size, size)
+ mask = (
+ bool_masked_pos.repeat_interleave(self.config.patch_size, 1)
+ .repeat_interleave(self.config.patch_size, 2)
+ .unsqueeze(1)
+ .contiguous()
+ )
+ reconstruction_loss = nn.functional.l1_loss(pixel_values, reconstructed_pixel_values, reduction="none")
+ masked_im_loss = (reconstruction_loss * mask).sum() / (mask.sum() + 1e-5) / self.config.num_channels
+
+ if not return_dict:
+ output = (reconstructed_pixel_values,) + outputs[2:]
+ return ((masked_im_loss,) + output) if masked_im_loss is not None else output
+
+ return Swinv2MaskedImageModelingOutput(
+ loss=masked_im_loss,
+ reconstruction=reconstructed_pixel_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ reshaped_hidden_states=outputs.reshaped_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Swinv2 Model transformer with an image classification head on top (a linear layer on top of the final hidden state
+ of the [CLS] token) e.g. for ImageNet.
+
+ <Tip>
+
+ Note that it's possible to fine-tune SwinV2 on higher resolution images than the ones it has been trained on, by
+ setting `interpolate_pos_encoding` to `True` in the forward of the model. This will interpolate the pre-trained
+ position embeddings to the higher resolution.
+
+ </Tip>
+ """
+)
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.swin.modeling_swin.SwinForImageClassification with SWIN->SWINV2,Swin->Swinv2,swin->swinv2
+class Swinv2ForImageClassification(Swinv2PreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.num_labels = config.num_labels
+ self.swinv2 = Swinv2Model(config)
+
+ # Classifier head
+ self.classifier = (
+ nn.Linear(self.swinv2.num_features, config.num_labels) if config.num_labels > 0 else nn.Identity()
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ interpolate_pos_encoding: bool = False,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | Swinv2ImageClassifierOutput:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.swinv2(
+ pixel_values,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ return_dict=return_dict,
+ )
+
+ pooled_output = outputs[1]
+
+ logits = self.classifier(pooled_output)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config)
+
+ if not return_dict:
+ output = (logits,) + outputs[2:]
+ return ((loss,) + output) if loss is not None else output
+
+ return Swinv2ImageClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ reshaped_hidden_states=outputs.reshaped_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Swinv2 backbone, to be used with frameworks like DETR and MaskFormer.
+ """
+)
+class Swinv2Backbone(BackboneMixin, Swinv2PreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.num_features = [config.embed_dim] + [int(config.embed_dim * 2**i) for i in range(len(config.depths))]
+ self.embeddings = Swinv2Embeddings(config)
+ self.encoder = Swinv2Encoder(config, self.embeddings.patch_grid)
+
+ # initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings.patch_embeddings
+
+ @can_return_tuple
+ @filter_output_hidden_states
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: Tensor,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> BackboneOutput:
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, AutoBackbone
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> processor = AutoImageProcessor.from_pretrained("microsoft/swinv2-tiny-patch4-window8-256")
+ >>> model = AutoBackbone.from_pretrained(
+ ... "microsoft/swinv2-tiny-patch4-window8-256", out_features=["stage1", "stage2", "stage3", "stage4"]
+ ... )
+
+ >>> inputs = processor(image, return_tensors="pt")
+
+ >>> outputs = model(**inputs)
+ >>> feature_maps = outputs.feature_maps
+ >>> list(feature_maps[-1].shape)
+ [1, 2048, 7, 7]
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+
+ embedding_output, input_dimensions = self.embeddings(pixel_values)
+
+ outputs = self.encoder(
+ embedding_output,
+ input_dimensions,
+ output_attentions=output_attentions,
+ output_hidden_states=True,
+ output_hidden_states_before_downsampling=True,
+ return_dict=return_dict,
+ )
+
+ hidden_states = outputs.reshaped_hidden_states if return_dict else outputs[-1]
+
+ feature_maps = ()
+ for stage, hidden_state in zip(self.stage_names, hidden_states):
+ if stage in self.out_features:
+ feature_maps += (hidden_state,)
+
+ if not return_dict:
+ output = (feature_maps,)
+ if output_hidden_states:
+ output += (outputs[1],)
+ if output_attentions:
+ output += (outputs[2],)
+ return output
+
+ return BackboneOutput(
+ feature_maps=feature_maps,
+ hidden_states=outputs.hidden_states if output_hidden_states else None,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "Swinv2ForImageClassification",
+ "Swinv2ForMaskedImageModeling",
+ "Swinv2Model",
+ "Swinv2PreTrainedModel",
+ "Swinv2Backbone",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/switch_transformers/__init__.py b/lib/python3.11/site-packages/transformers/models/switch_transformers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..70afa7006d73dd2ecf9c421edd78e230cae4c731
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/switch_transformers/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_switch_transformers import *
+ from .modeling_switch_transformers import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..48b5622c9514fbc701eb6a399f4c6c7958b5af6f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/configuration_switch_transformers.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/configuration_switch_transformers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5387875633aafc1c87c2e6bb0c9b81a2df713fc
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/configuration_switch_transformers.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/modeling_switch_transformers.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/modeling_switch_transformers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..17cb452ae59a2caaf9ac138a9246dca9998d340d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/modeling_switch_transformers.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/modular_switch_transformers.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/modular_switch_transformers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1da282e8e1a05fa4fb7ef2ea762ebd7d28f76df7
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/switch_transformers/__pycache__/modular_switch_transformers.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/switch_transformers/configuration_switch_transformers.py b/lib/python3.11/site-packages/transformers/models/switch_transformers/configuration_switch_transformers.py
new file mode 100644
index 0000000000000000000000000000000000000000..53da1bd7b8997074012d96fcc235c5f2b240ac2e
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/switch_transformers/configuration_switch_transformers.py
@@ -0,0 +1,111 @@
+# Copyright 2022, Google and HuggingFace Inc.
+#
+# 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.
+"""Switch Transformers model configuration"""
+
+from typing import Literal
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="google/switch-base-8")
+@strict
+class SwitchTransformersConfig(PreTrainedConfig):
+ r"""
+ num_sparse_encoder_layers (`int`, *optional*, defaults to 3):
+ Number of sparse (MoE) dense hidden layers in the Transformer encoder layer.
+ Note: When set to 0 with `num_layers=1`, the current implementation may still create a sparse layer
+ due to the sparse step calculation. This edge case is not encountered in existing checkpoints.
+ num_sparse_decoder_layers (`int`, *optional*, defaults to 3):
+ Number of sparse (MoE) dense hidden layers in the Transformer decoder layer.
+ Note: When set to 0 with `num_decoder_layers=1`, the current implementation may still create a sparse
+ layer due to the sparse step calculation. This edge case is not encountered in existing checkpoints.
+ router_bias (`bool`, *optional*, defaults to `False`):
+ Whether to add a bias to the router.
+ router_dtype (`str`, *optional*, default to `"float32"`):
+ The `dtype` used for the routers. It is preferable to keep the `dtype` to `"float32"` as specified in the
+ *selective precision* discussion in [the paper](https://huggingface.co/papers/2101.03961).
+ router_ignore_padding_tokens (`bool`, *optional*, defaults to `False`):
+ Whether to ignore padding tokens when routing.
+ relative_attention_num_buckets (`int`, *optional*, defaults to 32):
+ The number of buckets to use for each attention layer.
+ relative_attention_max_distance (`int`, *optional*, defaults to 128):
+ The maximum distance of the longer sequences for the bucket separation.
+ dense_act_fn (`string`, *optional*, defaults to `"relu"`):
+ Type of feed forward layer to be used. Should be one of `"relu"` or `"gated-gelu"`. SwitchTransformersv1.1
+ uses the `"gated-gelu"` feed forward projection. Original SwitchTransformers uses `"relu"`.
+ add_router_probs (`bool`, *optional*, defaults to `False`):
+ Whether to output router probabilities to compute router auxiliary loss.
+ """
+
+ model_type = "switch_transformers"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ attribute_map = {"hidden_size": "d_model", "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"}
+
+ vocab_size: int = 32128
+ d_model: int = 768
+ d_kv: int = 64
+ d_ff: int = 2048
+ expert_capacity: int = 64
+ num_layers: int = 12
+ num_sparse_encoder_layers: int = 3
+ num_decoder_layers: int | None = 12
+ num_sparse_decoder_layers: int = 3
+ num_heads: int = 12
+ num_experts: int = 8
+ router_bias: bool = False
+ router_jitter_noise: int | float = 0.01
+ router_dtype: Literal["float32", "float16", "bfloat16"] = "float32"
+ router_ignore_padding_tokens: bool = False
+ relative_attention_num_buckets: int = 32
+ relative_attention_max_distance: int = 128
+ dropout_rate: float | int = 0.1
+ layer_norm_epsilon: float = 1e-6
+ router_z_loss_coef: float = 0.001
+ router_aux_loss_coef: float = 0.001
+ initializer_factor: float = 1.0
+ dense_act_fn: str = "relu"
+ is_encoder_decoder: bool = True
+ add_router_probs: bool = False
+ use_cache: bool = True
+ pad_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 1
+ bos_token_id: int | None = None
+ tie_word_embeddings: bool = True
+ is_decoder: bool = False
+ add_cross_attention: bool = False
+
+ def __post_init__(self, **kwargs):
+ self.num_decoder_layers = (
+ self.num_decoder_layers if self.num_decoder_layers is not None else self.num_layers
+ ) # default = symmetry
+
+ # This tells us, each how many encoder layer we'll have to set a sparse layer.
+ if self.num_sparse_encoder_layers > 0:
+ self.encoder_sparse_step = self.num_layers // self.num_sparse_encoder_layers
+ else:
+ self.encoder_sparse_step = self.num_layers # HACK: this will create 0 sparse layers
+
+ # This tells us, each how many decoder layer we'll have to set a sparse layer.
+ if self.num_sparse_decoder_layers > 0:
+ self.decoder_sparse_step = self.num_decoder_layers // self.num_sparse_decoder_layers
+ else:
+ self.decoder_sparse_step = self.num_decoder_layers # HACK: this will create 0 sparse layers
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["SwitchTransformersConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/switch_transformers/modeling_switch_transformers.py b/lib/python3.11/site-packages/transformers/models/switch_transformers/modeling_switch_transformers.py
new file mode 100644
index 0000000000000000000000000000000000000000..fca1a97a7efcb3ce6f55b87210566806418819e9
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/switch_transformers/modeling_switch_transformers.py
@@ -0,0 +1,1095 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/switch_transformers/modular_switch_transformers.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_switch_transformers.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2022 SwitchTransformers Authors and 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.
+
+import copy
+import math
+
+import torch
+import torch.nn as nn
+from torch.nn import CrossEntropyLoss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ MoEModelOutput,
+ MoEModelOutputWithPastAndCrossAttentions,
+ Seq2SeqMoEModelOutput,
+ Seq2SeqMoEOutput,
+)
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, is_torchdynamo_compiling, logging
+from ...utils.generic import can_return_tuple, merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from .configuration_switch_transformers import SwitchTransformersConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+class SwitchTransformersTop1Router(nn.Module):
+ """
+ Router using tokens choose top-1 experts assignment.
+
+ This router uses the same mechanism as in Switch Transformer (https://huggingface.co/papers/2101.03961) and V-MoE
+ (https://huggingface.co/papers/2106.05974): tokens choose their top experts. Items are sorted by router_probs and then
+ routed to their choice of expert until the expert's expert_capacity is reached. **There is no guarantee that each
+ token is processed by an expert**, or that each expert receives at least one token.
+
+ """
+
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__()
+ self.num_experts = config.num_experts
+ self.expert_capacity = config.expert_capacity
+ self.classifier = nn.Linear(config.hidden_size, self.num_experts, bias=config.router_bias)
+ self.jitter_noise = config.router_jitter_noise
+ self.ignore_padding_tokens = config.router_ignore_padding_tokens
+ self.dtype = getattr(torch, config.router_dtype)
+
+ def forward(self, hidden_states: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ r"""
+ Computes router probabilities from input hidden states.
+
+ Args:
+ hidden_states (`torch.Tensor`):
+ (batch_size, sequence_length, hidden_dim) from which router probabilities are computed.
+ Returns:
+ router_probabilities (`torch.Tensor`):
+ Tensor of shape (batch_size, sequence_length, num_experts) corresponding to the probabilities for each
+ token and expert. Used for routing tokens to experts.
+ router_logits (`torch.Tensor`):
+ Logits tensor of shape (batch_size, sequence_length, num_experts) corresponding to raw router logits.
+ This is used later for computing router z-loss.
+ """
+ # float32 is used to ensure stability. See the discussion of "selective precision" in
+ # https://huggingface.co/papers/2101.03961.
+ # We also store the previous dtype to cast back the output to the previous dtype
+ self.input_dtype = hidden_states.dtype
+ hidden_states = hidden_states.to(self.dtype)
+ if self.training and self.jitter_noise > 0:
+ # Multiply the token inputs by the uniform distribution - adding some noise
+ hidden_states *= torch.empty_like(hidden_states).uniform_(1.0 - self.jitter_noise, 1.0 + self.jitter_noise)
+ self.classifier = self.classifier.to(self.dtype)
+ router_logits = self.classifier(hidden_states)
+
+ # Apply Softmax and cast back to the original `dtype`
+ router_probs = nn.functional.softmax(router_logits, dim=-1, dtype=self.dtype).to(self.input_dtype)
+ router_logits, expert_index = torch.max(router_probs, dim=-1, keepdim=True)
+ expert_index = torch.nn.functional.one_hot(expert_index, num_classes=self.num_experts)
+ token_priority = torch.cumsum(expert_index, dim=-2)
+ # mask if the token routed to the expert will overflow
+ expert_capacity_mask = token_priority <= self.expert_capacity
+ expert_index = expert_index * expert_capacity_mask
+ router_probs = torch.max(router_probs, dim=-1).values.unsqueeze(-1)
+ return router_probs, expert_index, router_logits
+
+
+class SwitchTransformersLayerNorm(nn.Module):
+ def __init__(self, hidden_size, eps=1e-6):
+ """
+ Construct a layernorm module in the SWITCH_TRANSFORMERS style. No bias and no subtraction of mean.
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states):
+ # SWITCH_TRANSFORMERS uses a layer_norm which only scales and doesn't shift, which is also known as Root Mean
+ # Square Layer Normalization https://huggingface.co/papers/1910.07467 thus variance is calculated
+ # w/o mean and there is no bias. Additionally we want to make sure that the accumulation for
+ # half-precision inputs is done in fp32
+
+ variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+
+ # convert into half-precision if necessary
+ if self.weight.dtype in [torch.float16, torch.bfloat16]:
+ hidden_states = hidden_states.to(self.weight.dtype)
+
+ return self.weight * hidden_states
+
+
+class SwitchTransformersDenseActDense(nn.Module):
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__()
+ self.wi = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.act = ACT2FN[config.dense_act_fn]
+
+ def forward(self, hidden_states):
+ hidden_states = self.wi(hidden_states)
+ hidden_states = self.act(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ if (
+ isinstance(self.wo.weight, torch.Tensor)
+ and hidden_states.dtype != self.wo.weight.dtype
+ and self.wo.weight.dtype != torch.int8
+ ):
+ hidden_states = hidden_states.to(self.wo.weight.dtype)
+ hidden_states = self.wo(hidden_states)
+ return hidden_states
+
+
+class SwitchTransformersExperts(nn.ModuleDict):
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__()
+ self.num_experts = config.num_experts
+ for idx in range(config.num_experts):
+ self[f"expert_{idx}"] = SwitchTransformersDenseActDense(config)
+
+ def forward(
+ self, hidden_states: torch.Tensor, selected_experts: torch.Tensor, routing_weights: torch.Tensor
+ ) -> torch.Tensor:
+ final_hidden_states = torch.zeros_like(hidden_states)
+ expert_mask = selected_experts.permute(2, 1, 0)
+
+ expert_hit = torch.greater(expert_mask.sum(dim=(-1, -2)), 0).nonzero()
+ for expert_idx in expert_hit:
+ idx, top_x = torch.where(expert_mask[expert_idx].squeeze(0))
+ current_state = hidden_states[None, top_x].reshape(-1, hidden_states.shape[-1])
+ current_hidden_states = self[f"expert_{expert_idx[0]}"](current_state) * routing_weights[top_x, idx, None]
+ final_hidden_states.index_add_(0, top_x, current_hidden_states.to(hidden_states.dtype))
+ return final_hidden_states
+
+
+class SwitchTransformersSparseMLP(nn.Module): # inherit from mixtral
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__()
+ self.router = SwitchTransformersTop1Router(config)
+ self.experts = SwitchTransformersExperts(config)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ batch_size, sequence_length, hidden_dim = hidden_states.shape
+ hidden_states = hidden_states.view(-1, hidden_dim)
+ _, selected_experts, routing_weights = self.router(hidden_states)
+ hidden_states = self.experts(hidden_states, selected_experts, routing_weights)
+ hidden_states = hidden_states.reshape(batch_size, sequence_length, hidden_dim)
+ return hidden_states
+
+
+class SwitchTransformersLayerFF(nn.Module):
+ r"""
+ Switch Transformers Feed Forward layer module. This is a wrapper around the Mixture of Experts module.
+
+ Parameters:
+ config : ([`SwitchTransformersConfig`]): Model configuration class with all the parameters of the model.
+ Initializing with a config file does not load the weights associated with the model, only the
+ configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+ is_sparse (`bool`):
+ Whether the MLP layer is a `Sparse` layer (contains a Mixture of Experts) or not
+ """
+
+ def __init__(self, config: SwitchTransformersConfig, is_sparse=False):
+ super().__init__()
+ self.is_sparse = is_sparse
+
+ # Check if it is a sparse layer, if not then it is a dense layer
+ if not self.is_sparse:
+ self.mlp = SwitchTransformersDenseActDense(config)
+ else:
+ self.mlp = SwitchTransformersSparseMLP(config)
+
+ self.layer_norm = SwitchTransformersLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(self, hidden_states, **kwargs):
+ forwarded_states = self.layer_norm(hidden_states)
+ forwarded_states = self.mlp(forwarded_states)
+ output = hidden_states + self.dropout(forwarded_states)
+ return output
+
+
+class SwitchTransformersAttention(nn.Module):
+ def __init__(
+ self,
+ config: SwitchTransformersConfig,
+ has_relative_attention_bias=False,
+ layer_idx: int | None = None,
+ ):
+ super().__init__()
+ self.is_decoder = config.is_decoder
+ self.has_relative_attention_bias = has_relative_attention_bias
+ self.relative_attention_num_buckets = config.relative_attention_num_buckets
+ self.relative_attention_max_distance = config.relative_attention_max_distance
+ self.d_model = config.d_model
+ self.key_value_proj_dim = config.d_kv
+ self.n_heads = config.num_heads
+ self.dropout = config.dropout_rate
+ self.inner_dim = self.n_heads * self.key_value_proj_dim
+ self.layer_idx = layer_idx
+ if layer_idx is None and self.is_decoder:
+ logger.warning_once(
+ f"Instantiating a decoder {self.__class__.__name__} without passing `layer_idx` is not recommended and "
+ "will to errors during the forward call, if caching is used. Please make sure to provide a `layer_idx` "
+ "when creating this class."
+ )
+
+ self.q = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.k = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.v = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.o = nn.Linear(self.inner_dim, self.d_model, bias=False)
+
+ if self.has_relative_attention_bias:
+ self.relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets, self.n_heads)
+
+ self.gradient_checkpointing = False
+
+ @staticmethod
+ def _relative_position_bucket(relative_position, bidirectional=True, num_buckets=32, max_distance=128):
+ """
+ Adapted from Mesh Tensorflow:
+ https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593
+
+ Translate relative position to a bucket number for relative attention. The relative position is defined as
+ memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to
+ position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for
+ small absolute relative_position and larger buckets for larger absolute relative_positions. All relative
+ positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket.
+ This should allow for more graceful generalization to longer sequences than the model has been trained on
+
+ Args:
+ relative_position: an int32 Tensor
+ bidirectional: a boolean - whether the attention is bidirectional
+ num_buckets: an integer
+ max_distance: an integer
+
+ Returns:
+ a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets)
+ """
+ relative_buckets = 0
+ if bidirectional:
+ num_buckets //= 2
+ relative_buckets += (relative_position > 0).to(torch.long) * num_buckets
+ relative_position = torch.abs(relative_position)
+ else:
+ relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
+ # now relative_position is in the range [0, inf)
+
+ # half of the buckets are for exact increments in positions
+ max_exact = num_buckets // 2
+ is_small = relative_position < max_exact
+
+ # The other half of the buckets are for logarithmically bigger bins in positions up to max_distance
+ relative_position_if_large = max_exact + (
+ torch.log(relative_position.float() / max_exact)
+ / math.log(max_distance / max_exact)
+ * (num_buckets - max_exact)
+ ).to(torch.long)
+ relative_position_if_large = torch.min(
+ relative_position_if_large, torch.full_like(relative_position_if_large, num_buckets - 1)
+ )
+
+ relative_buckets += torch.where(is_small, relative_position, relative_position_if_large)
+ return relative_buckets
+
+ def compute_bias(self, query_length, key_length, device=None, past_seen_tokens=0):
+ """Compute binned relative position bias"""
+ if device is None:
+ device = self.relative_attention_bias.weight.device
+ context_position = torch.arange(query_length, dtype=torch.long, device=device)[:, None] + past_seen_tokens
+ memory_position = torch.arange(key_length, dtype=torch.long, device=device)[None, :]
+ relative_position = memory_position - context_position # shape (query_length, key_length)
+ relative_position_bucket = self._relative_position_bucket(
+ relative_position, # shape (query_length, key_length)
+ bidirectional=(not self.is_decoder),
+ num_buckets=self.relative_attention_num_buckets,
+ max_distance=self.relative_attention_max_distance,
+ )
+ values = self.relative_attention_bias(relative_position_bucket) # shape (query_length, key_length, num_heads)
+ values = values.permute([2, 0, 1]).unsqueeze(0) # shape (1, num_heads, query_length, key_length)
+ return values
+
+ def forward(
+ self,
+ hidden_states,
+ mask=None,
+ key_value_states=None,
+ position_bias=None,
+ past_key_values=None,
+ output_attentions=False,
+ **kwargs,
+ ):
+ """
+ Self-attention (if key_value_states is None) or attention over source sentence (provided by key_value_states).
+ """
+ # Input is (batch_size, seq_length, dim)
+ # Mask is (batch_size, 1, 1, key_length) (non-causal encoder) or (batch_size, 1, seq_length, key_length) (causal decoder)
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.key_value_proj_dim)
+ past_seen_tokens = past_key_values.get_seq_length(self.layer_idx) if past_key_values is not None else 0
+ # We clone here for StaticCache, as we get the value before updating it, but use it after and it's the same ref
+ past_seen_tokens = past_seen_tokens.clone() if isinstance(past_seen_tokens, torch.Tensor) else past_seen_tokens
+
+ # if key_value_states are provided this layer is used as a cross-attention layer for the decoder
+ is_cross_attention = key_value_states is not None
+
+ query_states = self.q(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ # Check is encoder-decoder model is being used. Otherwise we'll get `DynamicCache`
+ is_updated = False
+ if isinstance(past_key_values, EncoderDecoderCache):
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ if is_cross_attention:
+ # after the first generated id, we can subsequently re-use all key/value_states from cache
+ curr_past_key_values = past_key_values.cross_attention_cache
+ else:
+ curr_past_key_values = past_key_values.self_attention_cache
+ else:
+ curr_past_key_values = past_key_values
+
+ current_states = key_value_states if is_cross_attention else hidden_states
+ if is_cross_attention and past_key_values is not None and is_updated:
+ # reuse k,v, cross_attentions
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+ else:
+ kv_shape = (*current_states.shape[:-1], -1, self.key_value_proj_dim)
+ key_states = self.k(current_states).view(kv_shape).transpose(1, 2)
+ value_states = self.v(current_states).view(kv_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+ if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+ past_key_values.is_updated[self.layer_idx] = True
+
+ # compute scores, equivalent of torch.einsum("bnqd,bnkd->bnqk", query_states, key_states), compatible with onnx op>9
+ scores = torch.matmul(query_states, key_states.transpose(3, 2))
+
+ if position_bias is None:
+ key_length = key_states.shape[-2]
+ if not self.has_relative_attention_bias:
+ position_bias = torch.zeros(
+ (1, query_states.shape[1], input_shape[1], key_length), device=scores.device, dtype=scores.dtype
+ )
+ if self.gradient_checkpointing and self.training:
+ position_bias.requires_grad = True
+ else:
+ position_bias = self.compute_bias(
+ input_shape[1], key_length, device=scores.device, past_seen_tokens=past_seen_tokens
+ )
+
+ if mask is not None:
+ causal_mask = mask[:, :, :, : key_states.shape[-2]]
+ position_bias = position_bias + causal_mask
+
+ position_bias_masked = position_bias
+ scores += position_bias_masked
+
+ # (batch_size, n_heads, seq_length, key_length)
+ attn_weights = nn.functional.softmax(scores.float(), dim=-1).type_as(scores)
+ attn_weights = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+ attn_output = torch.matmul(attn_weights, value_states)
+
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ attn_output = attn_output.reshape(*input_shape, -1)
+ attn_output = self.o(attn_output)
+
+ outputs = (attn_output, position_bias)
+
+ if output_attentions:
+ outputs = outputs + (attn_weights,)
+ return outputs
+
+
+class SwitchTransformersLayerSelfAttention(nn.Module):
+ def __init__(self, config, has_relative_attention_bias=False, layer_idx: int | None = None):
+ super().__init__()
+ self.SelfAttention = SwitchTransformersAttention(
+ config, has_relative_attention_bias=has_relative_attention_bias, layer_idx=layer_idx
+ )
+ self.layer_norm = SwitchTransformersLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ position_bias=None,
+ past_key_values=None,
+ use_cache=False,
+ output_attentions=False,
+ **kwargs,
+ ):
+ normed_hidden_states = self.layer_norm(hidden_states)
+ attention_output = self.SelfAttention(
+ normed_hidden_states,
+ mask=attention_mask,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ )
+ hidden_states = hidden_states + self.dropout(attention_output[0])
+ outputs = (hidden_states,) + attention_output[1:] # add attentions if we output them
+ return outputs
+
+
+class SwitchTransformersLayerCrossAttention(nn.Module):
+ def __init__(self, config, layer_idx: int | None = None):
+ super().__init__()
+ self.EncDecAttention = SwitchTransformersAttention(
+ config, has_relative_attention_bias=False, layer_idx=layer_idx
+ )
+ self.layer_norm = SwitchTransformersLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states,
+ key_value_states,
+ attention_mask=None,
+ position_bias=None,
+ past_key_values=None,
+ output_attentions=False,
+ **kwargs,
+ ):
+ normed_hidden_states = self.layer_norm(hidden_states)
+ attention_output = self.EncDecAttention(
+ normed_hidden_states,
+ mask=attention_mask,
+ key_value_states=key_value_states,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+ layer_output = hidden_states + self.dropout(attention_output[0])
+ outputs = (layer_output,) + attention_output[1:] # add attentions if we output them
+ return outputs
+
+
+class SwitchTransformersBlock(GradientCheckpointingLayer):
+ def __init__(self, config, has_relative_attention_bias=False, is_sparse=False, layer_idx: int | None = None):
+ super().__init__()
+ self.is_decoder = config.is_decoder
+ self.is_sparse = is_sparse
+ self.layer = nn.ModuleList()
+ self.layer.append(
+ SwitchTransformersLayerSelfAttention(
+ config, has_relative_attention_bias=has_relative_attention_bias, layer_idx=layer_idx
+ )
+ )
+ if self.is_decoder:
+ self.layer.append(SwitchTransformersLayerCrossAttention(config, layer_idx=layer_idx))
+
+ self.layer.append(SwitchTransformersLayerFF(config, is_sparse=self.is_sparse))
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ position_bias=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ encoder_decoder_position_bias=None,
+ past_key_values=None,
+ use_cache=False,
+ **kwargs,
+ ):
+ hidden_states, _ = self.layer[0](
+ hidden_states,
+ attention_mask=attention_mask,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ )
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16 and torch.isinf(hidden_states).any():
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ do_cross_attention = self.is_decoder and encoder_hidden_states is not None
+ if do_cross_attention:
+ hidden_states, _ = self.layer[1](
+ hidden_states,
+ key_value_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ position_bias=encoder_decoder_position_bias,
+ past_key_values=past_key_values,
+ )
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16 and torch.isinf(hidden_states).any():
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ hidden_states = self.layer[-1](hidden_states)
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16 and torch.isinf(hidden_states).any():
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+ return hidden_states
+
+
+@auto_docstring
+class SwitchTransformersPreTrainedModel(PreTrainedModel):
+ config: SwitchTransformersConfig
+ base_model_prefix = "switch_transformers"
+ supports_gradient_checkpointing = True
+ _can_compile_fullgraph = False
+ _no_split_modules = ["SwitchTransformersBlock"]
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ factor = self.config.initializer_factor # Used for testing weights initialization
+ if isinstance(module, SwitchTransformersLayerNorm):
+ init.constant_(module.weight, factor * 1.0)
+ elif isinstance(
+ module,
+ (SwitchTransformersModel, SwitchTransformersForConditionalGeneration, SwitchTransformersEncoderModel),
+ ):
+ init.normal_(module.shared.weight, mean=0.0, std=factor * 1.0)
+ if hasattr(module, "lm_head") and not self.config.tie_word_embeddings:
+ init.normal_(module.lm_head.weight, mean=0.0, std=factor * 1.0)
+ elif isinstance(module, SwitchTransformersDenseActDense):
+ init.normal_(module.wi.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi, "bias") and module.wi.bias is not None:
+ init.zeros_(module.wi.bias)
+ init.normal_(module.wo.weight, mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
+ if hasattr(module.wo, "bias") and module.wo.bias is not None:
+ init.zeros_(module.wo.bias)
+ elif isinstance(module, SwitchTransformersAttention):
+ d_model = self.config.d_model
+ key_value_proj_dim = self.config.d_kv
+ n_heads = self.config.num_heads
+ init.normal_(module.q.weight, mean=0.0, std=factor * ((d_model * key_value_proj_dim) ** -0.5))
+ init.normal_(module.k.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.v.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.o.weight, mean=0.0, std=factor * ((n_heads * key_value_proj_dim) ** -0.5))
+ if module.has_relative_attention_bias:
+ init.normal_(module.relative_attention_bias.weight, mean=0.0, std=factor * ((d_model) ** -0.5))
+ elif isinstance(module, SwitchTransformersSparseMLP):
+ d_model = self.config.d_model
+ key_value_proj_dim = self.config.d_kv
+ n_heads = self.config.num_heads
+ init.normal_(module.router.classifier.weight, mean=0.0, std=factor * 1)
+ for idx in range(self.config.num_experts):
+ init.normal_(module.experts[f"expert_{idx}"].wi.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.experts[f"expert_{idx}"].wo.weight, mean=0.0, std=factor * (d_model**-0.5))
+
+ def _shift_right(self, input_ids):
+ decoder_start_token_id = self.config.decoder_start_token_id
+ pad_token_id = self.config.pad_token_id
+
+ if decoder_start_token_id is None:
+ raise ValueError(
+ "self.model.config.decoder_start_token_id has to be defined. In SwitchTransformers it is usually set"
+ " to the pad_token_id. See SwitchTransformers docs for more information"
+ )
+
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
+ shifted_input_ids[..., 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.pad_token_id has to be defined.")
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+class SwitchTransformersStack(SwitchTransformersPreTrainedModel):
+ _can_record_outputs = {
+ "hidden_states": SwitchTransformersBlock,
+ "attentions": OutputRecorder(SwitchTransformersAttention, index=-1, layer_name="layer.0"),
+ "cross_attentions": OutputRecorder(SwitchTransformersAttention, index=-1, layer_name="layer.1"),
+ "router_logits": OutputRecorder(SwitchTransformersTop1Router, index=2),
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.d_model)
+
+ self.is_decoder = config.is_decoder
+
+ sparse_step = config.decoder_sparse_step if self.is_decoder else config.encoder_sparse_step
+ config.num_layers = config.num_decoder_layers if self.is_decoder else config.num_layers
+ self.block = nn.ModuleList()
+ for i in range(config.num_layers):
+ is_sparse = (i % sparse_step == 1 or sparse_step == 1) if sparse_step > 0 else False
+
+ self.block.append(
+ SwitchTransformersBlock(
+ config, has_relative_attention_bias=bool(i == 0), is_sparse=is_sparse, layer_idx=i
+ )
+ )
+
+ self.final_layer_norm = SwitchTransformersLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.post_init()
+
+ self.gradient_checkpointing = False
+
+ @merge_with_config_defaults
+ @capture_outputs
+ def forward(
+ self,
+ input_ids=None,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ inputs_embeds=None,
+ past_key_values=None,
+ use_cache=None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | MoEModelOutputWithPastAndCrossAttentions:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ if inputs_embeds is None:
+ if self.embed_tokens is None:
+ raise ValueError("You have to initialize the model with valid token embeddings")
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ batch_size, seq_length = inputs_embeds.shape[:2]
+
+ if use_cache is True:
+ if not self.is_decoder:
+ raise ValueError(f"`use_cache` can only be set to `True` if {self} is used as a decoder")
+
+ if self.is_decoder:
+ if use_cache and past_key_values is None:
+ if self.config.is_encoder_decoder:
+ past_key_values = EncoderDecoderCache(
+ DynamicCache(config=self.config), DynamicCache(config=self.config)
+ )
+ else:
+ past_key_values = DynamicCache(config=self.config)
+ elif not self.is_decoder:
+ # do not pass cache object down the line for encoder stack
+ # it messes indexing later in decoder-stack because cache object is modified in-place
+ past_key_values = None
+
+ past_key_values_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+ if attention_mask is None and not is_torchdynamo_compiling():
+ # required mask seq length can be calculated via length of past cache
+ mask_seq_length = past_key_values_length + seq_length
+ attention_mask = torch.ones(batch_size, mask_seq_length, device=inputs_embeds.device)
+
+ if self.config.is_decoder:
+ causal_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+ else:
+ causal_mask = attention_mask[:, None, None, :]
+ causal_mask = causal_mask.to(dtype=inputs_embeds.dtype)
+ causal_mask = (1.0 - causal_mask) * torch.finfo(inputs_embeds.dtype).min
+
+ if encoder_attention_mask is not None:
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+
+ position_bias = None
+ encoder_decoder_position_bias = None
+
+ hidden_states = self.dropout(inputs_embeds)
+
+ for i, layer_module in enumerate(self.block):
+ hidden_states = layer_module(
+ hidden_states,
+ causal_mask,
+ position_bias,
+ encoder_hidden_states,
+ encoder_attention_mask,
+ encoder_decoder_position_bias,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = self.final_layer_norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ return MoEModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class SwitchTransformersModel(SwitchTransformersPreTrainedModel):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ }
+ _input_embed_layer = "shared"
+
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__(config)
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = SwitchTransformersStack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ self.decoder = SwitchTransformersStack(decoder_config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ decoder_inputs_embeds: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqMoEModelOutput:
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids, attention_mask=attention_mask, inputs_embeds=inputs_embeds, **kwargs
+ )
+
+ hidden_states = encoder_outputs[0]
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ **kwargs,
+ )
+
+ return Seq2SeqMoEModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ decoder_router_logits=decoder_outputs.router_logits,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ encoder_router_logits=encoder_outputs.router_logits,
+ )
+
+
+####################################################
+# This dict contains ids and associated url
+# for the pretrained weights provided with the models
+####################################################
+
+
+def router_z_loss_func(router_logits: torch.Tensor) -> float:
+ r"""
+ Compute the router z-loss implemented in PyTorch.
+
+ The router z-loss was introduced in [Designing Effective Sparse Expert Models](https://huggingface.co/papers/2202.08906).
+ It encourages router logits to remain small in an effort to improve stability.
+
+ Args:
+ router_logits (`float`):
+ Input logits of shape [batch_size, sequence_length, num_experts]
+
+ Returns:
+ Scalar router z-loss.
+ """
+ num_groups, tokens_per_group, _ = router_logits.shape
+ log_z = torch.logsumexp(router_logits, dim=-1)
+ z_loss = log_z**2
+ return torch.sum(z_loss) / (num_groups * tokens_per_group)
+
+
+def load_balancing_loss_func(router_probs: torch.Tensor, expert_indices: torch.Tensor) -> float:
+ r"""
+ Computes auxiliary load balancing loss as in Switch Transformer - implemented in Pytorch.
+
+ See Switch Transformer (https://huggingface.co/papers/2101.03961) for more details. This function implements the loss
+ function presented in equations (4) - (6) of the paper. It aims at penalizing cases where the routing between
+ experts is too unbalanced.
+
+ Args:
+ router_probs (`torch.Tensor`):
+ Probability assigned to each expert per token. Shape: [batch_size, sequence_length, num_experts].
+ expert_indices (`torch.Tensor`):
+ Indices tensor of shape [batch_size, sequence_length] identifying the selected expert for a given token.
+
+ Returns:
+ The auxiliary loss.
+ """
+ num_experts = router_probs.shape[-1]
+
+ # cast the expert indices to int64, otherwise one-hot encoding will fail
+ if expert_indices.dtype != torch.int64:
+ expert_indices = expert_indices.to(torch.int64)
+
+ if len(expert_indices.shape) == 2:
+ expert_indices = expert_indices.unsqueeze(2)
+
+ expert_mask = torch.nn.functional.one_hot(expert_indices, num_experts)
+
+ # For a given token, determine if it was routed to a given expert.
+ expert_mask = torch.max(expert_mask, axis=-2).values
+
+ # cast to float32 otherwise mean will fail
+ expert_mask = expert_mask.to(torch.float32)
+ tokens_per_group_and_expert = torch.mean(expert_mask, axis=-2)
+
+ router_prob_per_group_and_expert = torch.mean(router_probs, axis=-2)
+ return torch.mean(tokens_per_group_and_expert * router_prob_per_group_and_expert) * (num_experts**2)
+
+
+@auto_docstring(
+ custom_intro="""
+ SWITCH_TRANSFORMERS Model with a `language modeling` head on top.
+ """
+)
+class SwitchTransformersForConditionalGeneration(SwitchTransformersPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ "lm_head.weight": "shared.weight",
+ }
+
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__(config)
+ self.model_dim = config.d_model
+
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = SwitchTransformersStack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = SwitchTransformersStack(decoder_config)
+
+ self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
+
+ self.router_z_loss_coef = config.router_z_loss_coef
+ self.router_aux_loss_coef = config.router_aux_loss_coef
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.Tensor]] | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ output_router_logits: bool | None = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqMoEOutput:
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_router_logits=output_router_logits,
+ **kwargs,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
+ # get decoder inputs from shifting lm labels to the right
+ decoder_input_ids = self._shift_right(labels)
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ output_router_logits=output_router_logits,
+ **kwargs,
+ )
+
+ sequence_output = decoder_outputs.last_hidden_state
+
+ if self.config.tie_word_embeddings:
+ # Rescale output before projecting on vocab
+ # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/transformer.py#L586
+ sequence_output = sequence_output * (self.model_dim**-0.5)
+
+ lm_logits = self.lm_head(sequence_output)
+
+ loss = None
+ encoder_z_loss = None
+ encoder_aux_loss = None
+ decoder_z_loss = None
+ decoder_aux_loss = None
+
+ if output_router_logits:
+ # Compute the router loss (z_loss + auxiliary loss) for each router in the encoder and decoder
+ if self.encoder.config.encoder_sparse_step > 1:
+ encoder_router_logits, encoder_expert_indexes = self._unpack_router_logits(encoder_outputs[-1])
+ encoder_z_loss = router_z_loss_func(encoder_router_logits)
+ encoder_router_probs = nn.Softmax(dim=-1)(encoder_router_logits)
+ encoder_aux_loss = load_balancing_loss_func(encoder_router_probs, encoder_expert_indexes)
+ else:
+ encoder_z_loss = 0
+ encoder_aux_loss = 0
+
+ if self.decoder.config.decoder_sparse_step > 1:
+ decoder_router_logits, decoder_expert_indexes = self._unpack_router_logits(decoder_outputs[-1])
+ decoder_z_loss = router_z_loss_func(decoder_router_logits)
+ decoder_router_probs = nn.Softmax(dim=-1)(decoder_router_logits)
+ decoder_aux_loss = load_balancing_loss_func(decoder_router_probs, decoder_expert_indexes)
+ else:
+ decoder_z_loss = 0
+ decoder_aux_loss = 0
+
+ if labels is not None:
+ loss_fct = CrossEntropyLoss(ignore_index=-100)
+ # move labels to correct device to enable PP
+ labels = labels.to(lm_logits.device)
+ loss = loss_fct(lm_logits.view(-1, lm_logits.size(-1)), labels.view(-1))
+
+ if output_router_logits:
+ z_loss = self.router_z_loss_coef * (encoder_z_loss + decoder_z_loss)
+ aux_loss = self.router_aux_loss_coef * (encoder_aux_loss + decoder_aux_loss)
+ loss = loss + z_loss + aux_loss
+
+ return Seq2SeqMoEOutput(
+ loss=loss,
+ logits=lm_logits,
+ encoder_z_loss=encoder_z_loss,
+ encoder_aux_loss=encoder_aux_loss,
+ decoder_z_loss=decoder_z_loss,
+ decoder_aux_loss=decoder_aux_loss,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ decoder_router_logits=decoder_outputs.router_logits,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ encoder_router_logits=encoder_outputs.router_logits,
+ )
+
+ def _unpack_router_logits(self, router_outputs):
+ total_router_logits = []
+ total_expert_indexes = []
+ for router_output in router_outputs:
+ if len(router_output[0].shape) > 1:
+ router_logits, expert_indexes = router_output
+ total_router_logits.append(router_logits)
+ total_expert_indexes.append(expert_indexes)
+ return torch.cat(total_router_logits, dim=1), torch.cat(total_expert_indexes, dim=1)
+
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+ return self._shift_right(labels)
+
+
+class SwitchTransformersEncoderModel(SwitchTransformersPreTrainedModel):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ }
+
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__(config)
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.use_cache = False
+ encoder_config.is_encoder_decoder = False
+ self.encoder = SwitchTransformersStack(encoder_config)
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | MoEModelOutput:
+ use_cache = False
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return encoder_outputs
+
+
+__all__ = [
+ "SwitchTransformersEncoderModel",
+ "SwitchTransformersForConditionalGeneration",
+ "SwitchTransformersModel",
+ "SwitchTransformersPreTrainedModel",
+ "SwitchTransformersTop1Router",
+ "SwitchTransformersSparseMLP",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/switch_transformers/modular_switch_transformers.py b/lib/python3.11/site-packages/transformers/models/switch_transformers/modular_switch_transformers.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc1ea6be960e7542869fd4e350fd5bc789bdf84d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/switch_transformers/modular_switch_transformers.py
@@ -0,0 +1,810 @@
+# Copyright 2022 SwitchTransformers Authors and 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.
+"""PyTorch SwitchTransformers model."""
+
+import copy
+
+import torch
+import torch.nn as nn
+from torch.nn import CrossEntropyLoss
+
+from ... import initialization as init
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ MoEModelOutput,
+ MoEModelOutputWithPastAndCrossAttentions,
+ Seq2SeqMoEModelOutput,
+ Seq2SeqMoEOutput,
+)
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import (
+ TransformersKwargs,
+ auto_docstring,
+ is_torchdynamo_compiling,
+ logging,
+)
+from ...utils.generic import (
+ can_return_tuple,
+ merge_with_config_defaults,
+)
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from ..t5.modeling_t5 import T5Attention, T5DenseActDense, T5LayerCrossAttention, T5LayerNorm, T5LayerSelfAttention
+from .configuration_switch_transformers import SwitchTransformersConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+####################################################
+# This dict contains ids and associated url
+# for the pretrained weights provided with the models
+####################################################
+
+
+def router_z_loss_func(router_logits: torch.Tensor) -> float:
+ r"""
+ Compute the router z-loss implemented in PyTorch.
+
+ The router z-loss was introduced in [Designing Effective Sparse Expert Models](https://huggingface.co/papers/2202.08906).
+ It encourages router logits to remain small in an effort to improve stability.
+
+ Args:
+ router_logits (`float`):
+ Input logits of shape [batch_size, sequence_length, num_experts]
+
+ Returns:
+ Scalar router z-loss.
+ """
+ num_groups, tokens_per_group, _ = router_logits.shape
+ log_z = torch.logsumexp(router_logits, dim=-1)
+ z_loss = log_z**2
+ return torch.sum(z_loss) / (num_groups * tokens_per_group)
+
+
+def load_balancing_loss_func(router_probs: torch.Tensor, expert_indices: torch.Tensor) -> float:
+ r"""
+ Computes auxiliary load balancing loss as in Switch Transformer - implemented in Pytorch.
+
+ See Switch Transformer (https://huggingface.co/papers/2101.03961) for more details. This function implements the loss
+ function presented in equations (4) - (6) of the paper. It aims at penalizing cases where the routing between
+ experts is too unbalanced.
+
+ Args:
+ router_probs (`torch.Tensor`):
+ Probability assigned to each expert per token. Shape: [batch_size, sequence_length, num_experts].
+ expert_indices (`torch.Tensor`):
+ Indices tensor of shape [batch_size, sequence_length] identifying the selected expert for a given token.
+
+ Returns:
+ The auxiliary loss.
+ """
+ num_experts = router_probs.shape[-1]
+
+ # cast the expert indices to int64, otherwise one-hot encoding will fail
+ if expert_indices.dtype != torch.int64:
+ expert_indices = expert_indices.to(torch.int64)
+
+ if len(expert_indices.shape) == 2:
+ expert_indices = expert_indices.unsqueeze(2)
+
+ expert_mask = torch.nn.functional.one_hot(expert_indices, num_experts)
+
+ # For a given token, determine if it was routed to a given expert.
+ expert_mask = torch.max(expert_mask, axis=-2).values
+
+ # cast to float32 otherwise mean will fail
+ expert_mask = expert_mask.to(torch.float32)
+ tokens_per_group_and_expert = torch.mean(expert_mask, axis=-2)
+
+ router_prob_per_group_and_expert = torch.mean(router_probs, axis=-2)
+ return torch.mean(tokens_per_group_and_expert * router_prob_per_group_and_expert) * (num_experts**2)
+
+
+class SwitchTransformersTop1Router(nn.Module):
+ """
+ Router using tokens choose top-1 experts assignment.
+
+ This router uses the same mechanism as in Switch Transformer (https://huggingface.co/papers/2101.03961) and V-MoE
+ (https://huggingface.co/papers/2106.05974): tokens choose their top experts. Items are sorted by router_probs and then
+ routed to their choice of expert until the expert's expert_capacity is reached. **There is no guarantee that each
+ token is processed by an expert**, or that each expert receives at least one token.
+
+ """
+
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__()
+ self.num_experts = config.num_experts
+ self.expert_capacity = config.expert_capacity
+ self.classifier = nn.Linear(config.hidden_size, self.num_experts, bias=config.router_bias)
+ self.jitter_noise = config.router_jitter_noise
+ self.ignore_padding_tokens = config.router_ignore_padding_tokens
+ self.dtype = getattr(torch, config.router_dtype)
+
+ def forward(self, hidden_states: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ r"""
+ Computes router probabilities from input hidden states.
+
+ Args:
+ hidden_states (`torch.Tensor`):
+ (batch_size, sequence_length, hidden_dim) from which router probabilities are computed.
+ Returns:
+ router_probabilities (`torch.Tensor`):
+ Tensor of shape (batch_size, sequence_length, num_experts) corresponding to the probabilities for each
+ token and expert. Used for routing tokens to experts.
+ router_logits (`torch.Tensor`):
+ Logits tensor of shape (batch_size, sequence_length, num_experts) corresponding to raw router logits.
+ This is used later for computing router z-loss.
+ """
+ # float32 is used to ensure stability. See the discussion of "selective precision" in
+ # https://huggingface.co/papers/2101.03961.
+ # We also store the previous dtype to cast back the output to the previous dtype
+ self.input_dtype = hidden_states.dtype
+ hidden_states = hidden_states.to(self.dtype)
+ if self.training and self.jitter_noise > 0:
+ # Multiply the token inputs by the uniform distribution - adding some noise
+ hidden_states *= torch.empty_like(hidden_states).uniform_(1.0 - self.jitter_noise, 1.0 + self.jitter_noise)
+ self.classifier = self.classifier.to(self.dtype)
+ router_logits = self.classifier(hidden_states)
+
+ # Apply Softmax and cast back to the original `dtype`
+ router_probs = nn.functional.softmax(router_logits, dim=-1, dtype=self.dtype).to(self.input_dtype)
+ router_logits, expert_index = torch.max(router_probs, dim=-1, keepdim=True)
+ expert_index = torch.nn.functional.one_hot(expert_index, num_classes=self.num_experts)
+ token_priority = torch.cumsum(expert_index, dim=-2)
+ # mask if the token routed to the expert will overflow
+ expert_capacity_mask = token_priority <= self.expert_capacity
+ expert_index = expert_index * expert_capacity_mask
+ router_probs = torch.max(router_probs, dim=-1).values.unsqueeze(-1)
+ return router_probs, expert_index, router_logits
+
+
+class SwitchTransformersLayerNorm(T5LayerNorm):
+ pass
+
+
+class SwitchTransformersDenseActDense(T5DenseActDense):
+ pass
+
+
+class SwitchTransformersExperts(nn.ModuleDict):
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__()
+ self.num_experts = config.num_experts
+ for idx in range(config.num_experts):
+ self[f"expert_{idx}"] = SwitchTransformersDenseActDense(config)
+
+ def forward(
+ self, hidden_states: torch.Tensor, selected_experts: torch.Tensor, routing_weights: torch.Tensor
+ ) -> torch.Tensor:
+ final_hidden_states = torch.zeros_like(hidden_states)
+ expert_mask = selected_experts.permute(2, 1, 0)
+
+ expert_hit = torch.greater(expert_mask.sum(dim=(-1, -2)), 0).nonzero()
+ for expert_idx in expert_hit:
+ idx, top_x = torch.where(expert_mask[expert_idx].squeeze(0))
+ current_state = hidden_states[None, top_x].reshape(-1, hidden_states.shape[-1])
+ current_hidden_states = self[f"expert_{expert_idx[0]}"](current_state) * routing_weights[top_x, idx, None]
+ final_hidden_states.index_add_(0, top_x, current_hidden_states.to(hidden_states.dtype))
+ return final_hidden_states
+
+
+class SwitchTransformersSparseMLP(nn.Module): # inherit from mixtral
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__()
+ self.router = SwitchTransformersTop1Router(config)
+ self.experts = SwitchTransformersExperts(config)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ batch_size, sequence_length, hidden_dim = hidden_states.shape
+ hidden_states = hidden_states.view(-1, hidden_dim)
+ _, selected_experts, routing_weights = self.router(hidden_states)
+ hidden_states = self.experts(hidden_states, selected_experts, routing_weights)
+ hidden_states = hidden_states.reshape(batch_size, sequence_length, hidden_dim)
+ return hidden_states
+
+
+class SwitchTransformersLayerFF(nn.Module):
+ r"""
+ Switch Transformers Feed Forward layer module. This is a wrapper around the Mixture of Experts module.
+
+ Parameters:
+ config : ([`SwitchTransformersConfig`]): Model configuration class with all the parameters of the model.
+ Initializing with a config file does not load the weights associated with the model, only the
+ configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+ is_sparse (`bool`):
+ Whether the MLP layer is a `Sparse` layer (contains a Mixture of Experts) or not
+ """
+
+ def __init__(self, config: SwitchTransformersConfig, is_sparse=False):
+ super().__init__()
+ self.is_sparse = is_sparse
+
+ # Check if it is a sparse layer, if not then it is a dense layer
+ if not self.is_sparse:
+ self.mlp = SwitchTransformersDenseActDense(config)
+ else:
+ self.mlp = SwitchTransformersSparseMLP(config)
+
+ self.layer_norm = SwitchTransformersLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(self, hidden_states, **kwargs):
+ forwarded_states = self.layer_norm(hidden_states)
+ forwarded_states = self.mlp(forwarded_states)
+ output = hidden_states + self.dropout(forwarded_states)
+ return output
+
+
+class SwitchTransformersAttention(T5Attention):
+ pass
+
+
+class SwitchTransformersLayerSelfAttention(T5LayerSelfAttention):
+ pass
+
+
+class SwitchTransformersLayerCrossAttention(T5LayerCrossAttention):
+ pass
+
+
+class SwitchTransformersBlock(GradientCheckpointingLayer):
+ def __init__(self, config, has_relative_attention_bias=False, is_sparse=False, layer_idx: int | None = None):
+ super().__init__()
+ self.is_decoder = config.is_decoder
+ self.is_sparse = is_sparse
+ self.layer = nn.ModuleList()
+ self.layer.append(
+ SwitchTransformersLayerSelfAttention(
+ config, has_relative_attention_bias=has_relative_attention_bias, layer_idx=layer_idx
+ )
+ )
+ if self.is_decoder:
+ self.layer.append(SwitchTransformersLayerCrossAttention(config, layer_idx=layer_idx))
+
+ self.layer.append(SwitchTransformersLayerFF(config, is_sparse=self.is_sparse))
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ position_bias=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ encoder_decoder_position_bias=None,
+ past_key_values=None,
+ use_cache=False,
+ **kwargs,
+ ):
+ hidden_states, _ = self.layer[0](
+ hidden_states,
+ attention_mask=attention_mask,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ )
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16 and torch.isinf(hidden_states).any():
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ do_cross_attention = self.is_decoder and encoder_hidden_states is not None
+ if do_cross_attention:
+ hidden_states, _ = self.layer[1](
+ hidden_states,
+ key_value_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ position_bias=encoder_decoder_position_bias,
+ past_key_values=past_key_values,
+ )
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16 and torch.isinf(hidden_states).any():
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ hidden_states = self.layer[-1](hidden_states)
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16 and torch.isinf(hidden_states).any():
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+ return hidden_states
+
+
+@auto_docstring
+class SwitchTransformersPreTrainedModel(PreTrainedModel):
+ config: SwitchTransformersConfig
+ base_model_prefix = "switch_transformers"
+ supports_gradient_checkpointing = True
+ _can_compile_fullgraph = False
+ _no_split_modules = ["SwitchTransformersBlock"]
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ factor = self.config.initializer_factor # Used for testing weights initialization
+ if isinstance(module, SwitchTransformersLayerNorm):
+ init.constant_(module.weight, factor * 1.0)
+ elif isinstance(
+ module,
+ (SwitchTransformersModel, SwitchTransformersForConditionalGeneration, SwitchTransformersEncoderModel),
+ ):
+ init.normal_(module.shared.weight, mean=0.0, std=factor * 1.0)
+ if hasattr(module, "lm_head") and not self.config.tie_word_embeddings:
+ init.normal_(module.lm_head.weight, mean=0.0, std=factor * 1.0)
+ elif isinstance(module, SwitchTransformersDenseActDense):
+ init.normal_(module.wi.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi, "bias") and module.wi.bias is not None:
+ init.zeros_(module.wi.bias)
+ init.normal_(module.wo.weight, mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
+ if hasattr(module.wo, "bias") and module.wo.bias is not None:
+ init.zeros_(module.wo.bias)
+ elif isinstance(module, SwitchTransformersAttention):
+ d_model = self.config.d_model
+ key_value_proj_dim = self.config.d_kv
+ n_heads = self.config.num_heads
+ init.normal_(module.q.weight, mean=0.0, std=factor * ((d_model * key_value_proj_dim) ** -0.5))
+ init.normal_(module.k.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.v.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.o.weight, mean=0.0, std=factor * ((n_heads * key_value_proj_dim) ** -0.5))
+ if module.has_relative_attention_bias:
+ init.normal_(module.relative_attention_bias.weight, mean=0.0, std=factor * ((d_model) ** -0.5))
+ elif isinstance(module, SwitchTransformersSparseMLP):
+ d_model = self.config.d_model
+ key_value_proj_dim = self.config.d_kv
+ n_heads = self.config.num_heads
+ init.normal_(module.router.classifier.weight, mean=0.0, std=factor * 1)
+ for idx in range(self.config.num_experts):
+ init.normal_(module.experts[f"expert_{idx}"].wi.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.experts[f"expert_{idx}"].wo.weight, mean=0.0, std=factor * (d_model**-0.5))
+
+ def _shift_right(self, input_ids):
+ decoder_start_token_id = self.config.decoder_start_token_id
+ pad_token_id = self.config.pad_token_id
+
+ if decoder_start_token_id is None:
+ raise ValueError(
+ "self.model.config.decoder_start_token_id has to be defined. In SwitchTransformers it is usually set"
+ " to the pad_token_id. See SwitchTransformers docs for more information"
+ )
+
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
+ shifted_input_ids[..., 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.pad_token_id has to be defined.")
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+class SwitchTransformersStack(SwitchTransformersPreTrainedModel):
+ _can_record_outputs = {
+ "hidden_states": SwitchTransformersBlock,
+ "attentions": OutputRecorder(SwitchTransformersAttention, index=-1, layer_name="layer.0"),
+ "cross_attentions": OutputRecorder(SwitchTransformersAttention, index=-1, layer_name="layer.1"),
+ "router_logits": OutputRecorder(SwitchTransformersTop1Router, index=2),
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.d_model)
+
+ self.is_decoder = config.is_decoder
+
+ sparse_step = config.decoder_sparse_step if self.is_decoder else config.encoder_sparse_step
+ config.num_layers = config.num_decoder_layers if self.is_decoder else config.num_layers
+ self.block = nn.ModuleList()
+ for i in range(config.num_layers):
+ is_sparse = (i % sparse_step == 1 or sparse_step == 1) if sparse_step > 0 else False
+
+ self.block.append(
+ SwitchTransformersBlock(
+ config, has_relative_attention_bias=bool(i == 0), is_sparse=is_sparse, layer_idx=i
+ )
+ )
+
+ self.final_layer_norm = SwitchTransformersLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.post_init()
+
+ self.gradient_checkpointing = False
+
+ @merge_with_config_defaults
+ @capture_outputs
+ def forward(
+ self,
+ input_ids=None,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ inputs_embeds=None,
+ past_key_values=None,
+ use_cache=None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | MoEModelOutputWithPastAndCrossAttentions:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ if inputs_embeds is None:
+ if self.embed_tokens is None:
+ raise ValueError("You have to initialize the model with valid token embeddings")
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ batch_size, seq_length = inputs_embeds.shape[:2]
+
+ if use_cache is True:
+ if not self.is_decoder:
+ raise ValueError(f"`use_cache` can only be set to `True` if {self} is used as a decoder")
+
+ if self.is_decoder:
+ if use_cache and past_key_values is None:
+ if self.config.is_encoder_decoder:
+ past_key_values = EncoderDecoderCache(
+ DynamicCache(config=self.config), DynamicCache(config=self.config)
+ )
+ else:
+ past_key_values = DynamicCache(config=self.config)
+ elif not self.is_decoder:
+ # do not pass cache object down the line for encoder stack
+ # it messes indexing later in decoder-stack because cache object is modified in-place
+ past_key_values = None
+
+ past_key_values_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+ if attention_mask is None and not is_torchdynamo_compiling():
+ # required mask seq length can be calculated via length of past cache
+ mask_seq_length = past_key_values_length + seq_length
+ attention_mask = torch.ones(batch_size, mask_seq_length, device=inputs_embeds.device)
+
+ if self.config.is_decoder:
+ causal_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+ else:
+ causal_mask = attention_mask[:, None, None, :]
+ causal_mask = causal_mask.to(dtype=inputs_embeds.dtype)
+ causal_mask = (1.0 - causal_mask) * torch.finfo(inputs_embeds.dtype).min
+
+ if encoder_attention_mask is not None:
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+
+ position_bias = None
+ encoder_decoder_position_bias = None
+
+ hidden_states = self.dropout(inputs_embeds)
+
+ for i, layer_module in enumerate(self.block):
+ hidden_states = layer_module(
+ hidden_states,
+ causal_mask,
+ position_bias,
+ encoder_hidden_states,
+ encoder_attention_mask,
+ encoder_decoder_position_bias,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = self.final_layer_norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ return MoEModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class SwitchTransformersModel(SwitchTransformersPreTrainedModel):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ }
+ _input_embed_layer = "shared"
+
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__(config)
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = SwitchTransformersStack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ self.decoder = SwitchTransformersStack(decoder_config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ decoder_inputs_embeds: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqMoEModelOutput:
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids, attention_mask=attention_mask, inputs_embeds=inputs_embeds, **kwargs
+ )
+
+ hidden_states = encoder_outputs[0]
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ **kwargs,
+ )
+
+ return Seq2SeqMoEModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ decoder_router_logits=decoder_outputs.router_logits,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ encoder_router_logits=encoder_outputs.router_logits,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ SWITCH_TRANSFORMERS Model with a `language modeling` head on top.
+ """
+)
+class SwitchTransformersForConditionalGeneration(SwitchTransformersPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ "lm_head.weight": "shared.weight",
+ }
+
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__(config)
+ self.model_dim = config.d_model
+
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = SwitchTransformersStack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = SwitchTransformersStack(decoder_config)
+
+ self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
+
+ self.router_z_loss_coef = config.router_z_loss_coef
+ self.router_aux_loss_coef = config.router_aux_loss_coef
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.Tensor]] | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ output_router_logits: bool | None = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqMoEOutput:
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_router_logits=output_router_logits,
+ **kwargs,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
+ # get decoder inputs from shifting lm labels to the right
+ decoder_input_ids = self._shift_right(labels)
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ output_router_logits=output_router_logits,
+ **kwargs,
+ )
+
+ sequence_output = decoder_outputs.last_hidden_state
+
+ if self.config.tie_word_embeddings:
+ # Rescale output before projecting on vocab
+ # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/transformer.py#L586
+ sequence_output = sequence_output * (self.model_dim**-0.5)
+
+ lm_logits = self.lm_head(sequence_output)
+
+ loss = None
+ encoder_z_loss = None
+ encoder_aux_loss = None
+ decoder_z_loss = None
+ decoder_aux_loss = None
+
+ if output_router_logits:
+ # Compute the router loss (z_loss + auxiliary loss) for each router in the encoder and decoder
+ if self.encoder.config.encoder_sparse_step > 1:
+ encoder_router_logits, encoder_expert_indexes = self._unpack_router_logits(encoder_outputs[-1])
+ encoder_z_loss = router_z_loss_func(encoder_router_logits)
+ encoder_router_probs = nn.Softmax(dim=-1)(encoder_router_logits)
+ encoder_aux_loss = load_balancing_loss_func(encoder_router_probs, encoder_expert_indexes)
+ else:
+ encoder_z_loss = 0
+ encoder_aux_loss = 0
+
+ if self.decoder.config.decoder_sparse_step > 1:
+ decoder_router_logits, decoder_expert_indexes = self._unpack_router_logits(decoder_outputs[-1])
+ decoder_z_loss = router_z_loss_func(decoder_router_logits)
+ decoder_router_probs = nn.Softmax(dim=-1)(decoder_router_logits)
+ decoder_aux_loss = load_balancing_loss_func(decoder_router_probs, decoder_expert_indexes)
+ else:
+ decoder_z_loss = 0
+ decoder_aux_loss = 0
+
+ if labels is not None:
+ loss_fct = CrossEntropyLoss(ignore_index=-100)
+ # move labels to correct device to enable PP
+ labels = labels.to(lm_logits.device)
+ loss = loss_fct(lm_logits.view(-1, lm_logits.size(-1)), labels.view(-1))
+
+ if output_router_logits:
+ z_loss = self.router_z_loss_coef * (encoder_z_loss + decoder_z_loss)
+ aux_loss = self.router_aux_loss_coef * (encoder_aux_loss + decoder_aux_loss)
+ loss = loss + z_loss + aux_loss
+
+ return Seq2SeqMoEOutput(
+ loss=loss,
+ logits=lm_logits,
+ encoder_z_loss=encoder_z_loss,
+ encoder_aux_loss=encoder_aux_loss,
+ decoder_z_loss=decoder_z_loss,
+ decoder_aux_loss=decoder_aux_loss,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ decoder_router_logits=decoder_outputs.router_logits,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ encoder_router_logits=encoder_outputs.router_logits,
+ )
+
+ def _unpack_router_logits(self, router_outputs):
+ total_router_logits = []
+ total_expert_indexes = []
+ for router_output in router_outputs:
+ if len(router_output[0].shape) > 1:
+ router_logits, expert_indexes = router_output
+ total_router_logits.append(router_logits)
+ total_expert_indexes.append(expert_indexes)
+ return torch.cat(total_router_logits, dim=1), torch.cat(total_expert_indexes, dim=1)
+
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+ return self._shift_right(labels)
+
+
+class SwitchTransformersEncoderModel(SwitchTransformersPreTrainedModel):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ }
+
+ def __init__(self, config: SwitchTransformersConfig):
+ super().__init__(config)
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.use_cache = False
+ encoder_config.is_encoder_decoder = False
+ self.encoder = SwitchTransformersStack(encoder_config)
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | MoEModelOutput:
+ use_cache = False
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return encoder_outputs
+
+
+__all__ = [
+ "SwitchTransformersEncoderModel",
+ "SwitchTransformersForConditionalGeneration",
+ "SwitchTransformersModel",
+ "SwitchTransformersPreTrainedModel",
+ "SwitchTransformersTop1Router",
+ "SwitchTransformersSparseMLP",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/t5/__init__.py b/lib/python3.11/site-packages/transformers/models/t5/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ba44f774dba82304e5dcbec0cbd6ee21fed1ef6
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2024 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_t5 import *
+ from .modeling_t5 import *
+ from .tokenization_t5 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/t5/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fc84ecbadaa3f99addf80771a2ca2318983ff3d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5/__pycache__/configuration_t5.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5/__pycache__/configuration_t5.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f5a6902064ebde825bf00e0768c12585ac3b695
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5/__pycache__/configuration_t5.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5/__pycache__/modeling_t5.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5/__pycache__/modeling_t5.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42c0cadc27c6f623655c5633dc0425ee9291bea4
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5/__pycache__/modeling_t5.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5/__pycache__/tokenization_t5.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5/__pycache__/tokenization_t5.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e336e5ff07367903ad34fb287e6b70db25131c0
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5/__pycache__/tokenization_t5.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5/configuration_t5.py b/lib/python3.11/site-packages/transformers/models/t5/configuration_t5.py
new file mode 100644
index 0000000000000000000000000000000000000000..5223811a5e9e5dc0157663d1019687013230fede
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5/configuration_t5.py
@@ -0,0 +1,98 @@
+# Copyright 2020, The T5 Authors and HuggingFace Inc.
+#
+# 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.
+"""T5 model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="google-t5/t5-small")
+@strict
+class T5Config(PreTrainedConfig):
+ r"""
+ relative_attention_num_buckets (`int`, *optional*, defaults to 32):
+ The number of buckets to use for each attention layer.
+ relative_attention_max_distance (`int`, *optional*, defaults to 128):
+ The maximum distance of the longer sequences for the bucket separation.
+ feed_forward_proj (`string`, *optional*, defaults to `"relu"`):
+ Type of feed forward layer to be used. Should be one of `"relu"` or `"gated-gelu"`. T5v1.1 uses the
+ `"gated-gelu"` feed forward projection. Original T5 uses `"relu"`.
+ """
+
+ model_type = "t5"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ attribute_map = {
+ "hidden_size": "d_model",
+ "num_attention_heads": "num_heads",
+ "num_hidden_layers": "num_layers",
+ "head_dim": "d_kv",
+ }
+
+ vocab_size: int = 32128
+ d_model: int = 512
+ d_kv: int = 64
+ d_ff: int = 2048
+ num_layers: int = 6
+ num_decoder_layers: int | None = None
+ num_heads: int = 8
+ relative_attention_num_buckets: int = 32
+ relative_attention_max_distance: int = 128
+ dropout_rate: float | int = 0.1
+ layer_norm_epsilon: float = 1e-6
+ initializer_factor: float = 1.0
+ feed_forward_proj: str = "relu"
+ is_encoder_decoder: bool = True
+ use_cache: bool = True
+ pad_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 1
+ classifier_dropout: float | int = 0.0
+ is_decoder: bool = False
+
+ def __post_init__(self, **kwargs):
+ self.num_decoder_layers = (
+ self.num_decoder_layers if self.num_decoder_layers is not None else self.num_layers
+ ) # default = symmetry
+
+ act_info = self.feed_forward_proj.split("-")
+ self.dense_act_fn = act_info[-1]
+ self.is_gated_act = act_info[0] == "gated"
+
+ # for backwards compatibility
+ if self.feed_forward_proj == "gated-gelu":
+ self.dense_act_fn = "gelu_new"
+
+ # Super weird feature of T5 because we support T5 and T51.1 from the same
+ # model code. Original T5 always scaled outputs, but the 1.1v does not.
+ # The model code was relying on saved configs where `tie_word_embeddings` is
+ # set to `False` in 1.1v and using it as indicator of whether to scale or not
+ # But in fact we tie weights always and force it to be `True`
+ self.scale_decoder_outputs = kwargs.pop("tie_word_embeddings", None) is not False
+ self.tie_word_embeddings = True
+
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ act_info = self.feed_forward_proj.split("-")
+ if len(act_info) > 1 and act_info[0] != "gated" or len(act_info) > 2:
+ raise ValueError(
+ f"`feed_forward_proj`: {self.feed_forward_proj} is not a valid activation function of the dense layer. "
+ "Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. "
+ "'gated-gelu' or 'relu'"
+ )
+
+
+__all__ = ["T5Config"]
diff --git a/lib/python3.11/site-packages/transformers/models/t5/modeling_t5.py b/lib/python3.11/site-packages/transformers/models/t5/modeling_t5.py
new file mode 100644
index 0000000000000000000000000000000000000000..465a5c0153927e4dc9925dc6e1584b6773f85d41
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5/modeling_t5.py
@@ -0,0 +1,1606 @@
+# Copyright 2018 Mesh TensorFlow authors, T5 Authors and 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.
+"""PyTorch T5 model."""
+
+import copy
+import math
+
+import torch
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ BaseModelOutputWithPastAndCrossAttentions,
+ Seq2SeqLMOutput,
+ Seq2SeqModelOutput,
+ Seq2SeqQuestionAnsweringModelOutput,
+ Seq2SeqSequenceClassifierOutput,
+ TokenClassifierOutput,
+)
+from ...modeling_utils import PreTrainedModel
+from ...utils import DUMMY_INPUTS, DUMMY_MASK, auto_docstring, logging, torch_compilable_check
+from .configuration_t5 import T5Config
+
+
+logger = logging.get_logger(__name__)
+
+
+class T5LayerNorm(nn.Module):
+ def __init__(self, hidden_size, eps=1e-6):
+ """
+ Construct a layernorm module in the T5 style. No bias and no subtraction of mean.
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states):
+ # T5 uses a layer_norm which only scales and doesn't shift, which is also known as Root Mean
+ # Square Layer Normalization https://huggingface.co/papers/1910.07467 thus variance is calculated
+ # w/o mean and there is no bias. Additionally we want to make sure that the accumulation for
+ # half-precision inputs is done in fp32
+
+ variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+
+ # convert into half-precision if necessary
+ if self.weight.dtype in [torch.float16, torch.bfloat16]:
+ hidden_states = hidden_states.to(self.weight.dtype)
+
+ return self.weight * hidden_states
+
+
+class T5DenseActDense(nn.Module):
+ def __init__(self, config: T5Config):
+ super().__init__()
+ self.wi = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.act = ACT2FN[config.dense_act_fn]
+
+ def forward(self, hidden_states):
+ hidden_states = self.wi(hidden_states)
+ hidden_states = self.act(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ if (
+ isinstance(self.wo.weight, torch.Tensor)
+ and hidden_states.dtype != self.wo.weight.dtype
+ and self.wo.weight.dtype != torch.int8
+ ):
+ hidden_states = hidden_states.to(self.wo.weight.dtype)
+ hidden_states = self.wo(hidden_states)
+ return hidden_states
+
+
+class T5DenseGatedActDense(nn.Module):
+ def __init__(self, config: T5Config):
+ super().__init__()
+ self.wi_0 = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wi_1 = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.act = ACT2FN[config.dense_act_fn]
+
+ def forward(self, hidden_states):
+ hidden_gelu = self.act(self.wi_0(hidden_states))
+ hidden_linear = self.wi_1(hidden_states)
+ hidden_states = hidden_gelu * hidden_linear
+ hidden_states = self.dropout(hidden_states)
+
+ # To make 8bit quantization work for google/flan-t5-xxl, self.wo is kept in float32.
+ # See https://github.com/huggingface/transformers/issues/20287
+ # we also make sure the weights are not in `int8` in case users will force `_keep_in_fp32_modules` to be `None``
+ if (
+ isinstance(self.wo.weight, torch.Tensor)
+ and hidden_states.dtype != self.wo.weight.dtype
+ and self.wo.weight.dtype != torch.int8
+ ):
+ hidden_states = hidden_states.to(self.wo.weight.dtype)
+
+ hidden_states = self.wo(hidden_states)
+ return hidden_states
+
+
+class T5LayerFF(nn.Module):
+ def __init__(self, config: T5Config):
+ super().__init__()
+ if config.is_gated_act:
+ self.DenseReluDense = T5DenseGatedActDense(config)
+ else:
+ self.DenseReluDense = T5DenseActDense(config)
+
+ self.layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(self, hidden_states):
+ forwarded_states = self.layer_norm(hidden_states)
+ forwarded_states = self.DenseReluDense(forwarded_states)
+ hidden_states = hidden_states + self.dropout(forwarded_states)
+ return hidden_states
+
+
+class T5Attention(nn.Module):
+ def __init__(
+ self,
+ config: T5Config,
+ has_relative_attention_bias=False,
+ layer_idx: int | None = None,
+ ):
+ super().__init__()
+ self.is_decoder = config.is_decoder
+ self.has_relative_attention_bias = has_relative_attention_bias
+ self.relative_attention_num_buckets = config.relative_attention_num_buckets
+ self.relative_attention_max_distance = config.relative_attention_max_distance
+ self.d_model = config.d_model
+ self.key_value_proj_dim = config.d_kv
+ self.n_heads = config.num_heads
+ self.dropout = config.dropout_rate
+ self.inner_dim = self.n_heads * self.key_value_proj_dim
+ self.layer_idx = layer_idx
+ if layer_idx is None and self.is_decoder:
+ logger.warning_once(
+ f"Instantiating a decoder {self.__class__.__name__} without passing `layer_idx` is not recommended and "
+ "will to errors during the forward call, if caching is used. Please make sure to provide a `layer_idx` "
+ "when creating this class."
+ )
+
+ self.q = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.k = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.v = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.o = nn.Linear(self.inner_dim, self.d_model, bias=False)
+
+ if self.has_relative_attention_bias:
+ self.relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets, self.n_heads)
+
+ self.gradient_checkpointing = False
+
+ @staticmethod
+ def _relative_position_bucket(relative_position, bidirectional=True, num_buckets=32, max_distance=128):
+ """
+ Adapted from Mesh Tensorflow:
+ https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593
+
+ Translate relative position to a bucket number for relative attention. The relative position is defined as
+ memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to
+ position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for
+ small absolute relative_position and larger buckets for larger absolute relative_positions. All relative
+ positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket.
+ This should allow for more graceful generalization to longer sequences than the model has been trained on
+
+ Args:
+ relative_position: an int32 Tensor
+ bidirectional: a boolean - whether the attention is bidirectional
+ num_buckets: an integer
+ max_distance: an integer
+
+ Returns:
+ a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets)
+ """
+ relative_buckets = 0
+ if bidirectional:
+ num_buckets //= 2
+ relative_buckets += (relative_position > 0).to(torch.long) * num_buckets
+ relative_position = torch.abs(relative_position)
+ else:
+ relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
+ # now relative_position is in the range [0, inf)
+
+ # half of the buckets are for exact increments in positions
+ max_exact = num_buckets // 2
+ is_small = relative_position < max_exact
+
+ # The other half of the buckets are for logarithmically bigger bins in positions up to max_distance
+ relative_position_if_large = max_exact + (
+ torch.log(relative_position.float() / max_exact)
+ / math.log(max_distance / max_exact)
+ * (num_buckets - max_exact)
+ ).to(torch.long)
+ relative_position_if_large = torch.min(
+ relative_position_if_large, torch.full_like(relative_position_if_large, num_buckets - 1)
+ )
+
+ relative_buckets += torch.where(is_small, relative_position, relative_position_if_large)
+ return relative_buckets
+
+ def compute_bias(self, query_length, key_length, device=None, past_seen_tokens=0):
+ """Compute binned relative position bias"""
+ if device is None:
+ device = self.relative_attention_bias.weight.device
+ context_position = torch.arange(query_length, dtype=torch.long, device=device)[:, None] + past_seen_tokens
+ memory_position = torch.arange(key_length, dtype=torch.long, device=device)[None, :]
+ relative_position = memory_position - context_position # shape (query_length, key_length)
+ relative_position_bucket = self._relative_position_bucket(
+ relative_position, # shape (query_length, key_length)
+ bidirectional=(not self.is_decoder),
+ num_buckets=self.relative_attention_num_buckets,
+ max_distance=self.relative_attention_max_distance,
+ )
+ values = self.relative_attention_bias(relative_position_bucket) # shape (query_length, key_length, num_heads)
+ values = values.permute([2, 0, 1]).unsqueeze(0) # shape (1, num_heads, query_length, key_length)
+ return values
+
+ def forward(
+ self,
+ hidden_states,
+ mask=None,
+ key_value_states=None,
+ position_bias=None,
+ past_key_values=None,
+ output_attentions=False,
+ **kwargs,
+ ):
+ """
+ Self-attention (if key_value_states is None) or attention over source sentence (provided by key_value_states).
+ """
+ # Input is (batch_size, seq_length, dim)
+ # Mask is (batch_size, 1, 1, key_length) (non-causal encoder) or (batch_size, 1, seq_length, key_length) (causal decoder)
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.key_value_proj_dim)
+ past_seen_tokens = past_key_values.get_seq_length(self.layer_idx) if past_key_values is not None else 0
+ # We clone here for StaticCache, as we get the value before updating it, but use it after and it's the same ref
+ past_seen_tokens = past_seen_tokens.clone() if isinstance(past_seen_tokens, torch.Tensor) else past_seen_tokens
+
+ # if key_value_states are provided this layer is used as a cross-attention layer for the decoder
+ is_cross_attention = key_value_states is not None
+
+ query_states = self.q(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ # Check is encoder-decoder model is being used. Otherwise we'll get `DynamicCache`
+ is_updated = False
+ if isinstance(past_key_values, EncoderDecoderCache):
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ if is_cross_attention:
+ # after the first generated id, we can subsequently re-use all key/value_states from cache
+ curr_past_key_values = past_key_values.cross_attention_cache
+ else:
+ curr_past_key_values = past_key_values.self_attention_cache
+ else:
+ curr_past_key_values = past_key_values
+
+ current_states = key_value_states if is_cross_attention else hidden_states
+ if is_cross_attention and past_key_values is not None and is_updated:
+ # reuse k,v, cross_attentions
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+ else:
+ kv_shape = (*current_states.shape[:-1], -1, self.key_value_proj_dim)
+ key_states = self.k(current_states).view(kv_shape).transpose(1, 2)
+ value_states = self.v(current_states).view(kv_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+ if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+ past_key_values.is_updated[self.layer_idx] = True
+
+ # compute scores, equivalent of torch.einsum("bnqd,bnkd->bnqk", query_states, key_states), compatible with onnx op>9
+ scores = torch.matmul(query_states, key_states.transpose(3, 2))
+
+ if position_bias is None:
+ key_length = key_states.shape[-2]
+ if not self.has_relative_attention_bias:
+ position_bias = torch.zeros(
+ (1, query_states.shape[1], input_shape[1], key_length), device=scores.device, dtype=scores.dtype
+ )
+ if self.gradient_checkpointing and self.training:
+ position_bias.requires_grad = True
+ else:
+ position_bias = self.compute_bias(
+ input_shape[1], key_length, device=scores.device, past_seen_tokens=past_seen_tokens
+ )
+
+ if mask is not None:
+ causal_mask = mask[:, :, :, : key_states.shape[-2]]
+ position_bias = position_bias + causal_mask
+
+ position_bias_masked = position_bias
+ scores += position_bias_masked
+
+ # (batch_size, n_heads, seq_length, key_length)
+ attn_weights = nn.functional.softmax(scores.float(), dim=-1).type_as(scores)
+ attn_weights = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+ attn_output = torch.matmul(attn_weights, value_states)
+
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ attn_output = attn_output.reshape(*input_shape, -1)
+ attn_output = self.o(attn_output)
+
+ outputs = (attn_output, position_bias)
+
+ if output_attentions:
+ outputs = outputs + (attn_weights,)
+ return outputs
+
+
+class T5LayerSelfAttention(nn.Module):
+ def __init__(self, config, has_relative_attention_bias=False, layer_idx: int | None = None):
+ super().__init__()
+ self.SelfAttention = T5Attention(
+ config, has_relative_attention_bias=has_relative_attention_bias, layer_idx=layer_idx
+ )
+ self.layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ position_bias=None,
+ past_key_values=None,
+ use_cache=False,
+ output_attentions=False,
+ **kwargs,
+ ):
+ normed_hidden_states = self.layer_norm(hidden_states)
+ attention_output = self.SelfAttention(
+ normed_hidden_states,
+ mask=attention_mask,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ )
+ hidden_states = hidden_states + self.dropout(attention_output[0])
+ outputs = (hidden_states,) + attention_output[1:] # add attentions if we output them
+ return outputs
+
+
+class T5LayerCrossAttention(nn.Module):
+ def __init__(self, config, layer_idx: int | None = None):
+ super().__init__()
+ self.EncDecAttention = T5Attention(config, has_relative_attention_bias=False, layer_idx=layer_idx)
+ self.layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states,
+ key_value_states,
+ attention_mask=None,
+ position_bias=None,
+ past_key_values=None,
+ output_attentions=False,
+ **kwargs,
+ ):
+ normed_hidden_states = self.layer_norm(hidden_states)
+ attention_output = self.EncDecAttention(
+ normed_hidden_states,
+ mask=attention_mask,
+ key_value_states=key_value_states,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+ layer_output = hidden_states + self.dropout(attention_output[0])
+ outputs = (layer_output,) + attention_output[1:] # add attentions if we output them
+ return outputs
+
+
+class T5Block(GradientCheckpointingLayer):
+ def __init__(self, config, has_relative_attention_bias=False, layer_idx: int | None = None):
+ super().__init__()
+ self.is_decoder = config.is_decoder
+ self.layer = nn.ModuleList()
+ self.layer.append(
+ T5LayerSelfAttention(config, has_relative_attention_bias=has_relative_attention_bias, layer_idx=layer_idx)
+ )
+ if self.is_decoder:
+ self.layer.append(T5LayerCrossAttention(config, layer_idx=layer_idx))
+
+ self.layer.append(T5LayerFF(config))
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ position_bias=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ encoder_decoder_position_bias=None,
+ past_key_values=None,
+ use_cache=False,
+ output_attentions=False,
+ return_dict=True,
+ **kwargs,
+ ):
+ self_attention_outputs = self.layer[0](
+ hidden_states,
+ attention_mask=attention_mask,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ )
+ hidden_states = self_attention_outputs[0]
+ attention_outputs = self_attention_outputs[1:] # Keep self-attention outputs and relative position weights
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16:
+ clamp_value = torch.where(
+ torch.isinf(hidden_states).any(),
+ torch.finfo(hidden_states.dtype).max - 1000,
+ torch.finfo(hidden_states.dtype).max,
+ )
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ do_cross_attention = self.is_decoder and encoder_hidden_states is not None
+ if do_cross_attention:
+ cross_attention_outputs = self.layer[1](
+ hidden_states,
+ key_value_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ position_bias=encoder_decoder_position_bias,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+ hidden_states = cross_attention_outputs[0]
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16:
+ clamp_value = torch.where(
+ torch.isinf(hidden_states).any(),
+ torch.finfo(hidden_states.dtype).max - 1000,
+ torch.finfo(hidden_states.dtype).max,
+ )
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ # Keep cross-attention outputs and relative position weights
+ attention_outputs = attention_outputs + cross_attention_outputs[1:]
+
+ # Apply Feed Forward layer
+ hidden_states = self.layer[-1](hidden_states)
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16:
+ clamp_value = torch.where(
+ torch.isinf(hidden_states).any(),
+ torch.finfo(hidden_states.dtype).max - 1000,
+ torch.finfo(hidden_states.dtype).max,
+ )
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ outputs = (hidden_states,)
+
+ return (
+ outputs + attention_outputs
+ ) # hidden-states, (self-attention position bias), (self-attention weights), (cross-attention position bias), (cross-attention weights)
+
+
+class T5ClassificationHead(nn.Module):
+ """Head for sentence-level classification tasks."""
+
+ def __init__(self, config: T5Config):
+ super().__init__()
+ self.dense = nn.Linear(config.d_model, config.d_model)
+ self.dropout = nn.Dropout(p=config.classifier_dropout)
+ self.out_proj = nn.Linear(config.d_model, config.num_labels)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.dense(hidden_states)
+ hidden_states = torch.tanh(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.out_proj(hidden_states)
+ return hidden_states
+
+
+@auto_docstring
+class T5PreTrainedModel(PreTrainedModel):
+ config: T5Config
+ base_model_prefix = "transformer"
+ supports_gradient_checkpointing = True
+ _can_compile_fullgraph = True
+
+ _no_split_modules = ["T5Block"]
+ _keep_in_fp32_modules = ["wo"]
+
+ @property
+ def dummy_inputs(self):
+ input_ids = torch.tensor(DUMMY_INPUTS)
+ input_mask = torch.tensor(DUMMY_MASK)
+ dummy_inputs = {
+ "decoder_input_ids": input_ids,
+ "input_ids": input_ids,
+ "decoder_attention_mask": input_mask,
+ }
+ return dummy_inputs
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ factor = self.config.initializer_factor # Used for testing weights initialization
+ if isinstance(module, T5LayerNorm):
+ init.constant_(module.weight, factor * 1.0)
+ elif isinstance(
+ module,
+ (T5Model, T5ForConditionalGeneration, T5EncoderModel, T5ForQuestionAnswering),
+ ):
+ init.normal_(module.shared.weight, mean=0.0, std=factor * 1.0)
+ if hasattr(module, "lm_head") and not self.config.tie_word_embeddings:
+ init.normal_(module.lm_head.weight, mean=0.0, std=factor * 1.0)
+ if hasattr(module, "qa_outputs"):
+ init.normal_(module.qa_outputs.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ init.zeros_(module.qa_outputs.bias)
+ elif isinstance(module, T5ForTokenClassification):
+ if hasattr(module, "classifier"):
+ init.normal_(module.classifier.weight, mean=0.0, std=factor * 1.0)
+ init.zeros_(module.classifier.bias)
+ elif isinstance(module, T5ClassificationHead):
+ init.normal_(module.dense.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.dense, "bias") and module.dense.bias is not None:
+ init.zeros_(module.dense.bias)
+ init.normal_(module.out_proj.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.out_proj, "bias") and module.out_proj.bias is not None:
+ init.zeros_(module.out_proj.bias)
+ elif isinstance(module, T5DenseActDense):
+ init.normal_(module.wi.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi, "bias") and module.wi.bias is not None:
+ init.zeros_(module.wi.bias)
+ init.normal_(module.wo.weight, mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
+ if hasattr(module.wo, "bias") and module.wo.bias is not None:
+ init.zeros_(module.wo.bias)
+ elif isinstance(module, T5DenseGatedActDense):
+ init.normal_(module.wi_0.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi_0, "bias") and module.wi_0.bias is not None:
+ init.zeros_(module.wi_0.bias)
+ init.normal_(module.wi_1.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi_1, "bias") and module.wi_1.bias is not None:
+ init.zeros_(module.wi_1.bias)
+ init.normal_(module.wo.weight, mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
+ if hasattr(module.wo, "bias") and module.wo.bias is not None:
+ init.zeros_(module.wo.bias)
+ elif isinstance(module, T5Attention):
+ d_model = self.config.d_model
+ key_value_proj_dim = self.config.d_kv
+ n_heads = self.config.num_heads
+ init.normal_(module.q.weight, mean=0.0, std=factor * ((d_model * key_value_proj_dim) ** -0.5))
+ init.normal_(module.k.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.v.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.o.weight, mean=0.0, std=factor * ((n_heads * key_value_proj_dim) ** -0.5))
+ if module.has_relative_attention_bias:
+ init.normal_(module.relative_attention_bias.weight, mean=0.0, std=factor * ((d_model) ** -0.5))
+
+ def _shift_right(self, input_ids):
+ decoder_start_token_id = self.config.decoder_start_token_id
+ pad_token_id = self.config.pad_token_id
+
+ if decoder_start_token_id is None:
+ raise ValueError(
+ "self.model.config.decoder_start_token_id has to be defined. In T5 it is usually set to the pad_token_id. "
+ "See T5 docs for more information."
+ )
+
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
+ shifted_input_ids[..., 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.pad_token_id has to be defined.")
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+class T5Stack(T5PreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.d_model)
+ self.is_decoder = config.is_decoder
+
+ self.block = nn.ModuleList(
+ [T5Block(config, has_relative_attention_bias=bool(i == 0), layer_idx=i) for i in range(config.num_layers)]
+ )
+ self.final_layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+ self.gradient_checkpointing = False
+
+ def set_input_embeddings(self, new_embeddings):
+ self.embed_tokens = new_embeddings
+
+ def forward(
+ self,
+ input_ids=None,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ inputs_embeds=None,
+ past_key_values=None,
+ use_cache=None,
+ output_attentions=None,
+ output_hidden_states=None,
+ return_dict=None,
+ **kwargs,
+ ):
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if input_ids is not None and inputs_embeds is not None:
+ err_msg_prefix = "decoder_" if self.is_decoder else ""
+ raise ValueError(
+ f"You cannot specify both {err_msg_prefix}input_ids and {err_msg_prefix}inputs_embeds at the same time"
+ )
+ elif input_ids is not None:
+ input_shape = input_ids.size()
+ input_ids = input_ids.view(-1, input_shape[-1])
+ elif inputs_embeds is not None:
+ input_shape = inputs_embeds.size()[:-1]
+ else:
+ err_msg_prefix = "decoder_" if self.is_decoder else ""
+ raise ValueError(f"You have to specify either {err_msg_prefix}input_ids or {err_msg_prefix}inputs_embeds")
+
+ if self.gradient_checkpointing and self.training:
+ if use_cache:
+ logger.warning_once(
+ "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+ )
+ use_cache = False
+
+ if inputs_embeds is None:
+ if self.embed_tokens is None:
+ raise ValueError("You have to initialize the model with valid token embeddings")
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ batch_size, seq_length = input_shape
+
+ if use_cache is True:
+ if not self.is_decoder:
+ raise ValueError(f"`use_cache` can only be set to `True` if {self} is used as a decoder")
+
+ if self.is_decoder:
+ if use_cache and past_key_values is None:
+ if self.config.is_encoder_decoder:
+ past_key_values = EncoderDecoderCache(
+ DynamicCache(config=self.config), DynamicCache(config=self.config)
+ )
+ else:
+ past_key_values = DynamicCache(config=self.config)
+ elif not self.is_decoder:
+ # do not pass cache object down the line for encoder stack
+ # it messes indexing later in decoder-stack because cache object is modified in-place
+ past_key_values = None
+
+ if self.config.is_decoder:
+ attention_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values.self_attention_cache
+ if isinstance(past_key_values, EncoderDecoderCache)
+ else past_key_values,
+ )
+ else:
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ )
+
+ encoder_extended_attention_mask = None
+ if self.is_decoder and encoder_hidden_states is not None:
+ encoder_extended_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+
+ all_hidden_states = () if output_hidden_states else None
+ all_attentions = () if output_attentions else None
+ all_cross_attentions = () if (output_attentions and self.is_decoder) else None
+ position_bias = None
+ encoder_decoder_position_bias = None
+
+ hidden_states = self.dropout(inputs_embeds)
+
+ for layer_module in self.block:
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ layer_outputs = layer_module(
+ hidden_states,
+ attention_mask,
+ position_bias,
+ encoder_hidden_states,
+ encoder_extended_attention_mask,
+ encoder_decoder_position_bias, # as a positional argument for gradient checkpointing
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ return_dict=return_dict,
+ )
+
+ hidden_states = layer_outputs[0]
+
+ # We share the position biases between the layers - the first layer store them
+ # layer_outputs = hidden-states, key-value-states (self-attention position bias), (self-attention weights),
+ # (cross-attention position bias), (cross-attention weights)
+ position_bias = layer_outputs[1]
+ if self.is_decoder and encoder_hidden_states is not None:
+ encoder_decoder_position_bias = layer_outputs[3 if output_attentions else 2]
+
+ if output_attentions:
+ all_attentions = all_attentions + (layer_outputs[2],)
+ if self.is_decoder:
+ all_cross_attentions = all_cross_attentions + (layer_outputs[4],)
+
+ hidden_states = self.final_layer_norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ # Add last layer
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(
+ v
+ for v in [
+ hidden_states,
+ past_key_values,
+ all_hidden_states,
+ all_attentions,
+ all_cross_attentions,
+ ]
+ if v is not None
+ )
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ hidden_states=all_hidden_states,
+ attentions=all_attentions,
+ cross_attentions=all_cross_attentions,
+ )
+
+
+@auto_docstring
+class T5Model(T5PreTrainedModel):
+ _keys_to_ignore_on_load_unexpected = [
+ "decoder.block.0.layer.1.EncDecAttention.relative_attention_bias.weight",
+ ]
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ }
+
+ def __init__(self, config: T5Config):
+ super().__init__(config)
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = T5Stack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = T5Stack(decoder_config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ decoder_inputs_embeds: torch.Tensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | Seq2SeqModelOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you
+ should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [T5 Training](./t5#training).
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ T5 uses the `pad_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+ is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+ To know more on how to prepare `decoder_input_ids` for pretraining take a look at [T5
+ Training](./t5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, T5Model
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
+ >>> model = T5Model.from_pretrained("google-t5/t5-small")
+
+ >>> input_ids = tokenizer(
+ ... "Studies have been shown that owning a dog is good for you", return_tensors="pt"
+ ... ).input_ids # Batch size 1
+ >>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1
+
+ >>> # preprocess: Prepend decoder_input_ids with start token which is pad token for T5Model.
+ >>> # This is not needed for torch's T5ForConditionalGeneration as it does this internally using labels arg.
+ >>> decoder_input_ids = model._shift_right(decoder_input_ids)
+
+ >>> # forward pass
+ >>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
+ >>> last_hidden_states = outputs.last_hidden_state
+ ```"""
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # Encode if needed (training, first prediction pass)
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if not return_dict:
+ return decoder_outputs + encoder_outputs
+
+ return Seq2SeqModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ T5 Model with a `language modeling` head on top.
+ """
+)
+class T5ForConditionalGeneration(T5PreTrainedModel, GenerationMixin):
+ _keys_to_ignore_on_load_unexpected = [
+ "decoder.block.0.layer.1.EncDecAttention.relative_attention_bias.weight",
+ ]
+ _tied_weights_keys = {
+ "lm_head.weight": "shared.weight",
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ }
+
+ def __init__(self, config: T5Config):
+ super().__init__(config)
+ self.model_dim = config.d_model
+
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = T5Stack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = T5Stack(decoder_config)
+
+ self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.Tensor]] | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | Seq2SeqLMOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you
+ should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [T5 Training](./t5#training).
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ T5 uses the `pad_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+ is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+ To know more on how to prepare `decoder_input_ids` for pretraining take a look at [T5
+ Training](./t5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[-100, 0, ...,
+ config.vocab_size - 1]`. All labels set to `-100` are ignored (masked), the loss is only computed for
+ labels in `[0, ..., config.vocab_size]`
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, T5ForConditionalGeneration
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
+ >>> model = T5ForConditionalGeneration.from_pretrained("google-t5/t5-small")
+
+ >>> # training
+ >>> input_ids = tokenizer("The <extra_id_0> walks in <extra_id_1> park", return_tensors="pt").input_ids
+ >>> labels = tokenizer("<extra_id_0> cute dog <extra_id_1> the <extra_id_2>", return_tensors="pt").input_ids
+ >>> outputs = model(input_ids=input_ids, labels=labels)
+ >>> loss = outputs.loss
+ >>> logits = outputs.logits
+
+ >>> # inference
+ >>> input_ids = tokenizer(
+ ... "summarize: studies have shown that owning a dog is good for you", return_tensors="pt"
+ ... ).input_ids # Batch size 1
+ >>> outputs = model.generate(input_ids)
+ >>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+ >>> # studies have shown that owning a dog is good for you.
+ ```"""
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # Encode if needed (training, first prediction pass)
+ if encoder_outputs is None:
+ # Convert encoder inputs in embeddings if needed
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
+ # get decoder inputs from shifting lm labels to the right
+ decoder_input_ids = self._shift_right(labels)
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = decoder_outputs[0]
+
+ if self.config.scale_decoder_outputs:
+ sequence_output = sequence_output * (self.model_dim**-0.5)
+
+ lm_logits = self.lm_head(sequence_output)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss(ignore_index=-100)
+ # move labels to correct device to enable PP
+ labels = labels.to(lm_logits.device)
+ loss = loss_fct(lm_logits.view(-1, lm_logits.size(-1)), labels.view(-1))
+
+ if not return_dict:
+ output = (lm_logits,) + decoder_outputs[1:] + encoder_outputs
+ return ((loss,) + output) if loss is not None else output
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=lm_logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+ return self._shift_right(labels)
+
+
+@auto_docstring
+class T5EncoderModel(T5PreTrainedModel):
+ _tied_weights_keys = {"encoder.embed_tokens.weight": "shared.weight"}
+ _keys_to_ignore_on_load_unexpected = [r"decoder"]
+
+ def __init__(self, config: T5Config):
+ super().__init__(config)
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = config
+ encoder_config.use_cache = False
+ encoder_config.is_encoder_decoder = False
+ self.encoder = T5Stack(encoder_config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | BaseModelOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you
+ should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [T5 Training](./t5#training).
+
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, T5EncoderModel
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
+ >>> model = T5EncoderModel.from_pretrained("google-t5/t5-small")
+ >>> input_ids = tokenizer(
+ ... "Studies have been shown that owning a dog is good for you", return_tensors="pt"
+ ... ).input_ids # Batch size 1
+ >>> outputs = model(input_ids=input_ids)
+ >>> last_hidden_states = outputs.last_hidden_state
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ return encoder_outputs
+
+
+@auto_docstring(
+ custom_intro="""
+ T5 model with a sequence classification/head on top (a linear layer on top of the pooled output) e.g. for GLUE
+ tasks.
+ """
+)
+class T5ForSequenceClassification(T5PreTrainedModel):
+ _keys_to_ignore_on_load_unexpected = ["decoder.block.0.layer.1.EncDecAttention.relative_attention_bias.weight"]
+
+ def __init__(self, config: T5Config):
+ super().__init__(config)
+ self.transformer = T5Model(config)
+ self.classification_head = T5ClassificationHead(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: list[torch.FloatTensor] | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | Seq2SeqSequenceClassifierOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you
+ should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [T5 Training](./t5#training).
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ T5 uses the `pad_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+ is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+ To know more on how to prepare `decoder_input_ids` for pretraining take a look at [T5
+ Training](./t5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ if labels is not None:
+ use_cache = False
+
+ if input_ids is None and inputs_embeds is not None:
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__}"
+ )
+
+ # Copied from models.bart.modeling_bart.BartModel.forward different to other models, T5 automatically creates
+ # decoder_input_ids from input_ids if no decoder_input_ids are provided
+ if decoder_input_ids is None and decoder_inputs_embeds is None:
+ if input_ids is None:
+ raise ValueError(
+ "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+ "passed, `input_ids` cannot be `None`. Please pass either "
+ "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+ )
+ decoder_input_ids = self._shift_right(input_ids)
+
+ outputs = self.transformer(
+ input_ids,
+ attention_mask=attention_mask,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ sequence_output = outputs[0]
+
+ eos_mask = input_ids.eq(self.config.eos_token_id).to(sequence_output.device)
+
+ torch_compilable_check(
+ torch.unique_consecutive(eos_mask.sum(1)).numel() == 1,
+ "All examples must have the same number of <eos> tokens.",
+ )
+ batch_size, _, hidden_size = sequence_output.shape
+ sentence_representation = sequence_output[eos_mask, :].view(batch_size, -1, hidden_size)[:, -1, :]
+ logits = self.classification_head(sentence_representation)
+
+ loss = None
+ if labels is not None:
+ labels = labels.to(logits.device)
+ if self.config.problem_type is None:
+ if self.config.num_labels == 1:
+ self.config.problem_type = "regression"
+ elif self.config.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+ self.config.problem_type = "single_label_classification"
+ else:
+ self.config.problem_type = "multi_label_classification"
+
+ if self.config.problem_type == "regression":
+ loss_fct = MSELoss()
+ if self.config.num_labels == 1:
+ loss = loss_fct(logits.squeeze(), labels.squeeze())
+ else:
+ loss = loss_fct(logits, labels)
+ elif self.config.problem_type == "single_label_classification":
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.config.num_labels), labels.view(-1))
+ elif self.config.problem_type == "multi_label_classification":
+ loss_fct = BCEWithLogitsLoss()
+ loss = loss_fct(logits, labels)
+ if not return_dict:
+ output = (logits,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return Seq2SeqSequenceClassifierOutput(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ decoder_hidden_states=outputs.decoder_hidden_states,
+ decoder_attentions=outputs.decoder_attentions,
+ cross_attentions=outputs.cross_attentions,
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+ encoder_hidden_states=outputs.encoder_hidden_states,
+ encoder_attentions=outputs.encoder_attentions,
+ )
+
+
+@auto_docstring
+class T5ForTokenClassification(T5PreTrainedModel):
+ def __init__(self, config: T5Config):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ self.transformer = T5EncoderModel(config)
+ self.dropout = nn.Dropout(config.classifier_dropout)
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.Tensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ labels: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.Tensor] | TokenClassifierOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you
+ should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [T5 Training](./t5#training).
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.transformer(
+ input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = outputs[0]
+ hidden_states = self.dropout(hidden_states)
+ logits = self.classifier(hidden_states)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+ if not return_dict:
+ output = (logits, outputs[2:-1])
+ return ((loss,) + output) if loss is not None else output
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@auto_docstring
+class T5ForQuestionAnswering(T5PreTrainedModel):
+ _keys_to_ignore_on_load_unexpected = ["decoder.block.0.layer.1.EncDecAttention.relative_attention_bias.weight"]
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ }
+
+ def __init__(self, config: T5Config):
+ super().__init__(config)
+ self.model_dim = config.d_model
+
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = T5Stack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = T5Stack(decoder_config)
+
+ self.num_labels = config.num_labels
+ self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.Tensor]] | None = None,
+ start_positions: torch.LongTensor | None = None,
+ end_positions: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | Seq2SeqQuestionAnsweringModelOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you
+ should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [T5 Training](./t5#training).
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ T5 uses the `pad_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+ is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+ To know more on how to prepare `decoder_input_ids` for pretraining take a look at [T5
+ Training](./t5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ if start_positions is not None and end_positions is not None:
+ use_cache = False
+
+ # Copied from models.bart.modeling_bart.BartModel.forward
+ # different to other models, T5 automatically creates decoder_input_ids from
+ # input_ids if no decoder_input_ids are provided
+ if decoder_input_ids is None and decoder_inputs_embeds is None:
+ if input_ids is None:
+ raise ValueError(
+ "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+ "passed, `input_ids` cannot be `None`. Please pass either "
+ "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+ )
+ decoder_input_ids = self._shift_right(input_ids)
+
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # Encode if needed (training, first prediction pass)
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=None,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = decoder_outputs[0]
+
+ logits = self.qa_outputs(sequence_output)
+ start_logits, end_logits = logits.split(1, dim=-1)
+ start_logits = start_logits.squeeze(-1).contiguous()
+ end_logits = end_logits.squeeze(-1).contiguous()
+
+ total_loss = None
+ if start_positions is not None and end_positions is not None:
+ # If we are on multi-GPU, split add a dimension
+ if len(start_positions.size()) > 1:
+ start_positions = start_positions.squeeze(-1).to(start_logits.device)
+ if len(end_positions.size()) > 1:
+ end_positions = end_positions.squeeze(-1).to(end_logits.device)
+ # sometimes the start/end positions are outside our model inputs, we ignore these terms
+ ignored_index = start_logits.size(1)
+ start_positions = start_positions.clamp(0, ignored_index)
+ end_positions = end_positions.clamp(0, ignored_index)
+
+ loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
+ start_loss = loss_fct(start_logits, start_positions)
+ end_loss = loss_fct(end_logits, end_positions)
+ total_loss = (start_loss + end_loss) / 2
+
+ if not return_dict:
+ output = (start_logits, end_logits) + decoder_outputs[1:] + encoder_outputs
+ return ((total_loss,) + output) if total_loss is not None else output
+
+ return Seq2SeqQuestionAnsweringModelOutput(
+ loss=total_loss,
+ start_logits=start_logits,
+ end_logits=end_logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+__all__ = [
+ "T5EncoderModel",
+ "T5ForConditionalGeneration",
+ "T5Model",
+ "T5PreTrainedModel",
+ "T5ForQuestionAnswering",
+ "T5ForSequenceClassification",
+ "T5ForTokenClassification",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/t5/tokenization_t5.py b/lib/python3.11/site-packages/transformers/models/t5/tokenization_t5.py
new file mode 100644
index 0000000000000000000000000000000000000000..741fb8369b6ba2c63874ec1262b3f3c0698f9f11
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5/tokenization_t5.py
@@ -0,0 +1,159 @@
+# Copyright 2018 T5 Authors and 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.
+"""Tokenization class for model T5."""
+
+import re
+
+from tokenizers import Tokenizer, decoders, normalizers, pre_tokenizers, processors
+from tokenizers.models import Unigram
+
+from ...tokenization_utils_tokenizers import TokenizersBackend
+from ...utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+VOCAB_FILES_NAMES = {"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"}
+
+
+class T5Tokenizer(TokenizersBackend):
+ """
+ Construct a T5 tokenizer (backed by HuggingFace's *tokenizers* library). Based on
+ [Unigram](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=unigram#models).
+
+ This tokenizer inherits from [`TokenizersBackend`] which contains most of the main methods. Users should
+ refer to this superclass for more information regarding those methods.
+
+ Args:
+ vocab_file (`str`, *optional*):
+ [SentencePiece](https://github.com/google/sentencepiece) file (generally has a *.spm* extension) that
+ contains the vocabulary necessary to instantiate a tokenizer.
+ eos_token (`str`, *optional*, defaults to `"</s>"`):
+ The end of sequence token.
+
+ <Tip>
+
+ When building a sequence using special tokens, this is not the token that is used for the end of sequence.
+ The token used is the `sep_token`.
+
+ </Tip>
+
+ unk_token (`str`, *optional*, defaults to `"<unk>"`):
+ The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
+ token instead.
+ pad_token (`str`, *optional*, defaults to `"<pad>"`):
+ The token used for padding, for example when batching sequences of different lengths.
+ extra_ids (`int`, *optional*, defaults to 100):
+ Add a number of extra ids added to the vocabulary for use as sentinels. These tokens are accessible as
+ "<extra_id_{%d}>" where "{%d}" is a number between 0 and extra_ids-1. These tokens can be retrieved by
+ calling get_sentinel_tokens method and token ids can be by calling get_sentinel_token_ids method
+ additional_special_tokens (`list[str]`, *optional*):
+ Additional special tokens used by the tokenizer.
+ vocab (`str`, `dict` or `list`, *optional*):
+ Custom vocabulary dict. If not provided, a minimal vocabulary is created using the special tokens.
+ """
+
+ vocab_files_names = VOCAB_FILES_NAMES
+ model_input_names = ["input_ids", "attention_mask"]
+ model = Unigram
+
+ def __init__(
+ self,
+ vocab: str | list[tuple[str, float]] | None = None,
+ eos_token="</s>",
+ unk_token="<unk>",
+ pad_token="<pad>",
+ _spm_precompiled_charsmap=None,
+ extra_ids=100,
+ additional_special_tokens=None,
+ **kwargs,
+ ):
+ self._extra_ids = extra_ids
+
+ # Handle extra_ids and additional_special_tokens
+ if additional_special_tokens is not None:
+ extra_tokens = [x for x in additional_special_tokens if "<extra_id_" in str(x)]
+ if len(extra_tokens) < 1:
+ additional_special_tokens += [f"<extra_id_{i}>" for i in range(extra_ids)]
+ elif extra_ids > 0 and extra_ids != len(extra_tokens):
+ raise ValueError(
+ f"Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are"
+ " provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids"
+ " tokens"
+ )
+ else:
+ extra_tokens = [f"<extra_id_{i}>" for i in range(extra_ids)]
+ additional_special_tokens = extra_tokens
+
+ # T5 vocab structure: <pad>=0, </s>=1, <unk>=2, then regular vocab, then extra_ids in reverse
+ if vocab is not None:
+ self._vocab_scores = vocab
+ else:
+ self._vocab_scores = [
+ (str(pad_token), 0.0),
+ (str(eos_token), 0.0),
+ (str(unk_token), 0.0),
+ ("▁", -2.0), # Space token
+ ]
+ for i in range(extra_ids - 1, -1, -1):
+ self._vocab_scores.append((f"<extra_id_{i}>", 0.0))
+
+ self._tokenizer = Tokenizer(
+ Unigram(
+ self._vocab_scores,
+ unk_id=2,
+ byte_fallback=False,
+ )
+ )
+
+ if _spm_precompiled_charsmap is not None:
+ self._tokenizer.normalizer = normalizers.Precompiled(_spm_precompiled_charsmap)
+
+ self._tokenizer.pre_tokenizer = pre_tokenizers.Sequence(
+ [
+ pre_tokenizers.WhitespaceSplit(),
+ pre_tokenizers.Metaspace(replacement="▁", prepend_scheme="always", split=True),
+ ]
+ )
+ self._tokenizer.decoder = decoders.Metaspace(replacement="▁", prepend_scheme="always", split=True)
+
+ super().__init__(
+ eos_token=eos_token,
+ unk_token=unk_token,
+ pad_token=pad_token,
+ extra_ids=extra_ids,
+ additional_special_tokens=additional_special_tokens,
+ **kwargs,
+ )
+
+ self._tokenizer.post_processor = processors.TemplateProcessing(
+ single=["$A", "</s>"],
+ pair=["$A", "</s>", "$B", "</s>"],
+ special_tokens=[
+ ("</s>", self.eos_token_id),
+ ],
+ )
+
+ def get_sentinel_tokens(self):
+ """Get the list of sentinel tokens (extra_id tokens) from additional_special_tokens."""
+ return list(
+ set(filter(lambda x: bool(re.search(r"<extra_id_\d+>", x)) is not None, self.additional_special_tokens))
+ )
+
+ def get_sentinel_token_ids(self):
+ """Get the token IDs for sentinel tokens."""
+ return [self.convert_tokens_to_ids(token) for token in self.get_sentinel_tokens()]
+
+
+__all__ = ["T5Tokenizer"]
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma/__init__.py b/lib/python3.11/site-packages/transformers/models/t5gemma/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0688bdb54cbedec4ae03e3a68331117656ec666f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5gemma/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_t5gemma import *
+ from .modeling_t5gemma import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..28ab6e847add604d8748bfd06f49e380827e6417
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/configuration_t5gemma.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/configuration_t5gemma.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..08cf162bf1f6cb1dfdf291c2c61d3f499f836fab
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/configuration_t5gemma.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/modeling_t5gemma.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/modeling_t5gemma.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ba2a4d648ac8e8e7e52283fd3cdb1aae59f64b2c
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/modeling_t5gemma.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/modular_t5gemma.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/modular_t5gemma.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..54be897752f2a6c953246ef6ad8fcf790207f047
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5gemma/__pycache__/modular_t5gemma.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma/configuration_t5gemma.py b/lib/python3.11/site-packages/transformers/models/t5gemma/configuration_t5gemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..9de40c8322596f36b0b8fc0d08f748d40b2c6f01
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5gemma/configuration_t5gemma.py
@@ -0,0 +1,172 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/t5gemma/modular_t5gemma.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_t5gemma.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 Google Inc. HuggingFace Inc. 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 Any
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...modeling_rope_utils import RopeParameters
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="google/t5_gemma_module-7b")
+@strict
+class T5GemmaModuleConfig(PreTrainedConfig):
+ r"""
+ query_pre_attn_scalar (`float`, *optional*, defaults to 256):
+ scaling factor used on the attention scores
+ final_logit_softcapping (`float`, *optional*, defaults to 30.0):
+ scaling factor when applying tanh softcapping on the logits.
+ attn_logit_softcapping (`float`, *optional*, defaults to 50.0):
+ scaling factor when applying tanh softcapping on the attention scores.
+
+ ```python
+ >>> from transformers import T5GemmaModuleModel, T5GemmaModuleConfig
+ >>> # Initializing a T5GemmaModule t5_gemma_module-7b style configuration
+ >>> configuration = T5GemmaModuleConfig()
+ >>> # Initializing a model from the t5_gemma_module-7b style configuration
+ >>> model = T5GemmaModuleModel(configuration)
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "t5_gemma_module"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ base_model_tp_plan = {
+ "layers.*.self_attn.q_proj": "colwise",
+ "layers.*.self_attn.k_proj": "colwise",
+ "layers.*.self_attn.v_proj": "colwise",
+ "layers.*.self_attn.o_proj": "rowwise",
+ "layers.*.mlp.gate_proj": "colwise",
+ "layers.*.mlp.up_proj": "colwise",
+ "layers.*.mlp.down_proj": "rowwise",
+ }
+ base_model_pp_plan = {
+ "embed_tokens": (["input_ids"], ["inputs_embeds"]),
+ "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
+ "norm": (["hidden_states"], ["hidden_states"]),
+ }
+
+ vocab_size: int = 256000
+ hidden_size: int = 2304
+ intermediate_size: int = 9216
+ num_hidden_layers: int = 26
+ num_attention_heads: int = 8
+ num_key_value_heads: int = 4
+ head_dim: int = 256
+ hidden_activation: str = "gelu_pytorch_tanh"
+ max_position_embeddings: int = 8192
+ initializer_range: float = 0.02
+ rms_norm_eps: float = 1e-6
+ use_cache: bool = True
+ pad_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 1
+ bos_token_id: int | None = 2
+ tie_word_embeddings: bool = True
+ rope_parameters: RopeParameters | dict | None = None
+ attention_bias: bool = False
+ attention_dropout: int | float | None = 0.0
+ query_pre_attn_scalar: int = 256
+ sliding_window: int | None = 4096
+ layer_types: list[str] | None = None
+ final_logit_softcapping: float | None = 30.0
+ attn_logit_softcapping: float | None = 50.0
+
+ is_decoder: bool = False
+
+ def __post_init__(self, **kwargs):
+ if self.layer_types is None:
+ self.layer_types = [
+ "sliding_attention" if bool((i + 1) % 2) else "full_attention" for i in range(self.num_hidden_layers)
+ ]
+
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if self.hidden_size % self.num_attention_heads != 0:
+ raise ValueError(
+ f"The hidden size ({self.hidden_size}) is not a multiple of the number of attention "
+ f"heads ({self.num_attention_heads})."
+ )
+
+
+@auto_docstring(checkpoint="google/t5_gemma_module-7b")
+@strict
+class T5GemmaConfig(PreTrainedConfig):
+ r"""
+ encoder (`Union[T5GemmaModuleConfig, dict]`, optional, *optional*):
+ Configuration for the encoder.
+ decoder (`Union[T5GemmaModuleConfig, dict]`, optional, *optional*):
+ Configuration for the decoder.
+
+ Example:
+
+ ```python
+ >>> from transformers import T5GemmaConfig, T5GemmaModel
+ >>> t5gemma_config = T5GemmaConfig.from_pretrained("google/t5gemma-2b-2b-prefixlm-it")
+ >>> model = T5GemmaModel(t5gemma_config)
+ ```"""
+
+ model_type = "t5gemma"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ sub_configs = {"encoder": T5GemmaModuleConfig, "decoder": T5GemmaModuleConfig}
+
+ encoder: T5GemmaModuleConfig | dict[Any, Any] | None = None
+ decoder: T5GemmaModuleConfig | dict[Any, Any] | None = None
+ is_encoder_decoder: bool = True
+ dropout_rate: int | float = 0.0
+ classifier_dropout_rate: int | float = 0.0
+ attention_dropout: float | int = 0.0
+ tie_word_embeddings: bool = True
+ vocab_size: int = 256000
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.encoder, dict):
+ self.encoder = T5GemmaModuleConfig(**self.encoder)
+ elif self.encoder is None:
+ self.encoder = T5GemmaModuleConfig()
+
+ if isinstance(self.decoder, dict):
+ self.decoder = T5GemmaModuleConfig(**self.decoder)
+ elif self.decoder is None:
+ self.decoder = T5GemmaModuleConfig()
+
+ self.encoder.is_decoder = False
+ self.encoder.dropout_rate = self.dropout_rate
+ self.encoder.attention_dropout = self.attention_dropout
+
+ self.decoder.is_decoder = True
+ self.decoder.use_cache = True
+ self.decoder.dropout_rate = self.dropout_rate
+ self.decoder.attention_dropout = self.attention_dropout
+ self.decoder.cross_attention_hidden_size = self.encoder.hidden_size
+
+ self.initializer_range = kwargs.pop("initializer_range", self.decoder.initializer_range)
+
+ for special_token_key in ["bos_token_id", "pad_token_id", "eos_token_id"]:
+ if special_token_key not in kwargs:
+ kwargs[special_token_key] = getattr(self.decoder, special_token_key)
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["T5GemmaConfig", "T5GemmaModuleConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma/modeling_t5gemma.py b/lib/python3.11/site-packages/transformers/models/t5gemma/modeling_t5gemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f41875c5def394f2313462e6f387faea8d57ffc
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5gemma/modeling_t5gemma.py
@@ -0,0 +1,1316 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/t5gemma/modular_t5gemma.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_t5gemma.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 Google Inc. HuggingFace Inc. 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 collections.abc import Callable
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...integrations import use_kernel_func_from_hub, use_kernelized_func
+from ...masking_utils import (
+ create_bidirectional_mask,
+ create_bidirectional_sliding_window_mask,
+ create_causal_mask,
+ create_sliding_window_causal_mask,
+)
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ BaseModelOutputWithPastAndCrossAttentions,
+ Seq2SeqLMOutput,
+ Seq2SeqModelOutput,
+ SequenceClassifierOutput,
+ TokenClassifierOutput,
+)
+from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, logging
+from ...utils.generic import maybe_autocast, merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from .configuration_t5gemma import T5GemmaConfig, T5GemmaModuleConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+class T5GemmaRMSNorm(nn.Module):
+ def __init__(self, dim: int, eps: float = 1e-6):
+ super().__init__()
+ self.eps = eps
+ self.weight = nn.Parameter(torch.zeros(dim))
+
+ def _norm(self, x):
+ return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+ def forward(self, x):
+ output = self._norm(x.float())
+ # Llama does x.to(float16) * w whilst T5Gemma is (x * w).to(float16)
+ # See https://github.com/huggingface/transformers/pull/29402
+ output = output * (1.0 + self.weight.float())
+ return output.type_as(x)
+
+ def extra_repr(self):
+ return f"{tuple(self.weight.shape)}, eps={self.eps}"
+
+
+class T5GemmaMLP(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.hidden_size = config.hidden_size
+ self.intermediate_size = config.intermediate_size
+ self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+ self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+ self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
+ self.act_fn = ACT2FN[config.hidden_activation]
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(self, x):
+ hidden_states = self.act_fn(self.gate_proj(x)) * self.up_proj(x)
+ hidden_states = self.dropout(hidden_states)
+ down_proj = self.down_proj(hidden_states)
+ return down_proj
+
+
+class T5GemmaRotaryEmbedding(nn.Module):
+ inv_freq: torch.Tensor # fix linting for `register_buffer`
+
+ def __init__(self, config: T5GemmaConfig, device=None):
+ super().__init__()
+ self.max_seq_len_cached = config.max_position_embeddings
+ self.original_max_seq_len = config.max_position_embeddings
+
+ self.config = config
+
+ self.rope_type = self.config.rope_parameters["rope_type"]
+ rope_init_fn: Callable = self.compute_default_rope_parameters
+ if self.rope_type != "default":
+ rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
+ inv_freq, self.attention_scaling = rope_init_fn(self.config, device)
+
+ self.register_buffer("inv_freq", inv_freq, persistent=False)
+ self.register_buffer("original_inv_freq", inv_freq.clone(), persistent=False)
+
+ @staticmethod
+ def compute_default_rope_parameters(
+ config: T5GemmaConfig | None = None,
+ device: Optional["torch.device"] = None,
+ seq_len: int | None = None,
+ ) -> tuple["torch.Tensor", float]:
+ """
+ Computes the inverse frequencies according to the original RoPE implementation
+ Args:
+ config ([`~transformers.PreTrainedConfig`]):
+ The model configuration.
+ device (`torch.device`):
+ The device to use for initialization of the inverse frequencies.
+ seq_len (`int`, *optional*):
+ The current sequence length. Unused for this type of RoPE.
+ Returns:
+ Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
+ post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
+ """
+ base = config.rope_parameters["rope_theta"]
+ dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
+
+ attention_factor = 1.0 # Unused in this type of RoPE
+
+ # Compute the inverse frequencies
+ inv_freq = 1.0 / (
+ base ** (torch.arange(0, dim, 2, dtype=torch.int64).to(device=device, dtype=torch.float) / dim)
+ )
+ return inv_freq, attention_factor
+
+ @torch.no_grad()
+ @dynamic_rope_update # power user: used with advanced RoPE types (e.g. dynamic rope)
+ def forward(self, x, position_ids):
+ inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)
+ position_ids_expanded = position_ids[:, None, :].float()
+
+ device_type = x.device.type if isinstance(x.device.type, str) and x.device.type != "mps" else "cpu"
+ with maybe_autocast(device_type=device_type, enabled=False): # Force float32
+ freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2)
+ emb = torch.cat((freqs, freqs), dim=-1)
+ cos = emb.cos() * self.attention_scaling
+ sin = emb.sin() * self.attention_scaling
+
+ return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+def rotate_half(x):
+ """Rotates half the hidden dims of the input."""
+ x1 = x[..., : x.shape[-1] // 2]
+ x2 = x[..., x.shape[-1] // 2 :]
+ return torch.cat((-x2, x1), dim=-1)
+
+
+@use_kernel_func_from_hub("rotary_pos_emb")
+def apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1):
+ """Applies Rotary Position Embedding to the query and key tensors.
+
+ Args:
+ q (`torch.Tensor`): The query tensor.
+ k (`torch.Tensor`): The key tensor.
+ cos (`torch.Tensor`): The cosine part of the rotary embedding.
+ sin (`torch.Tensor`): The sine part of the rotary embedding.
+ unsqueeze_dim (`int`, *optional*, defaults to 1):
+ The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+ sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+ that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+ k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+ cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+ the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+ Returns:
+ `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+ """
+ cos = cos.unsqueeze(unsqueeze_dim)
+ sin = sin.unsqueeze(unsqueeze_dim)
+ q_embed = (q * cos) + (rotate_half(q) * sin)
+ k_embed = (k * cos) + (rotate_half(k) * sin)
+ return q_embed, k_embed
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+ """
+ This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+ num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+ """
+ batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+ if n_rep == 1:
+ return hidden_states
+ hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+ return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ dropout: float | int = 0.0,
+ scaling: float | None = None,
+ softcap: float | None = None,
+ **kwargs,
+) -> tuple[torch.Tensor, torch.Tensor]:
+ if scaling is None:
+ scaling = module.head_dim**-0.5
+
+ key_states = repeat_kv(key, module.num_key_value_groups)
+ value_states = repeat_kv(value, module.num_key_value_groups)
+
+ attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
+
+ if softcap is not None:
+ attn_weights = attn_weights / softcap
+ attn_weights = torch.tanh(attn_weights)
+ attn_weights = attn_weights * softcap
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ # upcast attention to fp32
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value_states)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ return attn_output, attn_weights
+
+
+@use_kernelized_func(apply_rotary_pos_emb)
+class T5GemmaSelfAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config: T5GemmaModuleConfig, layer_idx: int):
+ super().__init__()
+ self.layer_type = config.layer_types[layer_idx] if hasattr(config, "layer_types") else None
+ self.config = config
+ self.layer_idx = layer_idx
+ self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+ self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
+ self.scaling = config.query_pre_attn_scalar**-0.5
+ self.attention_dropout = self.config.attention_dropout
+ # Required by flash attention: encoder selfattention is non-causal
+ self.is_causal = config.is_decoder
+
+ self.q_proj = nn.Linear(
+ config.hidden_size, config.num_attention_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.k_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.v_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.o_proj = nn.Linear(
+ config.num_attention_heads * self.head_dim, config.hidden_size, bias=config.attention_bias
+ )
+ self.attn_logit_softcapping = self.config.attn_logit_softcapping
+ self.sliding_window = config.sliding_window if self.layer_type == "sliding_attention" else None
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ if past_key_values is not None:
+ key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=self.attention_dropout if self.training else 0.0,
+ scaling=self.scaling,
+ sliding_window=self.sliding_window,
+ softcap=self.attn_logit_softcapping,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+@use_kernelized_func(apply_rotary_pos_emb)
+class T5GemmaCrossAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config: T5GemmaModuleConfig, layer_idx: int):
+ super().__init__()
+ self.config = config
+ self.layer_idx = layer_idx
+ self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+ self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
+ self.scaling = config.query_pre_attn_scalar**-0.5
+ self.attention_dropout = self.config.attention_dropout
+ self.is_causal = False
+
+ self.q_proj = nn.Linear(
+ config.hidden_size, config.num_attention_heads * self.head_dim, bias=config.attention_bias
+ )
+
+ self.k_proj = nn.Linear(
+ config.cross_attention_hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.v_proj = nn.Linear(
+ config.cross_attention_hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.o_proj = nn.Linear(
+ config.num_attention_heads * self.head_dim, config.hidden_size, bias=config.attention_bias
+ )
+ self.attn_logit_softcapping = self.config.attn_logit_softcapping
+
+ if config.cross_attention_hidden_size is None:
+ raise ValueError("Cross-attention needs cross_attention_hidden_size to be specified.")
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ encoder_hidden_states: torch.Tensor | None,
+ past_key_values: Cache | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ if encoder_hidden_states is None:
+ raise ValueError("Encoder hidden state is required for cross attention.")
+
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ curr_past_key_values = past_key_values.cross_attention_cache
+
+ if past_key_values is None or not is_updated:
+ encoder_input_shape = encoder_hidden_states.shape[:-1]
+ encoder_hidden_shape = (*encoder_input_shape, -1, self.head_dim)
+ key_states = self.k_proj(encoder_hidden_states).view(encoder_hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(encoder_hidden_states).view(encoder_hidden_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ past_key_values.is_updated[self.layer_idx] = True
+ else:
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=self.attention_dropout if self.training else 0.0,
+ scaling=self.scaling,
+ sliding_window=None,
+ softcap=self.attn_logit_softcapping,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+class T5GemmaEncoderLayer(GradientCheckpointingLayer):
+ """Encoder sub-layer."""
+
+ def __init__(self, config, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+ self.config = config
+ self.layer_idx = layer_idx
+ self.attention_type = config.layer_types[layer_idx]
+
+ self.self_attn = T5GemmaSelfAttention(
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.pre_self_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_self_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.mlp = T5GemmaMLP(config)
+ self.pre_feedforward_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_feedforward_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor,]:
+ residual = hidden_states
+ hidden_states = self.pre_self_attn_layernorm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=None,
+ **kwargs,
+ )
+ hidden_states = self.post_self_attn_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.post_feedforward_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+ return hidden_states
+
+
+class T5GemmaDecoderLayer(GradientCheckpointingLayer):
+ """Decoder sub-layer: an extra cross-attention layer."""
+
+ def __init__(self, config, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+ self.config = config
+ self.layer_idx = layer_idx
+ self.attention_type = config.layer_types[layer_idx]
+
+ self.self_attn = T5GemmaSelfAttention(
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.pre_self_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_self_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.mlp = T5GemmaMLP(config)
+ self.pre_feedforward_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_feedforward_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.cross_attn = T5GemmaCrossAttention(config=config, layer_idx=layer_idx)
+ self.pre_cross_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_cross_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ use_cache: bool | None = False,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ **kwargs,
+ ) -> torch.FloatTensor:
+ residual = hidden_states
+ hidden_states = self.pre_self_attn_layernorm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values.self_attention_cache if past_key_values is not None else None,
+ use_cache=use_cache,
+ **kwargs,
+ )
+ hidden_states = self.post_self_attn_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.pre_cross_attn_layernorm(hidden_states)
+ hidden_states, _ = self.cross_attn(
+ hidden_states=hidden_states,
+ encoder_hidden_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+ hidden_states = self.post_cross_attn_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.post_feedforward_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+ return hidden_states
+
+
+class T5GemmaClassificationHead(nn.Module):
+ """Head for sentence-level classification tasks."""
+
+ def __init__(self, hidden_size: int, num_labels: int, classifier_dropout_rate: float = 0.0):
+ super().__init__()
+ self.dropout = nn.Dropout(p=classifier_dropout_rate)
+ self.out_proj = nn.Linear(hidden_size, num_labels)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.out_proj(hidden_states)
+ return hidden_states
+
+
+class T5GemmaLMHead(nn.Module):
+ """Head for language modeling (generation) tasks."""
+
+ def __init__(self, hidden_size: int, vocab_size: int, bias: bool = False):
+ super().__init__()
+ self.out_proj = nn.Linear(hidden_size, vocab_size, bias=bias)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ logits = self.out_proj(hidden_states)
+ return logits
+
+
+@auto_docstring
+class T5GemmaPreTrainedModel(PreTrainedModel):
+ config: T5GemmaConfig
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["T5GemmaEncoderLayer", "T5GemmaDecoderLayer"]
+ _skip_keys_device_placement = ["past_key_values"]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+
+ _can_compile_fullgraph = True
+ _supports_attention_backend = True
+ _can_record_outputs = {
+ "hidden_states": T5GemmaDecoderLayer,
+ "attentions": [
+ OutputRecorder(T5GemmaSelfAttention, index=1, layer_name="self_attn"),
+ OutputRecorder(T5GemmaSelfAttention, index=1, layer_name="cross_attn"),
+ OutputRecorder(T5GemmaCrossAttention, index=1, layer_name="cross_attn"),
+ ],
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ # TODO: support initialization for encoders and decoders separately(?)
+ super()._init_weights(module)
+ std = self.config.initializer_range
+ if isinstance(module, T5GemmaClassificationHead):
+ scale = module.out_proj.weight.shape[0] ** -0.5
+ init.normal_(module.out_proj.weight, mean=0.0, std=std * scale)
+ if hasattr(module.out_proj, "bias") and module.out_proj.bias is not None:
+ init.zeros_(module.out_proj.bias)
+ elif isinstance(module, T5GemmaLMHead):
+ if not self.config.tie_word_embeddings:
+ scale = module.out_proj.weight.shape[0] ** -0.5
+ init.normal_(module.out_proj.weight, mean=0.0, std=std * scale)
+ # We initialize with 0s to be 1 centered as the RMSNorm here does (1 + weight)
+ elif "RMSNorm" in module.__class__.__name__:
+ init.zeros_(module.weight)
+
+ def _shift_right(self, input_ids):
+ """
+ Shifts input_ids to the right, prepends the decoder_start_token_id, and handles
+ pad_token_id replacement for labels that were -100.
+ This is a common preparation step for decoder inputs in sequence-to-sequence models.
+ """
+ decoder_start_token_id = self.config.decoder.bos_token_id
+ pad_token_id = self.config.decoder.pad_token_id
+
+ if decoder_start_token_id is None:
+ raise ValueError("self.model.config.decoder.bos_token_id has to be defined. ")
+
+ # shift inputs to the right
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
+ shifted_input_ids[..., 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.decoder.pad_token_id has to be defined.")
+
+ # Is this T5 specific?
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+def make_default_2d_attention_mask(
+ token_ids: torch.LongTensor | None,
+ hidden_states: torch.Tensor,
+ pad_token_id: int | None,
+) -> torch.Tensor:
+ """Construct the default attention mask."""
+ if token_ids is not None:
+ if pad_token_id is None:
+ raise ValueError("`pad_token_id` is required for padding information.")
+ attention_mask = (token_ids != pad_token_id).to(hidden_states.device, torch.long)
+ else:
+ attention_mask = torch.ones(
+ (hidden_states.shape[0], hidden_states.shape[1]), device=hidden_states.device, dtype=torch.long
+ )
+ return attention_mask
+
+
+class T5GemmaEncoder(T5GemmaPreTrainedModel):
+ _can_record_outputs = {
+ "attentions": T5GemmaSelfAttention,
+ "hidden_states": T5GemmaEncoderLayer,
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+ self.norm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.gradient_checkpointing = False
+
+ self.layers = nn.ModuleList(
+ [T5GemmaEncoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.rotary_emb = T5GemmaRotaryEmbedding(config=config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutput:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ # As we want to pass `past_key_values=None` explicitly everywhere, we need to pop them from kwargs if present
+ kwargs.pop("past_key_values", None)
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if position_ids is None:
+ position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device)
+ position_ids = position_ids.unsqueeze(0)
+
+ if attention_mask is None:
+ attention_mask = make_default_2d_attention_mask(input_ids, inputs_embeds, self.config.pad_token_id)
+
+ if not isinstance(self_attn_mask_mapping := attention_mask, dict):
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ }
+ self_attn_mask_mapping = {
+ "full_attention": create_bidirectional_mask(**mask_kwargs),
+ "sliding_attention": create_bidirectional_sliding_window_mask(**mask_kwargs),
+ }
+
+ hidden_states = inputs_embeds
+ normalizer = torch.tensor(self.config.hidden_size**0.5, dtype=hidden_states.dtype)
+ hidden_states = hidden_states * normalizer
+ hidden_states = self.dropout(hidden_states)
+
+ position_embeddings = self.rotary_emb(hidden_states, position_ids)
+
+ for i, layer_module in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = layer_module(
+ hidden_states,
+ position_embeddings,
+ self_attn_mask_mapping[self.config.layer_types[i]],
+ position_ids,
+ **kwargs,
+ )
+ hidden_states = self.norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ )
+
+
+class T5GemmaDecoder(T5GemmaPreTrainedModel):
+ _can_record_outputs = {
+ "attentions": OutputRecorder(T5GemmaSelfAttention, index=1),
+ "cross_attentions": OutputRecorder(T5GemmaCrossAttention, index=1),
+ "hidden_states": T5GemmaDecoderLayer,
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+ self.norm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.gradient_checkpointing = False
+
+ self.layers = nn.ModuleList(
+ [T5GemmaDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.rotary_emb = T5GemmaRotaryEmbedding(config=config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPastAndCrossAttentions:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+ if encoder_hidden_states is None:
+ raise ValueError("`encoder_hidden_states` must be given in decoder")
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if not self.training and use_cache and past_key_values is None:
+ # We do not pass the config to the cross attn cache to avoid initializing SWA
+ # --> we use full attention between our cross attentions
+ past_key_values = EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache())
+
+ if position_ids is None:
+ past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+ position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens
+ position_ids = position_ids.unsqueeze(0)
+
+ if attention_mask is None and past_key_values is None:
+ attention_mask = make_default_2d_attention_mask(input_ids, inputs_embeds, self.config.pad_token_id)
+
+ if not isinstance(self_attn_mask_mapping := attention_mask, dict):
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ "past_key_values": past_key_values.self_attention_cache if past_key_values is not None else None,
+ "position_ids": position_ids,
+ }
+ self_attn_mask_mapping = {
+ "full_attention": create_causal_mask(**mask_kwargs),
+ "sliding_attention": create_sliding_window_causal_mask(**mask_kwargs),
+ }
+
+ if not isinstance(cross_attn_mask_mapping := encoder_attention_mask, dict):
+ cross_attn_mask_mapping = {
+ "full_attention": create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+ }
+
+ hidden_states = inputs_embeds
+ normalizer = torch.tensor(self.config.hidden_size**0.5, dtype=hidden_states.dtype)
+ hidden_states = hidden_states * normalizer
+ hidden_states = self.dropout(hidden_states)
+
+ position_embeddings = self.rotary_emb(hidden_states, position_ids)
+
+ for i, layer_module in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = layer_module(
+ hidden_states,
+ position_embeddings,
+ self_attn_mask_mapping[self.config.layer_types[i]],
+ position_ids,
+ past_key_values,
+ use_cache,
+ encoder_hidden_states,
+ cross_attn_mask_mapping["full_attention"],
+ **kwargs,
+ )
+ hidden_states = self.norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class T5GemmaModel(T5GemmaPreTrainedModel):
+ def __init__(self, config: T5GemmaConfig):
+ super().__init__(config)
+
+ if not config.is_encoder_decoder:
+ raise ValueError("T5GemmaModel only support encoder-decoder modeling. Use `T5GemmaEncoderModel` instead.")
+
+ self.encoder = T5GemmaEncoder(config.encoder)
+ self.decoder = T5GemmaDecoder(config.decoder)
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.encoder.get_input_embeddings()
+
+ def set_input_embeddings(self, new_embeddings):
+ return self.encoder.set_input_embeddings(new_embeddings)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ decoder_inputs_embeds: torch.Tensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> Seq2SeqModelOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ """
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ **kwargs,
+ )
+
+ encoder_hidden_states = encoder_outputs.last_hidden_state
+
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ position_ids=decoder_position_ids,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return Seq2SeqModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states
+ if kwargs.get("output_hidden_states", False)
+ else (decoder_outputs.last_hidden_state,),
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring
+class T5GemmaEncoderModel(T5GemmaPreTrainedModel):
+ def __init__(self, config: T5GemmaConfig):
+ super().__init__(config)
+
+ if config.is_encoder_decoder:
+ raise ValueError("T5GemmaEncoderModel only supports encoder-only model. Use `T5GemmaModel` instead.")
+
+ self.encoder = T5GemmaEncoder(config.encoder)
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.encoder.get_input_embeddings()
+
+ def set_input_embeddings(self, new_embeddings):
+ return self.encoder.set_input_embeddings(new_embeddings)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ **kwargs,
+ )
+ return encoder_outputs
+
+
+class T5GemmaForConditionalGeneration(T5GemmaPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"lm_head.out_proj.weight": "model.decoder.embed_tokens.weight"}
+ _tp_plan = {"lm_head.out_proj": "colwise_gather_output"}
+ _pp_plan = {"lm_head.out_proj": (["hidden_states"], ["logits"])}
+
+ def __init__(self, config: T5GemmaConfig):
+ config.is_encoder_decoder = True
+ super().__init__(config)
+
+ self.model = T5GemmaModel(config)
+ self.vocab_size = config.decoder.vocab_size
+ self.lm_head = T5GemmaLMHead(config.decoder.hidden_size, self.vocab_size)
+ self.loss_type = "ForMaskedLM"
+
+ self.post_init()
+
+ def set_output_embeddings(self, new_embeddings):
+ self.lm_head.out_proj = new_embeddings
+ # The tying happens from decoder to lm-head, but when resizing
+ # the resized embed is assigned only to the head. Then tying weights
+ # again reverts everything back. So we have to update decoder here
+ if self.config.tie_word_embeddings:
+ self.model.decoder.embed_tokens.weight = new_embeddings.weight
+ self.model.decoder.embed_tokens.num_embeddings = new_embeddings.weight.shape[0]
+
+ def get_output_embeddings(self):
+ return self.lm_head.out_proj
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ logits_to_keep: int | torch.Tensor = 0,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqLMOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+ """
+
+ if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
+ # get decoder inputs from shifting lm labels to the right
+ decoder_input_ids = self._shift_right(labels)
+
+ decoder_outputs: Seq2SeqModelOutput = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = decoder_outputs.last_hidden_state
+ # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+ slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+ logits = self.lm_head(hidden_states[:, slice_indices, :])
+ decoder_config = self.get_decoder().config
+ if decoder_config.final_logit_softcapping is not None:
+ logits = logits / decoder_config.final_logit_softcapping
+ logits = torch.tanh(logits)
+ logits = logits * decoder_config.final_logit_softcapping
+
+ loss = None
+ if labels is not None:
+ # Input has right-shifted so we directly perform masked lm loss
+ loss = self.loss_function(logits, labels, self.vocab_size, **kwargs)
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.decoder_hidden_states,
+ decoder_attentions=decoder_outputs.decoder_attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=decoder_outputs.encoder_last_hidden_state,
+ encoder_hidden_states=decoder_outputs.encoder_hidden_states,
+ encoder_attentions=decoder_outputs.encoder_attentions,
+ )
+
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+ return self._shift_right(labels)
+
+
+@auto_docstring
+class T5GemmaForSequenceClassification(T5GemmaPreTrainedModel):
+ def __init__(self, config: T5GemmaConfig, is_encoder_decoder: bool | None = None):
+ r"""
+ is_encoder_decoder (`Optional`, *optional*):
+ Whether use encoder_decoder for sequence classification. When set to False, only encoder is used.
+ """
+ if is_encoder_decoder is not None:
+ config.is_encoder_decoder = is_encoder_decoder
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ if config.is_encoder_decoder:
+ self.model = T5GemmaModel(config)
+ else:
+ self.model = T5GemmaEncoderModel(config)
+
+ hidden_size = config.encoder.hidden_size
+ if config.is_encoder_decoder:
+ hidden_size = config.decoder.hidden_size
+
+ classifier_dropout = getattr(config, "classifier_dropout_rate", 0.1)
+ self.score = T5GemmaClassificationHead(hidden_size, self.num_labels, classifier_dropout)
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.Tensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SequenceClassifierOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ if self.config.is_encoder_decoder and (input_ids is None and inputs_embeds is not None):
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__} in encoder-decoder mode."
+ )
+
+ # Following T5, we automatically creates decoder_input_ids from input_ids if no decoder_input_ids are provided
+ if self.config.is_encoder_decoder and (decoder_input_ids is None and decoder_inputs_embeds is None):
+ if input_ids is None:
+ raise ValueError(
+ "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+ "passed, `input_ids` cannot be `None`. Please pass either "
+ "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+ )
+ decoder_input_ids = self._shift_right(input_ids)
+
+ if self.config.is_encoder_decoder:
+ outputs: Seq2SeqModelOutput = self.model(
+ input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=False,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.decoder_hidden_states
+ attentions = outputs.decoder_attentions
+ else:
+ outputs: BaseModelOutput = self.model(
+ input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.hidden_states
+ attentions = outputs.attentions
+
+ logits = self.score(last_hidden_state)
+
+ if input_ids is not None:
+ batch_size = input_ids.shape[0]
+ else:
+ batch_size = inputs_embeds.shape[0]
+
+ if self.config.pad_token_id is None and batch_size != 1:
+ raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
+ if self.config.pad_token_id is None:
+ last_non_pad_token = -1
+ elif input_ids is not None:
+ # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
+ non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
+ token_indices = torch.arange(input_ids.shape[-1], device=logits.device, dtype=torch.int32)
+ last_non_pad_token = (token_indices * non_pad_mask).argmax(-1)
+
+ if self.config.is_encoder_decoder:
+ last_non_pad_token += 1 # due to the right shift.
+ last_non_pad_token = torch.clamp(last_non_pad_token, max=decoder_input_ids.shape[-1] - 1)
+ else:
+ last_non_pad_token = -1
+ logger.warning_once(
+ f"{self.__class__.__name__} will not detect padding tokens in `inputs_embeds`. Results may be "
+ "unexpected if using padding tokens in conjunction with `inputs_embeds.`"
+ )
+
+ pooled_logits = logits[torch.arange(batch_size, device=logits.device), last_non_pad_token]
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits=logits, labels=labels, pooled_logits=pooled_logits, config=self.config)
+
+ return SequenceClassifierOutput(
+ loss=loss,
+ logits=pooled_logits,
+ hidden_states=hidden_states,
+ attentions=attentions,
+ )
+
+
+@auto_docstring
+class T5GemmaForTokenClassification(T5GemmaPreTrainedModel):
+ def __init__(self, config: T5GemmaConfig, is_encoder_decoder: bool | None = None):
+ r"""
+ is_encoder_decoder (`Optional`, *optional*):
+ Whether use encoder_decoder for token classification. When set to False, only encoder is used.
+ """
+ if is_encoder_decoder is not None:
+ config.is_encoder_decoder = is_encoder_decoder
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ if config.is_encoder_decoder:
+ self.model = T5GemmaModel(config)
+ else:
+ self.model = T5GemmaEncoderModel(config)
+
+ hidden_size = config.encoder.hidden_size
+ if config.is_encoder_decoder:
+ hidden_size = config.decoder.hidden_size
+
+ classifier_dropout = getattr(config, "classifier_dropout_rate", 0.1)
+ self.score = T5GemmaClassificationHead(hidden_size, self.num_labels, classifier_dropout)
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.Tensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TokenClassifierOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+
+ if self.config.is_encoder_decoder and (input_ids is None and inputs_embeds is not None):
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__} in encoder-decoder mode."
+ )
+
+ if self.config.is_encoder_decoder and (decoder_input_ids is None and decoder_inputs_embeds is None):
+ if input_ids is None:
+ raise ValueError(
+ "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+ "passed, `input_ids` cannot be `None`. Please pass either "
+ "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+ )
+ decoder_input_ids = self._shift_right(input_ids)
+
+ if self.config.is_encoder_decoder:
+ outputs: Seq2SeqModelOutput = self.model(
+ input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=False,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.decoder_hidden_states
+ attentions = outputs.decoder_attentions
+ else:
+ outputs: BaseModelOutput = self.model(
+ input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.hidden_states
+ attentions = outputs.attentions
+
+ logits = self.score(last_hidden_state)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits, labels, self.config)
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=hidden_states,
+ attentions=attentions,
+ )
+
+
+__all__ = [
+ "T5GemmaForConditionalGeneration",
+ "T5GemmaModel",
+ "T5GemmaEncoderModel",
+ "T5GemmaPreTrainedModel",
+ "T5GemmaForSequenceClassification",
+ "T5GemmaForTokenClassification",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma/modular_t5gemma.py b/lib/python3.11/site-packages/transformers/models/t5gemma/modular_t5gemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c8846ad74b909e95a7e669daa35bc7f922f1beb
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5gemma/modular_t5gemma.py
@@ -0,0 +1,1157 @@
+# Copyright 2025 Google Inc. HuggingFace Inc. 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 collections.abc import Callable
+from typing import Any
+
+import torch
+import torch.nn as nn
+from huggingface_hub.dataclasses import strict
+
+from ... import initialization as init
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...configuration_utils import PreTrainedConfig
+from ...generation import GenerationMixin
+from ...masking_utils import (
+ create_bidirectional_mask,
+ create_bidirectional_sliding_window_mask,
+ create_causal_mask,
+ create_sliding_window_causal_mask,
+)
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ BaseModelOutputWithPastAndCrossAttentions,
+ Seq2SeqLMOutput,
+ Seq2SeqModelOutput,
+ SequenceClassifierOutput,
+ TokenClassifierOutput,
+)
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import (
+ TransformersKwargs,
+ auto_docstring,
+ can_return_tuple,
+ logging,
+)
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from ..gemma2.configuration_gemma2 import Gemma2Config
+from ..gemma2.modeling_gemma2 import (
+ Gemma2Attention,
+ Gemma2MLP,
+ Gemma2PreTrainedModel,
+ Gemma2RMSNorm,
+ Gemma2RotaryEmbedding,
+ eager_attention_forward,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="google/t5_gemma_module-7b")
+@strict
+class T5GemmaModuleConfig(Gemma2Config):
+ r"""
+ query_pre_attn_scalar (`float`, *optional*, defaults to 256):
+ scaling factor used on the attention scores
+ final_logit_softcapping (`float`, *optional*, defaults to 30.0):
+ scaling factor when applying tanh softcapping on the logits.
+ attn_logit_softcapping (`float`, *optional*, defaults to 50.0):
+ scaling factor when applying tanh softcapping on the attention scores.
+
+ ```python
+ >>> from transformers import T5GemmaModuleModel, T5GemmaModuleConfig
+ >>> # Initializing a T5GemmaModule t5_gemma_module-7b style configuration
+ >>> configuration = T5GemmaModuleConfig()
+ >>> # Initializing a model from the t5_gemma_module-7b style configuration
+ >>> model = T5GemmaModuleModel(configuration)
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ is_decoder: bool = False
+ use_bidirectional_attention = AttributeError()
+
+
+@auto_docstring(checkpoint="google/t5_gemma_module-7b")
+@strict
+class T5GemmaConfig(PreTrainedConfig):
+ r"""
+ encoder (`Union[T5GemmaModuleConfig, dict]`, optional, *optional*):
+ Configuration for the encoder.
+ decoder (`Union[T5GemmaModuleConfig, dict]`, optional, *optional*):
+ Configuration for the decoder.
+
+ Example:
+
+ ```python
+ >>> from transformers import T5GemmaConfig, T5GemmaModel
+ >>> t5gemma_config = T5GemmaConfig.from_pretrained("google/t5gemma-2b-2b-prefixlm-it")
+ >>> model = T5GemmaModel(t5gemma_config)
+ ```"""
+
+ model_type = "t5gemma"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ sub_configs = {"encoder": T5GemmaModuleConfig, "decoder": T5GemmaModuleConfig}
+
+ encoder: T5GemmaModuleConfig | dict[Any, Any] | None = None
+ decoder: T5GemmaModuleConfig | dict[Any, Any] | None = None
+ is_encoder_decoder: bool = True
+ dropout_rate: int | float = 0.0
+ classifier_dropout_rate: int | float = 0.0
+ attention_dropout: float | int = 0.0
+ tie_word_embeddings: bool = True
+ vocab_size: int = 256000
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.encoder, dict):
+ self.encoder = T5GemmaModuleConfig(**self.encoder)
+ elif self.encoder is None:
+ self.encoder = T5GemmaModuleConfig()
+
+ if isinstance(self.decoder, dict):
+ self.decoder = T5GemmaModuleConfig(**self.decoder)
+ elif self.decoder is None:
+ self.decoder = T5GemmaModuleConfig()
+
+ self.encoder.is_decoder = False
+ self.encoder.dropout_rate = self.dropout_rate
+ self.encoder.attention_dropout = self.attention_dropout
+
+ self.decoder.is_decoder = True
+ self.decoder.use_cache = True
+ self.decoder.dropout_rate = self.dropout_rate
+ self.decoder.attention_dropout = self.attention_dropout
+ self.decoder.cross_attention_hidden_size = self.encoder.hidden_size
+
+ self.initializer_range = kwargs.pop("initializer_range", self.decoder.initializer_range)
+
+ for special_token_key in ["bos_token_id", "pad_token_id", "eos_token_id"]:
+ if special_token_key not in kwargs:
+ kwargs[special_token_key] = getattr(self.decoder, special_token_key)
+
+ super().__post_init__(**kwargs)
+
+
+class T5GemmaRMSNorm(Gemma2RMSNorm):
+ pass
+
+
+class T5GemmaMLP(Gemma2MLP):
+ def __init__(self, config):
+ super().__init__(config)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(self, x):
+ hidden_states = self.act_fn(self.gate_proj(x)) * self.up_proj(x)
+ hidden_states = self.dropout(hidden_states)
+ down_proj = self.down_proj(hidden_states)
+ return down_proj
+
+
+class T5GemmaRotaryEmbedding(Gemma2RotaryEmbedding):
+ pass
+
+
+class T5GemmaSelfAttention(Gemma2Attention):
+ def __init__(self, config: T5GemmaModuleConfig, layer_idx: int):
+ super().__init__(config, layer_idx)
+ # Required by flash attention: encoder selfattention is non-causal
+ self.is_causal = config.is_decoder
+
+
+class T5GemmaCrossAttention(Gemma2Attention):
+ def __init__(self, config: T5GemmaModuleConfig, layer_idx: int):
+ super().__init__(config, layer_idx)
+ del self.sliding_window
+ del self.layer_type
+ self.is_causal = False
+
+ if config.cross_attention_hidden_size is None:
+ raise ValueError("Cross-attention needs cross_attention_hidden_size to be specified.")
+
+ self.k_proj = nn.Linear(
+ config.cross_attention_hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.v_proj = nn.Linear(
+ config.cross_attention_hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ encoder_hidden_states: torch.Tensor | None,
+ past_key_values: Cache | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ if encoder_hidden_states is None:
+ raise ValueError("Encoder hidden state is required for cross attention.")
+
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ curr_past_key_values = past_key_values.cross_attention_cache
+
+ if past_key_values is None or not is_updated:
+ encoder_input_shape = encoder_hidden_states.shape[:-1]
+ encoder_hidden_shape = (*encoder_input_shape, -1, self.head_dim)
+ key_states = self.k_proj(encoder_hidden_states).view(encoder_hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(encoder_hidden_states).view(encoder_hidden_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ past_key_values.is_updated[self.layer_idx] = True
+ else:
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=self.attention_dropout if self.training else 0.0,
+ scaling=self.scaling,
+ sliding_window=None,
+ softcap=self.attn_logit_softcapping,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+class T5GemmaEncoderLayer(GradientCheckpointingLayer):
+ """Encoder sub-layer."""
+
+ def __init__(self, config, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+ self.config = config
+ self.layer_idx = layer_idx
+ self.attention_type = config.layer_types[layer_idx]
+
+ self.self_attn = T5GemmaSelfAttention(
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.pre_self_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_self_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.mlp = T5GemmaMLP(config)
+ self.pre_feedforward_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_feedforward_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor,]:
+ residual = hidden_states
+ hidden_states = self.pre_self_attn_layernorm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=None,
+ **kwargs,
+ )
+ hidden_states = self.post_self_attn_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.post_feedforward_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+ return hidden_states
+
+
+class T5GemmaDecoderLayer(GradientCheckpointingLayer):
+ """Decoder sub-layer: an extra cross-attention layer."""
+
+ def __init__(self, config, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+ self.config = config
+ self.layer_idx = layer_idx
+ self.attention_type = config.layer_types[layer_idx]
+
+ self.self_attn = T5GemmaSelfAttention(
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.pre_self_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_self_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.mlp = T5GemmaMLP(config)
+ self.pre_feedforward_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_feedforward_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.cross_attn = T5GemmaCrossAttention(config=config, layer_idx=layer_idx)
+ self.pre_cross_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_cross_attn_layernorm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ use_cache: bool | None = False,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ **kwargs,
+ ) -> torch.FloatTensor:
+ residual = hidden_states
+ hidden_states = self.pre_self_attn_layernorm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values.self_attention_cache if past_key_values is not None else None,
+ use_cache=use_cache,
+ **kwargs,
+ )
+ hidden_states = self.post_self_attn_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.pre_cross_attn_layernorm(hidden_states)
+ hidden_states, _ = self.cross_attn(
+ hidden_states=hidden_states,
+ encoder_hidden_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+ hidden_states = self.post_cross_attn_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.post_feedforward_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+ return hidden_states
+
+
+class T5GemmaClassificationHead(nn.Module):
+ """Head for sentence-level classification tasks."""
+
+ def __init__(self, hidden_size: int, num_labels: int, classifier_dropout_rate: float = 0.0):
+ super().__init__()
+ self.dropout = nn.Dropout(p=classifier_dropout_rate)
+ self.out_proj = nn.Linear(hidden_size, num_labels)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.out_proj(hidden_states)
+ return hidden_states
+
+
+class T5GemmaLMHead(nn.Module):
+ """Head for language modeling (generation) tasks."""
+
+ def __init__(self, hidden_size: int, vocab_size: int, bias: bool = False):
+ super().__init__()
+ self.out_proj = nn.Linear(hidden_size, vocab_size, bias=bias)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ logits = self.out_proj(hidden_states)
+ return logits
+
+
+@auto_docstring
+class T5GemmaPreTrainedModel(Gemma2PreTrainedModel):
+ config: T5GemmaConfig
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["T5GemmaEncoderLayer", "T5GemmaDecoderLayer"]
+ _can_record_outputs = {
+ "hidden_states": T5GemmaDecoderLayer,
+ "attentions": [
+ OutputRecorder(T5GemmaSelfAttention, index=1, layer_name="self_attn"),
+ OutputRecorder(T5GemmaSelfAttention, index=1, layer_name="cross_attn"),
+ OutputRecorder(T5GemmaCrossAttention, index=1, layer_name="cross_attn"),
+ ],
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ # TODO: support initialization for encoders and decoders separately(?)
+ PreTrainedModel._init_weights(self, module)
+ std = self.config.initializer_range
+ if isinstance(module, T5GemmaClassificationHead):
+ scale = module.out_proj.weight.shape[0] ** -0.5
+ init.normal_(module.out_proj.weight, mean=0.0, std=std * scale)
+ if hasattr(module.out_proj, "bias") and module.out_proj.bias is not None:
+ init.zeros_(module.out_proj.bias)
+ elif isinstance(module, T5GemmaLMHead):
+ if not self.config.tie_word_embeddings:
+ scale = module.out_proj.weight.shape[0] ** -0.5
+ init.normal_(module.out_proj.weight, mean=0.0, std=std * scale)
+ # We initialize with 0s to be 1 centered as the RMSNorm here does (1 + weight)
+ elif "RMSNorm" in module.__class__.__name__:
+ init.zeros_(module.weight)
+
+ def _shift_right(self, input_ids):
+ """
+ Shifts input_ids to the right, prepends the decoder_start_token_id, and handles
+ pad_token_id replacement for labels that were -100.
+ This is a common preparation step for decoder inputs in sequence-to-sequence models.
+ """
+ decoder_start_token_id = self.config.decoder.bos_token_id
+ pad_token_id = self.config.decoder.pad_token_id
+
+ if decoder_start_token_id is None:
+ raise ValueError("self.model.config.decoder.bos_token_id has to be defined. ")
+
+ # shift inputs to the right
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
+ shifted_input_ids[..., 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.decoder.pad_token_id has to be defined.")
+
+ # Is this T5 specific?
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+def make_default_2d_attention_mask(
+ token_ids: torch.LongTensor | None,
+ hidden_states: torch.Tensor,
+ pad_token_id: int | None,
+) -> torch.Tensor:
+ """Construct the default attention mask."""
+ if token_ids is not None:
+ if pad_token_id is None:
+ raise ValueError("`pad_token_id` is required for padding information.")
+ attention_mask = (token_ids != pad_token_id).to(hidden_states.device, torch.long)
+ else:
+ attention_mask = torch.ones(
+ (hidden_states.shape[0], hidden_states.shape[1]), device=hidden_states.device, dtype=torch.long
+ )
+ return attention_mask
+
+
+class T5GemmaEncoder(T5GemmaPreTrainedModel):
+ _can_record_outputs = {
+ "attentions": T5GemmaSelfAttention,
+ "hidden_states": T5GemmaEncoderLayer,
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+ self.norm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.gradient_checkpointing = False
+
+ self.layers = nn.ModuleList(
+ [T5GemmaEncoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.rotary_emb = T5GemmaRotaryEmbedding(config=config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutput:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ # As we want to pass `past_key_values=None` explicitly everywhere, we need to pop them from kwargs if present
+ kwargs.pop("past_key_values", None)
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if position_ids is None:
+ position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device)
+ position_ids = position_ids.unsqueeze(0)
+
+ if attention_mask is None:
+ attention_mask = make_default_2d_attention_mask(input_ids, inputs_embeds, self.config.pad_token_id)
+
+ if not isinstance(self_attn_mask_mapping := attention_mask, dict):
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ }
+ self_attn_mask_mapping = {
+ "full_attention": create_bidirectional_mask(**mask_kwargs),
+ "sliding_attention": create_bidirectional_sliding_window_mask(**mask_kwargs),
+ }
+
+ hidden_states = inputs_embeds
+ normalizer = torch.tensor(self.config.hidden_size**0.5, dtype=hidden_states.dtype)
+ hidden_states = hidden_states * normalizer
+ hidden_states = self.dropout(hidden_states)
+
+ position_embeddings = self.rotary_emb(hidden_states, position_ids)
+
+ for i, layer_module in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = layer_module(
+ hidden_states,
+ position_embeddings,
+ self_attn_mask_mapping[self.config.layer_types[i]],
+ position_ids,
+ **kwargs,
+ )
+ hidden_states = self.norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ )
+
+
+class T5GemmaDecoder(T5GemmaPreTrainedModel):
+ _can_record_outputs = {
+ "attentions": OutputRecorder(T5GemmaSelfAttention, index=1),
+ "cross_attentions": OutputRecorder(T5GemmaCrossAttention, index=1),
+ "hidden_states": T5GemmaDecoderLayer,
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+ self.norm = T5GemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.gradient_checkpointing = False
+
+ self.layers = nn.ModuleList(
+ [T5GemmaDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.rotary_emb = T5GemmaRotaryEmbedding(config=config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPastAndCrossAttentions:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+ if encoder_hidden_states is None:
+ raise ValueError("`encoder_hidden_states` must be given in decoder")
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if not self.training and use_cache and past_key_values is None:
+ # We do not pass the config to the cross attn cache to avoid initializing SWA
+ # --> we use full attention between our cross attentions
+ past_key_values = EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache())
+
+ if position_ids is None:
+ past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+ position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens
+ position_ids = position_ids.unsqueeze(0)
+
+ if attention_mask is None and past_key_values is None:
+ attention_mask = make_default_2d_attention_mask(input_ids, inputs_embeds, self.config.pad_token_id)
+
+ if not isinstance(self_attn_mask_mapping := attention_mask, dict):
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ "past_key_values": past_key_values.self_attention_cache if past_key_values is not None else None,
+ "position_ids": position_ids,
+ }
+ self_attn_mask_mapping = {
+ "full_attention": create_causal_mask(**mask_kwargs),
+ "sliding_attention": create_sliding_window_causal_mask(**mask_kwargs),
+ }
+
+ if not isinstance(cross_attn_mask_mapping := encoder_attention_mask, dict):
+ cross_attn_mask_mapping = {
+ "full_attention": create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+ }
+
+ hidden_states = inputs_embeds
+ normalizer = torch.tensor(self.config.hidden_size**0.5, dtype=hidden_states.dtype)
+ hidden_states = hidden_states * normalizer
+ hidden_states = self.dropout(hidden_states)
+
+ position_embeddings = self.rotary_emb(hidden_states, position_ids)
+
+ for i, layer_module in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = layer_module(
+ hidden_states,
+ position_embeddings,
+ self_attn_mask_mapping[self.config.layer_types[i]],
+ position_ids,
+ past_key_values,
+ use_cache,
+ encoder_hidden_states,
+ cross_attn_mask_mapping["full_attention"],
+ **kwargs,
+ )
+ hidden_states = self.norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class T5GemmaModel(T5GemmaPreTrainedModel):
+ def __init__(self, config: T5GemmaConfig):
+ super().__init__(config)
+
+ if not config.is_encoder_decoder:
+ raise ValueError("T5GemmaModel only support encoder-decoder modeling. Use `T5GemmaEncoderModel` instead.")
+
+ self.encoder = T5GemmaEncoder(config.encoder)
+ self.decoder = T5GemmaDecoder(config.decoder)
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.encoder.get_input_embeddings()
+
+ def set_input_embeddings(self, new_embeddings):
+ return self.encoder.set_input_embeddings(new_embeddings)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ decoder_inputs_embeds: torch.Tensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> Seq2SeqModelOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ """
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ **kwargs,
+ )
+
+ encoder_hidden_states = encoder_outputs.last_hidden_state
+
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ position_ids=decoder_position_ids,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return Seq2SeqModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states
+ if kwargs.get("output_hidden_states", False)
+ else (decoder_outputs.last_hidden_state,),
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring
+class T5GemmaEncoderModel(T5GemmaPreTrainedModel):
+ def __init__(self, config: T5GemmaConfig):
+ super().__init__(config)
+
+ if config.is_encoder_decoder:
+ raise ValueError("T5GemmaEncoderModel only supports encoder-only model. Use `T5GemmaModel` instead.")
+
+ self.encoder = T5GemmaEncoder(config.encoder)
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.encoder.get_input_embeddings()
+
+ def set_input_embeddings(self, new_embeddings):
+ return self.encoder.set_input_embeddings(new_embeddings)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ **kwargs,
+ )
+ return encoder_outputs
+
+
+class T5GemmaForConditionalGeneration(T5GemmaPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"lm_head.out_proj.weight": "model.decoder.embed_tokens.weight"}
+ _tp_plan = {"lm_head.out_proj": "colwise_gather_output"}
+ _pp_plan = {"lm_head.out_proj": (["hidden_states"], ["logits"])}
+
+ def __init__(self, config: T5GemmaConfig):
+ config.is_encoder_decoder = True
+ super().__init__(config)
+
+ self.model = T5GemmaModel(config)
+ self.vocab_size = config.decoder.vocab_size
+ self.lm_head = T5GemmaLMHead(config.decoder.hidden_size, self.vocab_size)
+ self.loss_type = "ForMaskedLM"
+
+ self.post_init()
+
+ def set_output_embeddings(self, new_embeddings):
+ self.lm_head.out_proj = new_embeddings
+ # The tying happens from decoder to lm-head, but when resizing
+ # the resized embed is assigned only to the head. Then tying weights
+ # again reverts everything back. So we have to update decoder here
+ if self.config.tie_word_embeddings:
+ self.model.decoder.embed_tokens.weight = new_embeddings.weight
+ self.model.decoder.embed_tokens.num_embeddings = new_embeddings.weight.shape[0]
+
+ def get_output_embeddings(self):
+ return self.lm_head.out_proj
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ logits_to_keep: int | torch.Tensor = 0,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqLMOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+ """
+
+ if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
+ # get decoder inputs from shifting lm labels to the right
+ decoder_input_ids = self._shift_right(labels)
+
+ decoder_outputs: Seq2SeqModelOutput = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = decoder_outputs.last_hidden_state
+ # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+ slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+ logits = self.lm_head(hidden_states[:, slice_indices, :])
+ decoder_config = self.get_decoder().config
+ if decoder_config.final_logit_softcapping is not None:
+ logits = logits / decoder_config.final_logit_softcapping
+ logits = torch.tanh(logits)
+ logits = logits * decoder_config.final_logit_softcapping
+
+ loss = None
+ if labels is not None:
+ # Input has right-shifted so we directly perform masked lm loss
+ loss = self.loss_function(logits, labels, self.vocab_size, **kwargs)
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.decoder_hidden_states,
+ decoder_attentions=decoder_outputs.decoder_attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=decoder_outputs.encoder_last_hidden_state,
+ encoder_hidden_states=decoder_outputs.encoder_hidden_states,
+ encoder_attentions=decoder_outputs.encoder_attentions,
+ )
+
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+ return self._shift_right(labels)
+
+
+@auto_docstring
+class T5GemmaForSequenceClassification(T5GemmaPreTrainedModel):
+ def __init__(self, config: T5GemmaConfig, is_encoder_decoder: bool | None = None):
+ r"""
+ is_encoder_decoder (`Optional`, *optional*):
+ Whether use encoder_decoder for sequence classification. When set to False, only encoder is used.
+ """
+ if is_encoder_decoder is not None:
+ config.is_encoder_decoder = is_encoder_decoder
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ if config.is_encoder_decoder:
+ self.model = T5GemmaModel(config)
+ else:
+ self.model = T5GemmaEncoderModel(config)
+
+ hidden_size = config.encoder.hidden_size
+ if config.is_encoder_decoder:
+ hidden_size = config.decoder.hidden_size
+
+ classifier_dropout = getattr(config, "classifier_dropout_rate", 0.1)
+ self.score = T5GemmaClassificationHead(hidden_size, self.num_labels, classifier_dropout)
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.Tensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SequenceClassifierOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ if self.config.is_encoder_decoder and (input_ids is None and inputs_embeds is not None):
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__} in encoder-decoder mode."
+ )
+
+ # Following T5, we automatically creates decoder_input_ids from input_ids if no decoder_input_ids are provided
+ if self.config.is_encoder_decoder and (decoder_input_ids is None and decoder_inputs_embeds is None):
+ if input_ids is None:
+ raise ValueError(
+ "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+ "passed, `input_ids` cannot be `None`. Please pass either "
+ "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+ )
+ decoder_input_ids = self._shift_right(input_ids)
+
+ if self.config.is_encoder_decoder:
+ outputs: Seq2SeqModelOutput = self.model(
+ input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=False,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.decoder_hidden_states
+ attentions = outputs.decoder_attentions
+ else:
+ outputs: BaseModelOutput = self.model(
+ input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.hidden_states
+ attentions = outputs.attentions
+
+ logits = self.score(last_hidden_state)
+
+ if input_ids is not None:
+ batch_size = input_ids.shape[0]
+ else:
+ batch_size = inputs_embeds.shape[0]
+
+ if self.config.pad_token_id is None and batch_size != 1:
+ raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
+ if self.config.pad_token_id is None:
+ last_non_pad_token = -1
+ elif input_ids is not None:
+ # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
+ non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
+ token_indices = torch.arange(input_ids.shape[-1], device=logits.device, dtype=torch.int32)
+ last_non_pad_token = (token_indices * non_pad_mask).argmax(-1)
+
+ if self.config.is_encoder_decoder:
+ last_non_pad_token += 1 # due to the right shift.
+ last_non_pad_token = torch.clamp(last_non_pad_token, max=decoder_input_ids.shape[-1] - 1)
+ else:
+ last_non_pad_token = -1
+ logger.warning_once(
+ f"{self.__class__.__name__} will not detect padding tokens in `inputs_embeds`. Results may be "
+ "unexpected if using padding tokens in conjunction with `inputs_embeds.`"
+ )
+
+ pooled_logits = logits[torch.arange(batch_size, device=logits.device), last_non_pad_token]
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits=logits, labels=labels, pooled_logits=pooled_logits, config=self.config)
+
+ return SequenceClassifierOutput(
+ loss=loss,
+ logits=pooled_logits,
+ hidden_states=hidden_states,
+ attentions=attentions,
+ )
+
+
+@auto_docstring
+class T5GemmaForTokenClassification(T5GemmaPreTrainedModel):
+ def __init__(self, config: T5GemmaConfig, is_encoder_decoder: bool | None = None):
+ r"""
+ is_encoder_decoder (`Optional`, *optional*):
+ Whether use encoder_decoder for token classification. When set to False, only encoder is used.
+ """
+ if is_encoder_decoder is not None:
+ config.is_encoder_decoder = is_encoder_decoder
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ if config.is_encoder_decoder:
+ self.model = T5GemmaModel(config)
+ else:
+ self.model = T5GemmaEncoderModel(config)
+
+ hidden_size = config.encoder.hidden_size
+ if config.is_encoder_decoder:
+ hidden_size = config.decoder.hidden_size
+
+ classifier_dropout = getattr(config, "classifier_dropout_rate", 0.1)
+ self.score = T5GemmaClassificationHead(hidden_size, self.num_labels, classifier_dropout)
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.Tensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TokenClassifierOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+
+ if self.config.is_encoder_decoder and (input_ids is None and inputs_embeds is not None):
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__} in encoder-decoder mode."
+ )
+
+ if self.config.is_encoder_decoder and (decoder_input_ids is None and decoder_inputs_embeds is None):
+ if input_ids is None:
+ raise ValueError(
+ "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+ "passed, `input_ids` cannot be `None`. Please pass either "
+ "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+ )
+ decoder_input_ids = self._shift_right(input_ids)
+
+ if self.config.is_encoder_decoder:
+ outputs: Seq2SeqModelOutput = self.model(
+ input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=False,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.decoder_hidden_states
+ attentions = outputs.decoder_attentions
+ else:
+ outputs: BaseModelOutput = self.model(
+ input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.hidden_states
+ attentions = outputs.attentions
+
+ logits = self.score(last_hidden_state)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits, labels, self.config)
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=hidden_states,
+ attentions=attentions,
+ )
+
+
+__all__ = [
+ "T5GemmaConfig",
+ "T5GemmaModuleConfig",
+ "T5GemmaForConditionalGeneration",
+ "T5GemmaModel",
+ "T5GemmaEncoderModel",
+ "T5GemmaPreTrainedModel",
+ "T5GemmaForSequenceClassification",
+ "T5GemmaForTokenClassification",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma2/__init__.py b/lib/python3.11/site-packages/transformers/models/t5gemma2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d018bfe722ab8bfbda0c38f681159d0182b6672
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5gemma2/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_t5gemma2 import *
+ from .modeling_t5gemma2 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..48f702043985d3066b2e4eb838ede776f55ed714
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/configuration_t5gemma2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/configuration_t5gemma2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..242a0c18f452aead4ec20ff19176b6fe34a0e39d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/configuration_t5gemma2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/modeling_t5gemma2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/modeling_t5gemma2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..581c65ef114428cdfc22fdb290a48e94645aa477
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/modeling_t5gemma2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/modular_t5gemma2.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/modular_t5gemma2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..036bff65f8f5c8298142311ec04f04157e5d754a
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/t5gemma2/__pycache__/modular_t5gemma2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma2/configuration_t5gemma2.py b/lib/python3.11/site-packages/transformers/models/t5gemma2/configuration_t5gemma2.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9a9a3f5769f8114ca7211089bad7315cea00e3b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5gemma2/configuration_t5gemma2.py
@@ -0,0 +1,403 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/t5gemma2/modular_t5gemma2.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_t5gemma2.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 Google Inc. HuggingFace Inc. 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 Any
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring, logging
+from ..siglip import SiglipVisionConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="google/t5gemma-2-270m-270m")
+@strict
+class T5Gemma2TextConfig(PreTrainedConfig):
+ r"""
+ query_pre_attn_scalar (`float`, *optional*, defaults to 256):
+ Scaling factor used on the attention scores
+ final_logit_softcapping (`float`, *optional*):
+ Scaling factor when applying tanh softcapping on the logits.
+ attn_logit_softcapping (`float`, *optional*):
+ Scaling factor when applying tanh softcapping on the attention scores.
+ """
+
+ model_type = "t5gemma2_text"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ base_model_tp_plan = {
+ "layers.*.self_attn.q_proj": "colwise",
+ "layers.*.self_attn.k_proj": "colwise",
+ "layers.*.self_attn.v_proj": "colwise",
+ "layers.*.self_attn.q_norm": "replicated_with_grad_allreduce",
+ "layers.*.self_attn.k_norm": "replicated_with_grad_allreduce",
+ "layers.*.self_attn.o_proj": "rowwise",
+ "layers.*.mlp.gate_proj": "colwise",
+ "layers.*.mlp.up_proj": "colwise",
+ "layers.*.mlp.down_proj": "rowwise",
+ }
+ base_model_pp_plan = {
+ "embed_tokens": (["input_ids"], ["inputs_embeds"]),
+ "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
+ "norm": (["hidden_states"], ["hidden_states"]),
+ }
+
+ vocab_size: int = 262_208
+ hidden_size: int = 2304
+ intermediate_size: int = 9216
+ num_hidden_layers: int = 26
+ num_attention_heads: int = 8
+ num_key_value_heads: int = 4
+ head_dim: int = 256
+ hidden_activation: str = "gelu_pytorch_tanh"
+ max_position_embeddings: int = 131_072
+ initializer_range: float = 0.02
+ rms_norm_eps: float = 1e-6
+ use_cache: bool = True
+ pad_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 1
+ bos_token_id: int | None = 2
+ tie_word_embeddings: bool = True
+ rope_parameters: dict | None = None
+ attention_bias: bool = False
+ attention_dropout: int | float | None = 0.0
+ query_pre_attn_scalar: int = 256
+ sliding_window: int | None = 4096
+ layer_types: list[str] | None = None
+ final_logit_softcapping: float | None = None
+ attn_logit_softcapping: float | None = None
+ default_theta = {"global": 1_000_000.0, "local": 10_000.0}
+
+ def __post_init__(self, **kwargs):
+ # BC -> the pattern used to be a simple int, and it's still present in configs on the Hub
+ _sliding_window_pattern = kwargs.pop("sliding_window_pattern", 6)
+ if self.layer_types is None:
+ self.layer_types = [
+ "sliding_attention" if bool((i + 1) % _sliding_window_pattern) else "full_attention"
+ for i in range(self.num_hidden_layers)
+ ]
+
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if self.hidden_size % self.num_attention_heads != 0:
+ raise ValueError(
+ f"The hidden size ({self.hidden_size}) is not a multiple of the number of attention "
+ f"heads ({self.num_attention_heads})."
+ )
+
+ def convert_rope_params_to_dict(self, **kwargs):
+ rope_scaling = kwargs.pop("rope_scaling", None)
+
+ # Try to set `rope_scaling` if available, otherwise use `rope_parameters`. If we find `rope_parameters`
+ # as arg in the inputs, we can safely assume that it is in the new format. New naming used -> new format
+ default_rope_params = {
+ "sliding_attention": {"rope_type": "default"},
+ "full_attention": {"rope_type": "default"},
+ }
+ self.rope_parameters = self.rope_parameters if self.rope_parameters is not None else default_rope_params
+ if rope_scaling is not None:
+ self.rope_parameters["full_attention"].update(rope_scaling)
+
+ # Set default values if not present
+ if self.rope_parameters.get("full_attention") is None:
+ self.rope_parameters["full_attention"] = {"rope_type": "default"}
+ self.rope_parameters["full_attention"].setdefault(
+ "rope_theta", kwargs.pop("rope_theta", self.default_theta["global"])
+ )
+ if self.rope_parameters.get("sliding_attention") is None:
+ self.rope_parameters["sliding_attention"] = {"rope_type": "default"}
+ self.rope_parameters["sliding_attention"].setdefault(
+ "rope_theta", kwargs.pop("rope_local_base_freq", self.default_theta["local"])
+ )
+
+ # Standardize and validate the correctness of rotary position embeddings parameters
+ self.standardize_rope_params()
+ return kwargs
+
+
+@auto_docstring(checkpoint="google/t5gemma-2-270m-270m")
+@strict
+class T5Gemma2EncoderConfig(PreTrainedConfig):
+ r"""
+ mm_tokens_per_image (`int`, *optional*, defaults to 256):
+ The number of tokens per image embedding.
+ boi_token_index (`int`, *optional*, defaults to 255999):
+ The begin-of-image token index to wrap the image prompt.
+ eoi_token_index (`int`, *optional*, defaults to 256000):
+ The end-of-image token index to wrap the image prompt.
+
+ Example:
+
+ ```python
+ >>> from transformers import T5Gemma2EncoderForConditionalGeneration, T5Gemma2EncoderConfig, SiglipVisionConfig, T5Gemma2EncoderTextConfig
+
+ >>> # Initializing a Siglip-like vision config
+ >>> vision_config = SiglipVisionConfig()
+
+ >>> # Initializing a T5Gemma2Encoder Text config
+ >>> text_config = T5Gemma2EncoderTextConfig()
+
+ >>> # Initializing a T5Gemma2Encoder gemma-3-4b style configuration
+ >>> configuration = T5Gemma2EncoderConfig(vision_config, text_config)
+
+ >>> # Initializing a model from the gemma-3-4b style configuration
+ >>> model = T5Gemma2EncoderTextConfig(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "t5gemma2_encoder"
+ attribute_map = {
+ "image_token_id": "image_token_index",
+ "boi_token_id": "boi_token_index",
+ "eoi_token_id": "eoi_token_index",
+ }
+
+ sub_configs = {
+ "text_config": T5Gemma2TextConfig,
+ "vision_config": SiglipVisionConfig,
+ }
+
+ text_config: T5Gemma2TextConfig | dict[str, Any] | None = None
+ vision_config: SiglipVisionConfig | dict[str, Any] | None = None
+ mm_tokens_per_image: int | None = 256
+ boi_token_index: int | None = 255_999
+ eoi_token_index: int | None = 256_000
+ image_token_index: int | None = 262_144
+ initializer_range: float | None = 0.02
+ tie_word_embeddings: bool | None = True
+
+ def __post_init__(self, **kwargs):
+ if self.text_config is None:
+ self.text_config = T5Gemma2TextConfig()
+ logger.info("text_config is None, using default T5Gemma2EncoderTextConfig text config.")
+ elif isinstance(self.text_config, dict):
+ self.text_config = T5Gemma2TextConfig(**self.text_config)
+
+ if isinstance(self.vision_config, dict):
+ self.vision_config = SiglipVisionConfig(**self.vision_config)
+ elif self.vision_config is None:
+ self.vision_config = SiglipVisionConfig()
+ logger.info("vision_config is None, using default SiglipVisionConfig vision config.")
+
+ super().__post_init__(**kwargs)
+
+
+@auto_docstring(checkpoint="google/t5gemma-2-270m-270m")
+@strict
+class T5Gemma2DecoderConfig(PreTrainedConfig):
+ r"""
+ query_pre_attn_scalar (`float`, *optional*, defaults to 256):
+ Scaling factor used on the attention scores
+ final_logit_softcapping (`float`, *optional*):
+ Scaling factor when applying tanh softcapping on the logits.
+ attn_logit_softcapping (`float`, *optional*):
+ Scaling factor when applying tanh softcapping on the attention scores.
+ """
+
+ model_type = "t5gemma2_decoder"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ base_model_tp_plan = {
+ "layers.*.self_attn.q_proj": "colwise",
+ "layers.*.self_attn.k_proj": "colwise",
+ "layers.*.self_attn.v_proj": "colwise",
+ "layers.*.self_attn.q_norm": "replicated_with_grad_allreduce",
+ "layers.*.self_attn.k_norm": "replicated_with_grad_allreduce",
+ "layers.*.self_attn.o_proj": "rowwise",
+ "layers.*.mlp.gate_proj": "colwise",
+ "layers.*.mlp.up_proj": "colwise",
+ "layers.*.mlp.down_proj": "rowwise",
+ }
+ base_model_pp_plan = {
+ "embed_tokens": (["input_ids"], ["inputs_embeds"]),
+ "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
+ "norm": (["hidden_states"], ["hidden_states"]),
+ }
+
+ vocab_size: int = 262_208
+ hidden_size: int = 2304
+ intermediate_size: int = 9216
+ num_hidden_layers: int = 26
+ num_attention_heads: int = 8
+ num_key_value_heads: int = 4
+ head_dim: int = 256
+ hidden_activation: str = "gelu_pytorch_tanh"
+ max_position_embeddings: int = 131_072
+ initializer_range: float = 0.02
+ rms_norm_eps: float = 1e-6
+ use_cache: bool = True
+ pad_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 1
+ bos_token_id: int | None = 2
+ tie_word_embeddings: bool = True
+ rope_parameters: dict | None = None
+ attention_bias: bool = False
+ attention_dropout: int | float | None = 0.0
+ query_pre_attn_scalar: int = 256
+ sliding_window: int | None = 4096
+ layer_types: list[str] | None = None
+ final_logit_softcapping: float | None = None
+ attn_logit_softcapping: float | None = None
+ default_theta = {"global": 1_000_000.0, "local": 10_000.0}
+
+ def __post_init__(self, **kwargs):
+ # BC -> the pattern used to be a simple int, and it's still present in configs on the Hub
+ _sliding_window_pattern = kwargs.pop("sliding_window_pattern", 6)
+ if self.layer_types is None:
+ self.layer_types = [
+ "sliding_attention" if bool((i + 1) % _sliding_window_pattern) else "full_attention"
+ for i in range(self.num_hidden_layers)
+ ]
+
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if self.hidden_size % self.num_attention_heads != 0:
+ raise ValueError(
+ f"The hidden size ({self.hidden_size}) is not a multiple of the number of attention "
+ f"heads ({self.num_attention_heads})."
+ )
+
+ def convert_rope_params_to_dict(self, **kwargs):
+ rope_scaling = kwargs.pop("rope_scaling", None)
+
+ # Try to set `rope_scaling` if available, otherwise use `rope_parameters`. If we find `rope_parameters`
+ # as arg in the inputs, we can safely assume that it is in the new format. New naming used -> new format
+ default_rope_params = {
+ "sliding_attention": {"rope_type": "default"},
+ "full_attention": {"rope_type": "default"},
+ }
+ self.rope_parameters = self.rope_parameters if self.rope_parameters is not None else default_rope_params
+ if rope_scaling is not None:
+ self.rope_parameters["full_attention"].update(rope_scaling)
+
+ # Set default values if not present
+ if self.rope_parameters.get("full_attention") is None:
+ self.rope_parameters["full_attention"] = {"rope_type": "default"}
+ self.rope_parameters["full_attention"].setdefault(
+ "rope_theta", kwargs.pop("rope_theta", self.default_theta["global"])
+ )
+ if self.rope_parameters.get("sliding_attention") is None:
+ self.rope_parameters["sliding_attention"] = {"rope_type": "default"}
+ self.rope_parameters["sliding_attention"].setdefault(
+ "rope_theta", kwargs.pop("rope_local_base_freq", self.default_theta["local"])
+ )
+
+ # Standardize and validate the correctness of rotary position embeddings parameters
+ self.standardize_rope_params()
+ return kwargs
+
+
+@auto_docstring(checkpoint="google/t5gemma-2-270m-270m")
+@strict
+class T5Gemma2Config(PreTrainedConfig):
+ r"""
+ encoder (`Union[T5Gemma2EncoderConfig, dict]`, optional, *optional*):
+ Configuration for the encoder.
+ decoder (`Union[T5Gemma2DecoderConfig, dict]`, optional, *optional*):
+ Configuration for the decoder.
+ eoi_token_index (`int`, *optional*):
+ The end-of-image token index to wrap the image prompt. Will be same as
+ `self.encoder.eoi_token_index`
+
+ ```python
+ >>> from transformers import T5Gemma2Config, T5Gemma2Model
+ >>> t5gemma2_config = T5Gemma2Config.from_pretrained("google/t5gemma-270m-270m")
+ >>> model = T5Gemma2Model(t5gemma2_config)
+ ```
+ """
+
+ model_type = "t5gemma2"
+ keys_to_ignore_at_inference = ["past_key_values"]
+
+ sub_configs = {
+ "encoder": T5Gemma2EncoderConfig,
+ "decoder": T5Gemma2DecoderConfig,
+ }
+
+ attribute_map = {
+ "image_token_id": "image_token_index",
+ "eoi_token_id": "eoi_token_index",
+ }
+
+ encoder: T5Gemma2EncoderConfig | dict[str, Any] | None = None
+ decoder: T5Gemma2DecoderConfig | dict[str, Any] | None = None
+ is_encoder_decoder: bool = True
+ dropout_rate: float | int = 0.0
+ attention_dropout: float | int = 0.0
+ classifier_dropout_rate: float | int = 0.0
+ initializer_range: float = 0.02
+ image_token_index: int = 256_001
+ eoi_token_index: int | None = None
+ tie_word_embeddings: bool = True
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.encoder, dict):
+ self.encoder = T5Gemma2EncoderConfig(**self.encoder)
+ elif self.encoder is None:
+ self.encoder = T5Gemma2EncoderConfig()
+ logger.info("encoder is None, using default T5Gemma2EncoderConfig encoder config.")
+
+ if isinstance(self.decoder, dict):
+ self.decoder = T5Gemma2DecoderConfig(**self.decoder)
+ elif self.decoder is None:
+ self.decoder = T5Gemma2DecoderConfig()
+ logger.info("decoder is None, using default T5Gemma2DecoderConfig decoder config.")
+
+ self.encoder.text_config.dropout_rate = self.dropout_rate
+ self.encoder.text_config.attention_dropout = self.attention_dropout
+ self.encoder.vision_config.attention_dropout = self.attention_dropout
+ self.encoder.image_token_index = self.image_token_index
+
+ self.decoder.dropout_rate = self.dropout_rate
+ self.decoder.attention_dropout = self.attention_dropout
+ self.eoi_token_index = self.encoder.eoi_token_index
+
+ for special_token_key in ["bos_token_id", "pad_token_id", "eos_token_id", "vocab_size"]:
+ if special_token_key not in kwargs:
+ kwargs[special_token_key] = getattr(self.decoder, special_token_key)
+
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if self.encoder.text_config.hidden_size != self.decoder.hidden_size:
+ raise ValueError(
+ "Imbalanced encoder-decoder is not supported in T5Gemma2: "
+ f"encoder ({self.encoder.text_config.hidden_size}) vs decoder ({self.decoder.hidden_size})."
+ )
+
+ if not self.is_encoder_decoder:
+ raise ValueError("T5Gemma2Model only support encoder-decoder modeling.")
+
+ if self.encoder.text_config.vocab_size != self.decoder.vocab_size:
+ raise ValueError(
+ "Imbalanced encoder-decoder vocabulary size is not supported in T5Gemma2: "
+ f"encoder ({self.encoder.text_config.vocab_size}) vs decoder ({self.decoder.vocab_size})."
+ )
+
+
+__all__ = ["T5Gemma2Config", "T5Gemma2TextConfig", "T5Gemma2EncoderConfig", "T5Gemma2DecoderConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma2/modeling_t5gemma2.py b/lib/python3.11/site-packages/transformers/models/t5gemma2/modeling_t5gemma2.py
new file mode 100644
index 0000000000000000000000000000000000000000..15de07406bfbfca0c891e5257af4c49e2f0cff57
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5gemma2/modeling_t5gemma2.py
@@ -0,0 +1,1579 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/t5gemma2/modular_t5gemma2.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_t5gemma2.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 Google Inc. HuggingFace Inc. 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 copy
+from collections.abc import Callable
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache, StaticCache
+from ...generation import GenerationConfig, GenerationMixin, GenerationMode
+from ...integrations import use_kernel_func_from_hub, use_kernelized_func
+from ...masking_utils import create_bidirectional_mask, create_causal_mask, create_sliding_window_causal_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ BaseModelOutputWithPastAndCrossAttentions,
+ BaseModelOutputWithPooling,
+ Seq2SeqLMOutput,
+ Seq2SeqModelOutput,
+ SequenceClassifierOutput,
+ TokenClassifierOutput,
+)
+from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, torch_compilable_check
+from ...utils.generic import maybe_autocast, merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from ..auto import AutoModel
+from .configuration_t5gemma2 import T5Gemma2Config, T5Gemma2DecoderConfig, T5Gemma2EncoderConfig, T5Gemma2TextConfig
+
+
+class T5Gemma2RMSNorm(nn.Module):
+ def __init__(self, dim: int, eps: float = 1e-6):
+ super().__init__()
+ self.eps = eps
+ self.weight = nn.Parameter(torch.zeros(dim))
+
+ def _norm(self, x):
+ return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+ def forward(self, x):
+ output = self._norm(x.float())
+ # Llama does x.to(float16) * w whilst T5Gemma2 is (x * w).to(float16)
+ # See https://github.com/huggingface/transformers/pull/29402
+ output = output * (1.0 + self.weight.float())
+ return output.type_as(x)
+
+ def extra_repr(self):
+ return f"{tuple(self.weight.shape)}, eps={self.eps}"
+
+
+class T5Gemma2MLP(nn.Module):
+ def __init__(self, config: T5Gemma2TextConfig):
+ super().__init__()
+ self.config = config
+ self.hidden_size = config.hidden_size
+ self.intermediate_size = config.intermediate_size
+ self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+ self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+ self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
+ self.act_fn = ACT2FN[config.hidden_activation]
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(self, x):
+ hidden_states = self.act_fn(self.gate_proj(x)) * self.up_proj(x)
+ hidden_states = self.dropout(hidden_states)
+ down_proj = self.down_proj(hidden_states)
+ return down_proj
+
+
+class T5Gemma2RotaryEmbedding(nn.Module):
+ inv_freq: torch.Tensor # fix linting for `register_buffer`
+
+ def __init__(self, config: T5Gemma2TextConfig, device=None):
+ super().__init__()
+ self.max_seq_len_cached = config.max_position_embeddings
+ self.original_max_seq_len = config.max_position_embeddings
+ self.config = config
+ self.layer_types = list(set(config.layer_types))
+ self.rope_type = {}
+ for layer_type in self.layer_types:
+ rope_params = self.config.rope_parameters[layer_type]
+ if rope_params is None:
+ continue
+
+ self.rope_type[layer_type] = rope_params["rope_type"]
+ rope_init_fn: Callable = self.compute_default_rope_parameters
+ if self.rope_type[layer_type] != "default":
+ rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type[layer_type]]
+ curr_inv_freq, curr_attention_scaling = rope_init_fn(self.config, layer_type=layer_type)
+ self.register_buffer(f"{layer_type}_inv_freq", curr_inv_freq, persistent=False)
+ self.register_buffer(f"{layer_type}_original_inv_freq", curr_inv_freq.clone(), persistent=False)
+ setattr(self, f"{layer_type}_attention_scaling", curr_attention_scaling)
+
+ @staticmethod
+ def compute_default_rope_parameters(
+ config: T5Gemma2TextConfig | None = None,
+ device: Optional["torch.device"] = None,
+ seq_len: int | None = None,
+ layer_type: str | None = None,
+ ) -> tuple["torch.Tensor", float]:
+ """
+ Computes the inverse frequencies according to the original RoPE implementation
+ Args:
+ config ([`~transformers.PreTrainedConfig`]):
+ The model configuration.
+ device (`torch.device`):
+ The device to use for initialization of the inverse frequencies.
+ seq_len (`int`, *optional*):
+ The current sequence length. Unused for this type of RoPE.
+ layer_type (`str`, *optional*):
+ The current layer type if the model has different RoPE parameters per type.
+ Should not be used unless `config.layer_types is not None`
+
+ Returns:
+ Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
+ post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
+ """
+ # For backward compatibility standardize the `rope_parameters_dict` if it uses old format
+ base = config.rope_parameters[layer_type]["rope_theta"]
+ dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
+
+ attention_factor = 1.0 # Unused in this type of RoPE
+
+ # Compute the inverse frequencies
+ inv_freq = 1.0 / (
+ base ** (torch.arange(0, dim, 2, dtype=torch.int64).to(device=device, dtype=torch.float) / dim)
+ )
+ return inv_freq, attention_factor
+
+ @torch.no_grad()
+ @dynamic_rope_update # power user: used with advanced RoPE types (e.g. dynamic rope)
+ def forward(self, x, position_ids, layer_type=None):
+ inv_freq = getattr(self, f"{layer_type}_inv_freq")
+ attention_scaling = getattr(self, f"{layer_type}_attention_scaling")
+
+ inv_freq_expanded = inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)
+ position_ids_expanded = position_ids[:, None, :].float()
+
+ device_type = x.device.type if isinstance(x.device.type, str) and x.device.type != "mps" else "cpu"
+ with maybe_autocast(device_type=device_type, enabled=False): # Force float32
+ freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2)
+ emb = torch.cat((freqs, freqs), dim=-1)
+ cos = emb.cos() * attention_scaling
+ sin = emb.sin() * attention_scaling
+
+ return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+def rotate_half(x):
+ """Rotates half the hidden dims of the input."""
+ x1 = x[..., : x.shape[-1] // 2]
+ x2 = x[..., x.shape[-1] // 2 :]
+ return torch.cat((-x2, x1), dim=-1)
+
+
+@use_kernel_func_from_hub("rotary_pos_emb")
+def apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1):
+ """Applies Rotary Position Embedding to the query and key tensors.
+
+ Args:
+ q (`torch.Tensor`): The query tensor.
+ k (`torch.Tensor`): The key tensor.
+ cos (`torch.Tensor`): The cosine part of the rotary embedding.
+ sin (`torch.Tensor`): The sine part of the rotary embedding.
+ unsqueeze_dim (`int`, *optional*, defaults to 1):
+ The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+ sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+ that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+ k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+ cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+ the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+ Returns:
+ `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+ """
+ cos = cos.unsqueeze(unsqueeze_dim)
+ sin = sin.unsqueeze(unsqueeze_dim)
+ q_embed = (q * cos) + (rotate_half(q) * sin)
+ k_embed = (k * cos) + (rotate_half(k) * sin)
+ return q_embed, k_embed
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+ """
+ This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+ num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+ """
+ batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+ if n_rep == 1:
+ return hidden_states
+ hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+ return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ dropout: float | int = 0.0,
+ scaling: float | None = None,
+ softcap: float | None = None,
+ **kwargs,
+) -> tuple[torch.Tensor, torch.Tensor]:
+ if scaling is None:
+ scaling = module.head_dim**-0.5
+
+ key_states = repeat_kv(key, module.num_key_value_groups)
+ value_states = repeat_kv(value, module.num_key_value_groups)
+
+ attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
+
+ if softcap is not None:
+ attn_weights = attn_weights / softcap
+ attn_weights = torch.tanh(attn_weights)
+ attn_weights = attn_weights * softcap
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ # upcast attention to fp32
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value_states)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ return attn_output, attn_weights
+
+
+@use_kernelized_func(apply_rotary_pos_emb)
+class T5Gemma2SelfAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config: T5Gemma2TextConfig, layer_idx: int):
+ super().__init__()
+ self.layer_type = config.layer_types[layer_idx] if hasattr(config, "layer_types") else None
+ self.config = config
+ self.layer_idx = layer_idx
+ self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+ self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
+ self.scaling = config.query_pre_attn_scalar**-0.5
+ self.attention_dropout = self.config.attention_dropout
+ self.is_causal = False # Only used by the encoder
+
+ self.q_proj = nn.Linear(
+ config.hidden_size, config.num_attention_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.k_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.v_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.o_proj = nn.Linear(
+ config.num_attention_heads * self.head_dim, config.hidden_size, bias=config.attention_bias
+ )
+ self.attn_logit_softcapping = self.config.attn_logit_softcapping
+ self.sliding_window = config.sliding_window if self.layer_type == "sliding_attention" else None
+ self.is_sliding = self.layer_type == "sliding_attention"
+
+ self.q_norm = T5Gemma2RMSNorm(dim=config.head_dim, eps=config.rms_norm_eps)
+ self.k_norm = T5Gemma2RMSNorm(dim=config.head_dim, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: torch.Tensor = None,
+ attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ query_states = self.q_norm(query_states)
+ key_states = self.k_norm(key_states)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ if past_key_values is not None:
+ key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=self.attention_dropout if self.training else 0.0,
+ scaling=self.scaling,
+ sliding_window=self.sliding_window,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+@use_kernelized_func(apply_rotary_pos_emb)
+class T5Gemma2MergedAttention(nn.Module):
+ """Merged self-attention and cross-attention for decoder."""
+
+ def __init__(self, config: T5Gemma2TextConfig, layer_idx: int):
+ super().__init__()
+ self.layer_type = config.layer_types[layer_idx] if hasattr(config, "layer_types") else None
+ self.config = config
+ self.layer_idx = layer_idx
+ self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+ self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
+ self.scaling = config.query_pre_attn_scalar**-0.5
+ self.attention_dropout = self.config.attention_dropout
+ self.is_causal = False # Fused causal and encoder mask
+
+ self.q_proj = nn.Linear(
+ config.hidden_size, config.num_attention_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.k_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.v_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.o_proj = nn.Linear(
+ config.num_attention_heads * self.head_dim, config.hidden_size, bias=config.attention_bias
+ )
+ self.attn_logit_softcapping = self.config.attn_logit_softcapping
+ self.sliding_window = config.sliding_window if self.layer_type == "sliding_attention" else None
+ self.is_sliding = self.layer_type == "sliding_attention"
+
+ self.q_norm = T5Gemma2RMSNorm(dim=config.head_dim, eps=config.rms_norm_eps)
+ self.k_norm = T5Gemma2RMSNorm(dim=config.head_dim, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ # decoder self-attention inputs
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ merged_attention_mask: torch.Tensor | None,
+ # cross-attention inputs
+ encoder_hidden_states: torch.Tensor,
+ # cache inputs
+ past_key_values: EncoderDecoderCache | None = None,
+ # others
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ # attention shapes.
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+ cross_input_shape = encoder_hidden_states.shape[:-1]
+ cross_hidden_shape = (*cross_input_shape, -1, self.head_dim)
+
+ # self-attention.
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ query_states = self.q_norm(query_states)
+ key_states = self.k_norm(key_states)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ if past_key_values is not None:
+ # self-attention.
+ self_attention_cache = past_key_values.self_attention_cache
+ key_states, value_states = self_attention_cache.update(key_states, value_states, self.layer_idx)
+
+ # cross-attention.
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ cross_attention_cache = past_key_values.cross_attention_cache
+
+ if past_key_values is None or not is_updated:
+ cross_key_states = self.k_proj(encoder_hidden_states).view(cross_hidden_shape).transpose(1, 2)
+ cross_value_states = self.v_proj(encoder_hidden_states).view(cross_hidden_shape).transpose(1, 2)
+
+ cross_key_states = self.k_norm(cross_key_states)
+
+ if past_key_values is not None:
+ cross_key_states, cross_value_states = cross_attention_cache.update(
+ cross_key_states, cross_value_states, self.layer_idx
+ )
+ past_key_values.is_updated[self.layer_idx] = True
+ else:
+ cross_key_states = cross_attention_cache.layers[self.layer_idx].keys
+ cross_value_states = cross_attention_cache.layers[self.layer_idx].values
+
+ # merged attention.
+ query_states = query_states
+ cross_key_size = cross_input_shape[1]
+ key_states = torch.cat([key_states, cross_key_states], dim=2)
+ value_states = torch.cat([value_states, cross_value_states], dim=2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ merged_attention_mask,
+ dropout=self.attention_dropout if self.training else 0.0,
+ scaling=self.scaling,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+
+ # decompose merged attention weights into self & cross attention weights
+ if attn_weights is not None:
+ self_attn_weights = attn_weights[..., :-cross_key_size]
+ cross_attn_weights = attn_weights[..., -cross_key_size:]
+ else:
+ self_attn_weights, cross_attn_weights = None, None
+ return attn_output, self_attn_weights, cross_attn_weights
+
+
+class T5Gemma2EncoderLayer(GradientCheckpointingLayer):
+ """Encoder sub-layer."""
+
+ def __init__(self, config, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+ self.config = config
+ self.layer_idx = layer_idx
+ self.attention_type = config.layer_types[layer_idx]
+
+ self.self_attn = T5Gemma2SelfAttention(
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.pre_self_attn_layernorm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_self_attn_layernorm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.mlp = T5Gemma2MLP(config)
+ self.pre_feedforward_layernorm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_feedforward_layernorm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor,]:
+ residual = hidden_states
+ hidden_states = self.pre_self_attn_layernorm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=None,
+ **kwargs,
+ )
+ hidden_states = self.post_self_attn_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.post_feedforward_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+ return hidden_states
+
+
+class T5Gemma2DecoderLayer(GradientCheckpointingLayer):
+ """Decoder sub-layer: merged attention instead of vanilla self-attention."""
+
+ def __init__(self, config, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+ self.config = config
+ self.layer_idx = layer_idx
+ self.attention_type = config.layer_types[layer_idx]
+
+ # replace vanilla self-attention with merged attention to support joint cross-attention.
+ self.self_attn = T5Gemma2MergedAttention(
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.pre_self_attn_layernorm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_self_attn_layernorm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.mlp = T5Gemma2MLP(config)
+ self.pre_feedforward_layernorm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_feedforward_layernorm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ merged_attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ use_cache: bool | None = False,
+ encoder_hidden_states: torch.Tensor | None = None,
+ **kwargs,
+ ) -> torch.FloatTensor:
+ residual = hidden_states
+ hidden_states = self.pre_self_attn_layernorm(hidden_states)
+
+ hidden_states, _, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ merged_attention_mask=merged_attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ encoder_hidden_states=encoder_hidden_states,
+ **kwargs,
+ )
+ hidden_states = self.post_self_attn_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.post_feedforward_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+ return hidden_states
+
+
+class T5Gemma2LMHead(nn.Module):
+ """Head for language modeling (generation) tasks."""
+
+ def __init__(self, hidden_size: int, vocab_size: int, bias: bool = False):
+ super().__init__()
+ self.out_proj = nn.Linear(hidden_size, vocab_size, bias=bias)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ logits = self.out_proj(hidden_states)
+ return logits
+
+
+class T5Gemma2ClassificationHead(nn.Module):
+ """Head for sentence-level classification tasks."""
+
+ def __init__(self, hidden_size: int, num_labels: int, classifier_dropout_rate: float = 0.0):
+ super().__init__()
+ self.dropout = nn.Dropout(p=classifier_dropout_rate)
+ self.out_proj = nn.Linear(hidden_size, num_labels)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.out_proj(hidden_states)
+ return hidden_states
+
+
+class T5Gemma2MultiModalProjector(nn.Module):
+ def __init__(self, config: T5Gemma2EncoderConfig):
+ super().__init__()
+
+ self.mm_input_projection_weight = nn.Parameter(
+ torch.zeros(config.vision_config.hidden_size, config.text_config.hidden_size)
+ )
+
+ self.mm_soft_emb_norm = T5Gemma2RMSNorm(
+ config.vision_config.hidden_size, eps=config.vision_config.layer_norm_eps
+ )
+
+ self.patches_per_image = int(config.vision_config.image_size // config.vision_config.patch_size)
+ self.tokens_per_side = int(config.mm_tokens_per_image**0.5)
+ self.kernel_size = self.patches_per_image // self.tokens_per_side
+ self.avg_pool = nn.AvgPool2d(kernel_size=self.kernel_size, stride=self.kernel_size)
+
+ def forward(self, vision_outputs: torch.Tensor):
+ batch_size, _, hidden_size = vision_outputs.shape
+
+ reshaped_vision_outputs = vision_outputs.transpose(1, 2)
+ reshaped_vision_outputs = reshaped_vision_outputs.reshape(
+ batch_size, hidden_size, self.patches_per_image, self.patches_per_image
+ )
+ reshaped_vision_outputs = reshaped_vision_outputs.contiguous()
+
+ pooled_vision_outputs = self.avg_pool(reshaped_vision_outputs)
+ pooled_vision_outputs = pooled_vision_outputs.flatten(2)
+ pooled_vision_outputs = pooled_vision_outputs.transpose(1, 2)
+
+ normed_vision_outputs = self.mm_soft_emb_norm(pooled_vision_outputs)
+
+ projected_vision_outputs = torch.matmul(normed_vision_outputs, self.mm_input_projection_weight)
+ return projected_vision_outputs.type_as(vision_outputs)
+
+
+class T5Gemma2TextScaledWordEmbedding(nn.Embedding):
+ """T5Gemma2 Embedding: override to add eoi token embedding separately."""
+
+ def __init__(
+ self,
+ num_embeddings: int,
+ embedding_dim: int,
+ padding_idx: int,
+ embed_scale: float = 1.0,
+ eoi_token_index: int = 256_000,
+ ):
+ super().__init__(num_embeddings, embedding_dim, padding_idx)
+ self.scalar_embed_scale = embed_scale
+ self.register_buffer("embed_scale", torch.tensor(embed_scale), persistent=False)
+ self.eoi_token_index = eoi_token_index
+ self.eoi_embedding = nn.Parameter(torch.zeros(self.embedding_dim))
+
+ def forward(self, input_ids: torch.Tensor):
+ input_embeddings = super().forward(input_ids) * self.embed_scale.to(self.weight.dtype)
+ input_embeddings[input_ids == self.eoi_token_index] = self.eoi_embedding.to(input_embeddings.dtype)
+ return input_embeddings
+
+
+@auto_docstring
+class T5Gemma2PreTrainedModel(PreTrainedModel):
+ config: T5Gemma2Config
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+
+ _no_split_modules = [
+ "T5Gemma2EncoderLayer",
+ "T5Gemma2DecoderLayer",
+ "SiglipVisionEmbeddings",
+ "SiglipEncoderLayer",
+ "SiglipMultiheadAttentionPoolingHead",
+ ]
+ _skip_keys_device_placement = ["past_key_values"]
+
+ # Mask creation is incompatible
+ # FA due to non-default creation / SWA
+ _supports_flash_attn = False
+ _supports_sdpa = True
+ # Flex due to custom masks not compatible to be merged after creation
+ _supports_flex_attn = False
+
+ _can_compile_fullgraph = True
+ _supports_attention_backend = True
+ _can_record_outputs = {
+ "hidden_states": [T5Gemma2EncoderLayer, T5Gemma2DecoderLayer],
+ "attentions": [
+ OutputRecorder(T5Gemma2SelfAttention, index=1, layer_name="self_attn"),
+ OutputRecorder(T5Gemma2MergedAttention, index=1, layer_name="self_attn"),
+ OutputRecorder(T5Gemma2MergedAttention, index=2, layer_name="cross_attn"),
+ ],
+ }
+ input_modalities = ("image", "text")
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, T5Gemma2MultiModalProjector):
+ init.zeros_(module.mm_input_projection_weight)
+ elif isinstance(module, T5Gemma2TextScaledWordEmbedding):
+ init.zeros_(module.eoi_embedding)
+ init.constant_(module.embed_scale, module.scalar_embed_scale)
+ elif isinstance(module, T5Gemma2ClassificationHead):
+ scale = module.out_proj.weight.shape[0] ** -0.5
+ init.normal_(module.out_proj.weight, mean=0.0, std=self.config.initializer_range * scale)
+ if hasattr(module.out_proj, "bias") and module.out_proj.bias is not None:
+ init.zeros_(module.out_proj.bias)
+ # We initialize with 0s to be 1 centered as the RMSNorm here does (1 + weight)
+ elif "RMSNorm" in module.__class__.__name__:
+ init.zeros_(module.weight)
+ elif isinstance(module, T5Gemma2RotaryEmbedding):
+ for layer_type in module.layer_types:
+ rope_init_fn = module.compute_default_rope_parameters
+ if module.rope_type[layer_type] != "default":
+ rope_init_fn = ROPE_INIT_FUNCTIONS[module.rope_type[layer_type]]
+ curr_inv_freq, _ = rope_init_fn(module.config, layer_type=layer_type)
+ init.copy_(getattr(module, f"{layer_type}_inv_freq"), curr_inv_freq)
+ init.copy_(getattr(module, f"{layer_type}_original_inv_freq"), curr_inv_freq)
+
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+ """
+ Shifts input_ids to the right, prepends the decoder_start_token_id, and handles
+ pad_token_id replacement for labels that were -100.
+ This is a common preparation step for decoder inputs in sequence-to-sequence models.
+ """
+ decoder_config = self.config.decoder
+ decoder_start_token_id = decoder_config.bos_token_id
+ pad_token_id = decoder_config.pad_token_id
+
+ if decoder_start_token_id is None:
+ raise ValueError("self.model.config.decoder.bos_token_id has to be defined. ")
+
+ # shift inputs to the right
+ shifted_input_ids = labels.new_zeros(labels.shape)
+ shifted_input_ids[..., 1:] = labels[..., :-1].clone()
+ shifted_input_ids[..., 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.decoder.pad_token_id has to be defined.")
+
+ # Is this T5 specific?
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+def sliding_window_mask_function(sliding_window: int, is_causal=True) -> Callable:
+ """
+ This creates uni/bidirectional attention mask with sliding window.
+ """
+
+ def inner_mask(batch_idx: int, head_idx: int, q_idx: int, kv_idx: int) -> bool:
+ if is_causal:
+ left_window_size, right_window_size = sliding_window, 0
+ else:
+ left_window_size, right_window_size = ((sliding_window + 1) // 2, (sliding_window) // 2 + 1)
+
+ dist = q_idx - kv_idx
+ left_mask = (dist >= 0) & (dist < left_window_size)
+ right_mask = (dist < 0) & (-dist < right_window_size)
+ return left_mask | right_mask
+
+ return inner_mask
+
+
+class T5Gemma2TextEncoder(T5Gemma2PreTrainedModel):
+ config: T5Gemma2TextConfig
+ _can_record_outputs = {
+ "attentions": T5Gemma2SelfAttention,
+ "hidden_states": T5Gemma2EncoderLayer,
+ }
+
+ def __init__(
+ self,
+ config: T5Gemma2TextConfig,
+ eoi_token_index: int = 256_000,
+ ):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = T5Gemma2TextScaledWordEmbedding(
+ config.vocab_size,
+ config.hidden_size,
+ self.padding_idx,
+ embed_scale=config.hidden_size**0.5,
+ eoi_token_index=eoi_token_index,
+ )
+ self.norm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.gradient_checkpointing = False
+
+ self.layers = nn.ModuleList(
+ [T5Gemma2EncoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.rotary_emb = T5Gemma2RotaryEmbedding(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ # Unused for processor compatibility kept in signature.
+ token_type_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ # As we want to pass `past_key_values=None` explicitly everywhere, we need to pop them from kwargs if present
+ kwargs.pop("past_key_values", None)
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if position_ids is None:
+ position_ids = torch.arange(0, inputs_embeds.shape[1], device=inputs_embeds.device).unsqueeze(0)
+
+ if not isinstance(self_attn_mask_mapping := attention_mask, dict):
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ }
+ self_attn_mask_mapping = {
+ "full_attention": create_bidirectional_mask(**mask_kwargs),
+ "sliding_attention": create_bidirectional_mask(
+ **mask_kwargs,
+ and_mask_function=sliding_window_mask_function(self.config.sliding_window, is_causal=False),
+ ),
+ }
+
+ # input layer
+ hidden_states = inputs_embeds
+
+ # global and local position embeddings
+ position_embeddings = {}
+ for layer_type in set(self.config.layer_types):
+ position_embeddings[layer_type] = self.rotary_emb(hidden_states, position_ids, layer_type)
+
+ # dropout
+ hidden_states = self.dropout(hidden_states)
+
+ for i, layer_module in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = layer_module(
+ hidden_states,
+ position_embeddings[self.config.layer_types[i]],
+ self_attn_mask_mapping[self.config.layer_types[i]],
+ position_ids,
+ **kwargs,
+ )
+
+ hidden_states = self.norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ )
+
+
+class T5Gemma2Encoder(T5Gemma2PreTrainedModel):
+ config: T5Gemma2EncoderConfig
+
+ def __init__(
+ self,
+ config: T5Gemma2EncoderConfig,
+ eoi_token_index: int = 256_000,
+ ):
+ super().__init__(config)
+
+ self.text_model = T5Gemma2TextEncoder._from_config(config.text_config, eoi_token_index=eoi_token_index)
+ self.vision_tower = AutoModel.from_config(config=config.vision_config)
+ self.multi_modal_projector = T5Gemma2MultiModalProjector(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.text_model.get_input_embeddings()
+
+ def set_input_embeddings(self, new_embeddings):
+ return self.text_model.set_input_embeddings(new_embeddings)
+
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self, pixel_values: torch.Tensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple | BaseModelOutputWithPooling:
+ # pixel_values: (batch_size, channels, height, width)
+ # image_features: Image feature tensor of shape (num_images, image_length, embed_dim).
+ vision_outputs = self.vision_tower(pixel_values=pixel_values, return_dict=True, **kwargs)
+ last_hidden_state = vision_outputs.last_hidden_state
+ image_features = self.multi_modal_projector(last_hidden_state)
+ vision_outputs.pooler_output = image_features
+
+ return vision_outputs
+
+ def get_image_placeholder_mask(
+ self,
+ input_ids: torch.LongTensor | None,
+ inputs_embeds: torch.FloatTensor | None,
+ image_features: torch.FloatTensor,
+ ):
+ """
+ Obtains multimodal placeholder mask from `input_ids` or `inputs_embeds`, and checks that the placeholder token count is
+ equal to the length of multimodal features. If the lengths are different, an error is raised.
+ """
+ image_token_id = self.config.image_token_id
+ if input_ids is None:
+ if inputs_embeds is None:
+ raise ValueError("Either `input_ids` or `inputs_embeds` has to be provided.")
+ special_image_mask = inputs_embeds == self.get_input_embeddings()(
+ torch.tensor(image_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ special_image_mask = special_image_mask.all(-1)
+ else:
+ special_image_mask = input_ids == image_token_id
+
+ n_image_tokens = special_image_mask.sum()
+ special_image_mask = special_image_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+ n_image_features = image_features.shape[0] * image_features.shape[1]
+ torch_compilable_check(
+ inputs_embeds[special_image_mask].numel() == image_features.numel(),
+ f"Image features and image tokens do not match: tokens: {n_image_tokens}, features {n_image_features}",
+ )
+ return special_image_mask
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ # Unused for processor compatibility kept in signature.
+ token_type_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ if inputs_embeds is None:
+ inputs_embeds = self.text_model.embed_tokens(input_ids)
+
+ if pixel_values is not None:
+ image_features = self.get_image_features(pixel_values, return_dict=True).pooler_output
+ image_features = image_features.to(inputs_embeds.device, inputs_embeds.dtype)
+
+ image_mask = self.get_image_placeholder_mask(
+ input_ids, inputs_embeds=inputs_embeds, image_features=image_features
+ )
+
+ inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_features)
+
+ outputs = self.text_model(
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+ return outputs
+
+
+class T5Gemma2Decoder(T5Gemma2PreTrainedModel):
+ config: T5Gemma2DecoderConfig
+ _can_record_outputs = {
+ "attentions": OutputRecorder(T5Gemma2MergedAttention, index=1),
+ "cross_attentions": OutputRecorder(T5Gemma2MergedAttention, index=2),
+ "hidden_states": T5Gemma2DecoderLayer,
+ }
+
+ def __init__(self, config: T5Gemma2DecoderConfig, eoi_token_index: int = 256_000):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = T5Gemma2TextScaledWordEmbedding(
+ config.vocab_size,
+ config.hidden_size,
+ config.pad_token_id,
+ embed_scale=config.hidden_size**0.5,
+ eoi_token_index=eoi_token_index,
+ )
+ self.norm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.gradient_checkpointing = False
+
+ self.layers = nn.ModuleList(
+ [T5Gemma2DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.rotary_emb = T5Gemma2RotaryEmbedding(config)
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPastAndCrossAttentions:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+ if encoder_hidden_states is None:
+ raise ValueError("`encoder_hidden_states` must be given in decoder")
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if not self.training and use_cache and past_key_values is None:
+ past_key_values = EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache())
+
+ if position_ids is None:
+ past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+ position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens
+ position_ids = position_ids.unsqueeze(0)
+
+ if not isinstance(self_attn_mask_mapping := attention_mask, dict):
+ # this masking function does nothing to masking but forces `allow_is_causal_skip` to be False
+ # as we always need a mask during decoding for merged attention.
+ dummy_and_mask_function = lambda *args: torch.tensor(True, dtype=torch.bool) # noqa
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ "past_key_values": past_key_values.self_attention_cache if past_key_values is not None else None,
+ "position_ids": position_ids,
+ "and_mask_function": dummy_and_mask_function,
+ }
+ self_attn_mask_mapping = {
+ "full_attention": create_causal_mask(**mask_kwargs),
+ "sliding_attention": create_sliding_window_causal_mask(**mask_kwargs),
+ }
+
+ if not isinstance(cross_attn_mask_mapping := encoder_attention_mask, dict):
+ cross_attn_mask_mapping = {
+ "full_attention": create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ and_mask_function=dummy_and_mask_function,
+ )
+ }
+
+ merged_attn_mask_mapping = {
+ "full_attention": torch.cat(
+ [self_attn_mask_mapping["full_attention"], cross_attn_mask_mapping["full_attention"]], dim=-1
+ ),
+ "sliding_attention": torch.cat(
+ [self_attn_mask_mapping["sliding_attention"], cross_attn_mask_mapping["full_attention"]], dim=-1
+ ),
+ }
+
+ # input layer
+ hidden_states = inputs_embeds
+
+ # global and local position embeddings
+ position_embeddings = {}
+ for layer_type in set(self.config.layer_types):
+ position_embeddings[layer_type] = self.rotary_emb(hidden_states, position_ids, layer_type)
+
+ # dropout
+ hidden_states = self.dropout(hidden_states)
+
+ for i, layer_module in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = layer_module(
+ hidden_states,
+ position_embeddings[self.config.layer_types[i]],
+ merged_attn_mask_mapping[self.config.layer_types[i]],
+ position_ids,
+ past_key_values,
+ use_cache,
+ encoder_hidden_states,
+ **kwargs,
+ )
+
+ hidden_states = self.norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class T5Gemma2Model(T5Gemma2PreTrainedModel):
+ _tied_weights_keys = {
+ "decoder.embed_tokens.weight": "encoder.text_model.embed_tokens.weight",
+ "decoder.embed_tokens.eoi_embedding": "encoder.text_model.embed_tokens.eoi_embedding",
+ }
+
+ def __init__(self, config: T5Gemma2Config):
+ super().__init__(config)
+
+ # setup encoder and decoder
+ self.encoder = T5Gemma2Encoder(config.encoder, config.eoi_token_index)
+ self.decoder = T5Gemma2Decoder(config.decoder, config.eoi_token_index)
+
+ self.post_init()
+
+ def get_encoder(self):
+ return self.encoder
+
+ def get_decoder(self):
+ return self.decoder
+
+ def get_input_embeddings(self):
+ return self.encoder.get_input_embeddings()
+
+ def set_input_embeddings(self, new_embeddings):
+ return self.encoder.set_input_embeddings(new_embeddings)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ # encoder inputs
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ # decoder inputs
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ # others (mainly inference or cache related)
+ encoder_outputs: BaseModelOutput | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ decoder_inputs_embeds: torch.Tensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> Seq2SeqModelOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ """
+ # encoder
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ pixel_values=pixel_values,
+ return_dict=True,
+ **kwargs,
+ )
+
+ encoder_hidden_states = encoder_outputs.last_hidden_state
+
+ # decoder
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ position_ids=decoder_position_ids,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ return_dict=True,
+ **kwargs,
+ )
+
+ return Seq2SeqModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+class T5Gemma2ForConditionalGeneration(T5Gemma2PreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {
+ "lm_head.out_proj.weight": "model.encoder.text_model.embed_tokens.weight",
+ }
+ _tp_plan = {"lm_head.out_proj": "colwise_gather_output"}
+ _pp_plan = {"lm_head.out_proj": (["hidden_states"], ["logits"])}
+
+ def __init__(self, config: T5Gemma2Config):
+ super().__init__(config)
+
+ self.model = T5Gemma2Model(config)
+ self.vocab_size = config.decoder.vocab_size
+ self.lm_head = T5Gemma2LMHead(config.decoder.hidden_size, self.vocab_size)
+ self.loss_type = "ForMaskedLM"
+
+ self.post_init()
+
+ def set_output_embeddings(self, new_embeddings):
+ self.lm_head.out_proj = new_embeddings
+
+ def get_output_embeddings(self):
+ return self.lm_head.out_proj
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ def get_encoder(self):
+ return self.model.get_encoder()
+
+ def get_decoder(self):
+ return self.model.get_decoder()
+
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self, pixel_values: torch.Tensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple | BaseModelOutputWithPooling:
+ return self.get_encoder().get_image_features(pixel_values, **kwargs)
+
+ @property
+ def vision_tower(self):
+ return self.get_encoder().vision_tower
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ # encoder inputs
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ # decoder inputs
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ # others (mainly inference or cache related)
+ encoder_outputs: BaseModelOutput | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ logits_to_keep: int | torch.Tensor = 0,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqLMOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+ """
+
+ if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
+ # get decoder inputs from shifting lm labels to the right
+ decoder_input_ids = self.prepare_decoder_input_ids_from_labels(labels)
+
+ decoder_outputs: Seq2SeqModelOutput = self.model(
+ input_ids=input_ids,
+ pixel_values=pixel_values,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = decoder_outputs.last_hidden_state
+ # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+ slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+ logits = self.lm_head(hidden_states[:, slice_indices, :])
+
+ decoder_config = self.config.decoder
+ if decoder_config.final_logit_softcapping is not None:
+ logits = logits / decoder_config.final_logit_softcapping
+ logits = torch.tanh(logits)
+ logits = logits * decoder_config.final_logit_softcapping
+
+ loss = None
+ if labels is not None:
+ # Input has right-shifted so we directly perform masked lm loss
+ loss = self.loss_function(logits, labels, self.vocab_size, **kwargs)
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.decoder_hidden_states,
+ decoder_attentions=decoder_outputs.decoder_attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=decoder_outputs.encoder_last_hidden_state,
+ encoder_hidden_states=decoder_outputs.encoder_hidden_states,
+ encoder_attentions=decoder_outputs.encoder_attentions,
+ )
+
+ def _prepare_cache_for_generation(
+ self,
+ generation_config: GenerationConfig,
+ model_kwargs: dict,
+ generation_mode: GenerationMode,
+ batch_size: int,
+ max_cache_length: int,
+ ) -> bool:
+ """Override cache preparation to support T5Gemma2-specific EncoderDecoder Cache."""
+
+ # Build cache and past_key_values structure first and then override as needed.
+ super()._prepare_cache_for_generation(
+ generation_config,
+ model_kwargs,
+ generation_mode,
+ batch_size,
+ max_cache_length,
+ )
+
+ # If use_cache is False, do not prepare the cache.
+ if generation_config.use_cache is False:
+ return
+
+ cache_implementation = generation_config.cache_implementation
+ if cache_implementation is None:
+ offload_cache = False
+ else:
+ offload_cache = "offloaded" in generation_config.cache_implementation
+
+ # Main change: use full cache for cross-attention.
+ cross_attn_config = copy.deepcopy(self.config.get_text_config(decoder=True))
+
+ # cross-attention does not use sliding window
+ cross_attn_config.sliding_window = None
+ cross_attn_config.layer_types = ["full_attention"] * cross_attn_config.num_hidden_layers
+
+ cross_attn_cache_kwargs = {
+ "config": cross_attn_config,
+ "offloading": offload_cache,
+ }
+
+ past_key_values = model_kwargs.get("past_key_values")
+ if past_key_values is not None:
+ if not isinstance(past_key_values, EncoderDecoderCache):
+ raise ValueError(
+ "The `past_key_values` in `model_kwargs` must be of type `EncoderDecoderCache` for T5Gemma2 model."
+ )
+
+ # Cache already established, no need to re-initialize.
+ if len(past_key_values.is_updated) > 0 and past_key_values.is_updated.get(0):
+ return
+
+ cross_attn_cls = type(past_key_values.cross_attention_cache)
+ if cross_attn_cls == StaticCache:
+ cross_attn_cache_kwargs["max_cache_len"] = model_kwargs["encoder_outputs"][0].shape[1]
+ # Update cross-attention cache only (switch from sliding_window to full).
+ past_key_values.cross_attention_cache = cross_attn_cls(**cross_attn_cache_kwargs)
+ else:
+ # Initialize new cache.
+ model_kwargs["past_key_values"] = EncoderDecoderCache(
+ DynamicCache(
+ **{
+ "config": self.config.get_text_config(decoder=True),
+ "offloading": offload_cache,
+ }
+ ), # self-attention cache
+ DynamicCache(), # cross-attention cache
+ )
+
+ if hasattr(self, "_cache") and self._cache is not None:
+ if not isinstance(self._cache, EncoderDecoderCache):
+ raise ValueError("The internal cache must be of type `EncoderDecoderCache` for T5Gemma2 model.")
+
+ self._cache = model_kwargs["past_key_values"]
+
+
+@auto_docstring
+class T5Gemma2ForSequenceClassification(T5Gemma2PreTrainedModel):
+ def __init__(self, config: T5Gemma2Config):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+ self.hidden_size = config.decoder.hidden_size
+
+ self.model = T5Gemma2Model(config)
+
+ classifier_dropout = getattr(config, "classifier_dropout_rate", 0.1)
+ self.score = T5Gemma2ClassificationHead(self.hidden_size, self.num_labels, classifier_dropout)
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.Tensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SequenceClassifierOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ if inputs_embeds is not None or decoder_inputs_embeds is not None:
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__}."
+ )
+
+ if input_ids is None:
+ raise ValueError("You have to specify input_ids")
+
+ if decoder_input_ids is None:
+ decoder_input_ids = self.prepare_decoder_input_ids_from_labels(input_ids)
+
+ outputs: Seq2SeqModelOutput = self.model(
+ input_ids,
+ pixel_values=pixel_values,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=False,
+ **kwargs,
+ )
+
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.decoder_hidden_states
+ attentions = outputs.decoder_attentions
+
+ logits = self.score(last_hidden_state)
+
+ batch_size = input_ids.shape[0]
+ # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
+ non_pad_mask = (decoder_input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
+ token_indices = torch.arange(decoder_input_ids.shape[-1], device=logits.device, dtype=torch.int32)
+ last_non_pad_token = (token_indices * non_pad_mask).argmax(-1)
+ last_non_pad_token = torch.clamp(last_non_pad_token, max=decoder_input_ids.shape[-1] - 1)
+
+ pooled_logits = logits[torch.arange(batch_size, device=logits.device), last_non_pad_token]
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits=logits, labels=labels, pooled_logits=pooled_logits, config=self.config)
+
+ return SequenceClassifierOutput(
+ loss=loss,
+ logits=pooled_logits,
+ hidden_states=hidden_states,
+ attentions=attentions,
+ )
+
+
+@auto_docstring
+class T5Gemma2ForTokenClassification(T5Gemma2PreTrainedModel):
+ def __init__(self, config: T5Gemma2Config):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+ self.hidden_size = config.decoder.hidden_size
+
+ self.model = T5Gemma2Model(config)
+
+ classifier_dropout = getattr(config, "classifier_dropout_rate", 0.1)
+ self.score = T5Gemma2ClassificationHead(self.hidden_size, self.num_labels, classifier_dropout)
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.Tensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TokenClassifierOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ if inputs_embeds is not None or decoder_inputs_embeds is not None:
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__}."
+ )
+
+ if input_ids is None:
+ raise ValueError("You have to specify input_ids")
+
+ if decoder_input_ids is None:
+ decoder_input_ids = self.prepare_decoder_input_ids_from_labels(input_ids)
+
+ outputs: Seq2SeqModelOutput = self.model(
+ input_ids,
+ pixel_values=pixel_values,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=False,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.decoder_hidden_states
+ attentions = outputs.decoder_attentions
+
+ logits = self.score(last_hidden_state)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits, labels, self.config)
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=hidden_states,
+ attentions=attentions,
+ )
+
+
+__all__ = [
+ "T5Gemma2ForConditionalGeneration",
+ "T5Gemma2Model",
+ "T5Gemma2Encoder",
+ "T5Gemma2PreTrainedModel",
+ "T5Gemma2ForSequenceClassification",
+ "T5Gemma2ForTokenClassification",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/t5gemma2/modular_t5gemma2.py b/lib/python3.11/site-packages/transformers/models/t5gemma2/modular_t5gemma2.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1b80a81ef80411d070652608aaf90bcbedb7457
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/t5gemma2/modular_t5gemma2.py
@@ -0,0 +1,1373 @@
+# Copyright 2025 Google Inc. HuggingFace Inc. 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 copy
+from collections.abc import Callable
+from typing import Any, Optional
+
+import torch
+import torch.nn as nn
+from huggingface_hub.dataclasses import strict
+
+from ... import initialization as init
+from ...cache_utils import DynamicCache, EncoderDecoderCache, StaticCache
+from ...configuration_utils import PreTrainedConfig
+from ...generation import GenerationConfig, GenerationMixin, GenerationMode
+from ...masking_utils import create_bidirectional_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_outputs import (
+ BaseModelOutput,
+ BaseModelOutputWithPastAndCrossAttentions,
+ BaseModelOutputWithPooling,
+ Seq2SeqLMOutput,
+ Seq2SeqModelOutput,
+ SequenceClassifierOutput,
+ TokenClassifierOutput,
+)
+from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import (
+ TransformersKwargs,
+ auto_docstring,
+ can_return_tuple,
+ logging,
+ torch_compilable_check,
+)
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from ..auto import AutoModel
+from ..gemma3.configuration_gemma3 import Gemma3Config, Gemma3TextConfig
+from ..gemma3.modeling_gemma3 import (
+ Gemma3Attention,
+ Gemma3MLP,
+ Gemma3MultiModalProjector,
+ Gemma3PreTrainedModel,
+ Gemma3RMSNorm,
+ Gemma3RotaryEmbedding,
+ Gemma3TextScaledWordEmbedding,
+ apply_rotary_pos_emb,
+ create_causal_mask,
+ create_sliding_window_causal_mask,
+ eager_attention_forward,
+)
+from ..siglip import SiglipVisionConfig
+from ..t5gemma.modeling_t5gemma import (
+ T5GemmaClassificationHead,
+ T5GemmaEncoderLayer,
+ T5GemmaLMHead,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="google/t5gemma-2-270m-270m")
+@strict
+class T5Gemma2TextConfig(Gemma3TextConfig, PreTrainedConfig):
+ r"""
+ query_pre_attn_scalar (`float`, *optional*, defaults to 256):
+ Scaling factor used on the attention scores
+ final_logit_softcapping (`float`, *optional*):
+ Scaling factor when applying tanh softcapping on the logits.
+ attn_logit_softcapping (`float`, *optional*):
+ Scaling factor when applying tanh softcapping on the attention scores.
+ """
+
+ model_type = "t5gemma2_text"
+ use_bidirectional_attention = AttributeError()
+
+ def __post_init__(self, **kwargs):
+ # BC -> the pattern used to be a simple int, and it's still present in configs on the Hub
+ _sliding_window_pattern = kwargs.pop("sliding_window_pattern", 6)
+ if self.layer_types is None:
+ self.layer_types = [
+ "sliding_attention" if bool((i + 1) % _sliding_window_pattern) else "full_attention"
+ for i in range(self.num_hidden_layers)
+ ]
+
+ PreTrainedConfig.__post_init__(**kwargs)
+
+
+@auto_docstring(checkpoint="google/t5gemma-2-270m-270m")
+@strict
+class T5Gemma2EncoderConfig(Gemma3Config):
+ model_type = "t5gemma2_encoder"
+
+ sub_configs = {
+ "text_config": T5Gemma2TextConfig,
+ "vision_config": SiglipVisionConfig,
+ }
+
+
+@auto_docstring(checkpoint="google/t5gemma-2-270m-270m")
+@strict
+class T5Gemma2DecoderConfig(Gemma3TextConfig, PreTrainedConfig):
+ r"""
+ query_pre_attn_scalar (`float`, *optional*, defaults to 256):
+ Scaling factor used on the attention scores
+ final_logit_softcapping (`float`, *optional*):
+ Scaling factor when applying tanh softcapping on the logits.
+ attn_logit_softcapping (`float`, *optional*):
+ Scaling factor when applying tanh softcapping on the attention scores.
+ """
+
+ model_type = "t5gemma2_decoder"
+ use_bidirectional_attention = AttributeError()
+
+ def __post_init__(self, **kwargs):
+ # BC -> the pattern used to be a simple int, and it's still present in configs on the Hub
+ _sliding_window_pattern = kwargs.pop("sliding_window_pattern", 6)
+ if self.layer_types is None:
+ self.layer_types = [
+ "sliding_attention" if bool((i + 1) % _sliding_window_pattern) else "full_attention"
+ for i in range(self.num_hidden_layers)
+ ]
+
+ PreTrainedConfig.__post_init__(**kwargs)
+
+
+@auto_docstring(checkpoint="google/t5gemma-2-270m-270m")
+@strict
+class T5Gemma2Config(PreTrainedConfig):
+ r"""
+ encoder (`Union[T5Gemma2EncoderConfig, dict]`, optional, *optional*):
+ Configuration for the encoder.
+ decoder (`Union[T5Gemma2DecoderConfig, dict]`, optional, *optional*):
+ Configuration for the decoder.
+ eoi_token_index (`int`, *optional*):
+ The end-of-image token index to wrap the image prompt. Will be same as
+ `self.encoder.eoi_token_index`
+
+ ```python
+ >>> from transformers import T5Gemma2Config, T5Gemma2Model
+ >>> t5gemma2_config = T5Gemma2Config.from_pretrained("google/t5gemma-270m-270m")
+ >>> model = T5Gemma2Model(t5gemma2_config)
+ ```
+ """
+
+ model_type = "t5gemma2"
+ keys_to_ignore_at_inference = ["past_key_values"]
+
+ sub_configs = {
+ "encoder": T5Gemma2EncoderConfig,
+ "decoder": T5Gemma2DecoderConfig,
+ }
+
+ attribute_map = {
+ "image_token_id": "image_token_index",
+ "eoi_token_id": "eoi_token_index",
+ }
+
+ encoder: T5Gemma2EncoderConfig | dict[str, Any] | None = None
+ decoder: T5Gemma2DecoderConfig | dict[str, Any] | None = None
+ is_encoder_decoder: bool = True
+ dropout_rate: float | int = 0.0
+ attention_dropout: float | int = 0.0
+ classifier_dropout_rate: float | int = 0.0
+ initializer_range: float = 0.02
+ image_token_index: int = 256_001
+ eoi_token_index: int | None = None
+ tie_word_embeddings: bool = True
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.encoder, dict):
+ self.encoder = T5Gemma2EncoderConfig(**self.encoder)
+ elif self.encoder is None:
+ self.encoder = T5Gemma2EncoderConfig()
+ logger.info("encoder is None, using default T5Gemma2EncoderConfig encoder config.")
+
+ if isinstance(self.decoder, dict):
+ self.decoder = T5Gemma2DecoderConfig(**self.decoder)
+ elif self.decoder is None:
+ self.decoder = T5Gemma2DecoderConfig()
+ logger.info("decoder is None, using default T5Gemma2DecoderConfig decoder config.")
+
+ self.encoder.text_config.dropout_rate = self.dropout_rate
+ self.encoder.text_config.attention_dropout = self.attention_dropout
+ self.encoder.vision_config.attention_dropout = self.attention_dropout
+ self.encoder.image_token_index = self.image_token_index
+
+ self.decoder.dropout_rate = self.dropout_rate
+ self.decoder.attention_dropout = self.attention_dropout
+ self.eoi_token_index = self.encoder.eoi_token_index
+
+ for special_token_key in ["bos_token_id", "pad_token_id", "eos_token_id", "vocab_size"]:
+ if special_token_key not in kwargs:
+ kwargs[special_token_key] = getattr(self.decoder, special_token_key)
+
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if self.encoder.text_config.hidden_size != self.decoder.hidden_size:
+ raise ValueError(
+ "Imbalanced encoder-decoder is not supported in T5Gemma2: "
+ f"encoder ({self.encoder.text_config.hidden_size}) vs decoder ({self.decoder.hidden_size})."
+ )
+
+ if not self.is_encoder_decoder:
+ raise ValueError("T5Gemma2Model only support encoder-decoder modeling.")
+
+ if self.encoder.text_config.vocab_size != self.decoder.vocab_size:
+ raise ValueError(
+ "Imbalanced encoder-decoder vocabulary size is not supported in T5Gemma2: "
+ f"encoder ({self.encoder.text_config.vocab_size}) vs decoder ({self.decoder.vocab_size})."
+ )
+
+
+class T5Gemma2RMSNorm(Gemma3RMSNorm):
+ pass
+
+
+class T5Gemma2MLP(Gemma3MLP):
+ def __init__(self, config: T5Gemma2TextConfig):
+ super().__init__(config)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(self, x):
+ hidden_states = self.act_fn(self.gate_proj(x)) * self.up_proj(x)
+ hidden_states = self.dropout(hidden_states)
+ down_proj = self.down_proj(hidden_states)
+ return down_proj
+
+
+class T5Gemma2RotaryEmbedding(Gemma3RotaryEmbedding):
+ def __init__(self, config: T5Gemma2TextConfig, device=None):
+ super().__init__(config, device)
+
+ @staticmethod
+ def compute_default_rope_parameters(
+ config: T5Gemma2TextConfig | None = None,
+ device: Optional["torch.device"] = None,
+ seq_len: int | None = None,
+ layer_type: str | None = None,
+ ) -> tuple["torch.Tensor", float]:
+ return super().compute_default_rope_parameters(config, device, seq_len, layer_type)
+
+
+class T5Gemma2SelfAttention(Gemma3Attention):
+ def __init__(self, config: T5Gemma2TextConfig, layer_idx: int):
+ super().__init__(config, layer_idx)
+ self.is_causal = False # Only used by the encoder
+
+
+class T5Gemma2MergedAttention(Gemma3Attention):
+ """Merged self-attention and cross-attention for decoder."""
+
+ def __init__(self, config: T5Gemma2TextConfig, layer_idx: int):
+ super().__init__(config, layer_idx)
+ self.is_causal = False # Fused causal and encoder mask
+
+ def forward(
+ self,
+ # decoder self-attention inputs
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ merged_attention_mask: torch.Tensor | None,
+ # cross-attention inputs
+ encoder_hidden_states: torch.Tensor,
+ # cache inputs
+ past_key_values: EncoderDecoderCache | None = None,
+ # others
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ # attention shapes.
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+ cross_input_shape = encoder_hidden_states.shape[:-1]
+ cross_hidden_shape = (*cross_input_shape, -1, self.head_dim)
+
+ # self-attention.
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ query_states = self.q_norm(query_states)
+ key_states = self.k_norm(key_states)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ if past_key_values is not None:
+ # self-attention.
+ self_attention_cache = past_key_values.self_attention_cache
+ key_states, value_states = self_attention_cache.update(key_states, value_states, self.layer_idx)
+
+ # cross-attention.
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ cross_attention_cache = past_key_values.cross_attention_cache
+
+ if past_key_values is None or not is_updated:
+ cross_key_states = self.k_proj(encoder_hidden_states).view(cross_hidden_shape).transpose(1, 2)
+ cross_value_states = self.v_proj(encoder_hidden_states).view(cross_hidden_shape).transpose(1, 2)
+
+ cross_key_states = self.k_norm(cross_key_states)
+
+ if past_key_values is not None:
+ cross_key_states, cross_value_states = cross_attention_cache.update(
+ cross_key_states, cross_value_states, self.layer_idx
+ )
+ past_key_values.is_updated[self.layer_idx] = True
+ else:
+ cross_key_states = cross_attention_cache.layers[self.layer_idx].keys
+ cross_value_states = cross_attention_cache.layers[self.layer_idx].values
+
+ # merged attention.
+ query_states = query_states
+ cross_key_size = cross_input_shape[1]
+ key_states = torch.cat([key_states, cross_key_states], dim=2)
+ value_states = torch.cat([value_states, cross_value_states], dim=2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ merged_attention_mask,
+ dropout=self.attention_dropout if self.training else 0.0,
+ scaling=self.scaling,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+
+ # decompose merged attention weights into self & cross attention weights
+ if attn_weights is not None:
+ self_attn_weights = attn_weights[..., :-cross_key_size]
+ cross_attn_weights = attn_weights[..., -cross_key_size:]
+ else:
+ self_attn_weights, cross_attn_weights = None, None
+ return attn_output, self_attn_weights, cross_attn_weights
+
+
+def sliding_window_mask_function(sliding_window: int, is_causal=True) -> Callable:
+ """
+ This creates uni/bidirectional attention mask with sliding window.
+ """
+
+ def inner_mask(batch_idx: int, head_idx: int, q_idx: int, kv_idx: int) -> bool:
+ if is_causal:
+ left_window_size, right_window_size = sliding_window, 0
+ else:
+ left_window_size, right_window_size = ((sliding_window + 1) // 2, (sliding_window) // 2 + 1)
+
+ dist = q_idx - kv_idx
+ left_mask = (dist >= 0) & (dist < left_window_size)
+ right_mask = (dist < 0) & (-dist < right_window_size)
+ return left_mask | right_mask
+
+ return inner_mask
+
+
+class T5Gemma2EncoderLayer(T5GemmaEncoderLayer):
+ pass
+
+
+class T5Gemma2DecoderLayer(T5GemmaEncoderLayer):
+ """Decoder sub-layer: merged attention instead of vanilla self-attention."""
+
+ def __init__(self, config, layer_idx: int):
+ super().__init__(config, layer_idx)
+
+ # replace vanilla self-attention with merged attention to support joint cross-attention.
+ self.self_attn = T5Gemma2MergedAttention(
+ config=config,
+ layer_idx=layer_idx,
+ )
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ merged_attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ use_cache: bool | None = False,
+ encoder_hidden_states: torch.Tensor | None = None,
+ **kwargs,
+ ) -> torch.FloatTensor:
+ residual = hidden_states
+ hidden_states = self.pre_self_attn_layernorm(hidden_states)
+
+ hidden_states, _, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ merged_attention_mask=merged_attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ encoder_hidden_states=encoder_hidden_states,
+ **kwargs,
+ )
+ hidden_states = self.post_self_attn_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.post_feedforward_layernorm(hidden_states)
+ hidden_states = residual + self.dropout(hidden_states)
+ return hidden_states
+
+
+class T5Gemma2LMHead(T5GemmaLMHead):
+ pass
+
+
+class T5Gemma2ClassificationHead(T5GemmaClassificationHead):
+ pass
+
+
+class T5Gemma2MultiModalProjector(Gemma3MultiModalProjector):
+ def __init__(self, config: T5Gemma2EncoderConfig):
+ super().__init__(config)
+
+
+class T5Gemma2TextScaledWordEmbedding(Gemma3TextScaledWordEmbedding):
+ """T5Gemma2 Embedding: override to add eoi token embedding separately."""
+
+ def __init__(
+ self,
+ num_embeddings: int,
+ embedding_dim: int,
+ padding_idx: int,
+ embed_scale: float = 1.0,
+ eoi_token_index: int = 256_000,
+ ):
+ super().__init__(num_embeddings, embedding_dim, padding_idx, embed_scale)
+ self.eoi_token_index = eoi_token_index
+ self.eoi_embedding = nn.Parameter(torch.zeros(self.embedding_dim))
+
+ def forward(self, input_ids: torch.Tensor):
+ input_embeddings = super().forward(input_ids) * self.embed_scale.to(self.weight.dtype)
+ input_embeddings[input_ids == self.eoi_token_index] = self.eoi_embedding.to(input_embeddings.dtype)
+ return input_embeddings
+
+
+@auto_docstring
+class T5Gemma2PreTrainedModel(Gemma3PreTrainedModel):
+ config: T5Gemma2Config
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+
+ # Mask creation is incompatible
+ # FA due to non-default creation / SWA
+ _supports_flash_attn = False
+ # Flex due to custom masks not compatible to be merged after creation
+ _supports_flex_attn = False
+
+ _no_split_modules = [
+ "T5Gemma2EncoderLayer",
+ "T5Gemma2DecoderLayer",
+ "SiglipVisionEmbeddings",
+ "SiglipEncoderLayer",
+ "SiglipMultiheadAttentionPoolingHead",
+ ]
+ _can_record_outputs = {
+ "hidden_states": [T5Gemma2EncoderLayer, T5Gemma2DecoderLayer],
+ "attentions": [
+ OutputRecorder(T5Gemma2SelfAttention, index=1, layer_name="self_attn"),
+ OutputRecorder(T5Gemma2MergedAttention, index=1, layer_name="self_attn"),
+ OutputRecorder(T5Gemma2MergedAttention, index=2, layer_name="cross_attn"),
+ ],
+ }
+
+ def _init_weights(self, module):
+ PreTrainedModel._init_weights(self, module)
+ if isinstance(module, T5Gemma2MultiModalProjector):
+ init.zeros_(module.mm_input_projection_weight)
+ elif isinstance(module, T5Gemma2TextScaledWordEmbedding):
+ init.zeros_(module.eoi_embedding)
+ init.constant_(module.embed_scale, module.scalar_embed_scale)
+ elif isinstance(module, T5Gemma2ClassificationHead):
+ scale = module.out_proj.weight.shape[0] ** -0.5
+ init.normal_(module.out_proj.weight, mean=0.0, std=self.config.initializer_range * scale)
+ if hasattr(module.out_proj, "bias") and module.out_proj.bias is not None:
+ init.zeros_(module.out_proj.bias)
+ # We initialize with 0s to be 1 centered as the RMSNorm here does (1 + weight)
+ elif "RMSNorm" in module.__class__.__name__:
+ init.zeros_(module.weight)
+ elif isinstance(module, T5Gemma2RotaryEmbedding):
+ for layer_type in module.layer_types:
+ rope_init_fn = module.compute_default_rope_parameters
+ if module.rope_type[layer_type] != "default":
+ rope_init_fn = ROPE_INIT_FUNCTIONS[module.rope_type[layer_type]]
+ curr_inv_freq, _ = rope_init_fn(module.config, layer_type=layer_type)
+ init.copy_(getattr(module, f"{layer_type}_inv_freq"), curr_inv_freq)
+ init.copy_(getattr(module, f"{layer_type}_original_inv_freq"), curr_inv_freq)
+
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+ """
+ Shifts input_ids to the right, prepends the decoder_start_token_id, and handles
+ pad_token_id replacement for labels that were -100.
+ This is a common preparation step for decoder inputs in sequence-to-sequence models.
+ """
+ decoder_config = self.config.decoder
+ decoder_start_token_id = decoder_config.bos_token_id
+ pad_token_id = decoder_config.pad_token_id
+
+ if decoder_start_token_id is None:
+ raise ValueError("self.model.config.decoder.bos_token_id has to be defined. ")
+
+ # shift inputs to the right
+ shifted_input_ids = labels.new_zeros(labels.shape)
+ shifted_input_ids[..., 1:] = labels[..., :-1].clone()
+ shifted_input_ids[..., 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.decoder.pad_token_id has to be defined.")
+
+ # Is this T5 specific?
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+class T5Gemma2TextEncoder(T5Gemma2PreTrainedModel):
+ config: T5Gemma2TextConfig
+ _can_record_outputs = {
+ "attentions": T5Gemma2SelfAttention,
+ "hidden_states": T5Gemma2EncoderLayer,
+ }
+
+ def __init__(
+ self,
+ config: T5Gemma2TextConfig,
+ eoi_token_index: int = 256_000,
+ ):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = T5Gemma2TextScaledWordEmbedding(
+ config.vocab_size,
+ config.hidden_size,
+ self.padding_idx,
+ embed_scale=config.hidden_size**0.5,
+ eoi_token_index=eoi_token_index,
+ )
+ self.norm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.gradient_checkpointing = False
+
+ self.layers = nn.ModuleList(
+ [T5Gemma2EncoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.rotary_emb = T5Gemma2RotaryEmbedding(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ # Unused for processor compatibility kept in signature.
+ token_type_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ # As we want to pass `past_key_values=None` explicitly everywhere, we need to pop them from kwargs if present
+ kwargs.pop("past_key_values", None)
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if position_ids is None:
+ position_ids = torch.arange(0, inputs_embeds.shape[1], device=inputs_embeds.device).unsqueeze(0)
+
+ if not isinstance(self_attn_mask_mapping := attention_mask, dict):
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ }
+ self_attn_mask_mapping = {
+ "full_attention": create_bidirectional_mask(**mask_kwargs),
+ "sliding_attention": create_bidirectional_mask(
+ **mask_kwargs,
+ and_mask_function=sliding_window_mask_function(self.config.sliding_window, is_causal=False),
+ ),
+ }
+
+ # input layer
+ hidden_states = inputs_embeds
+
+ # global and local position embeddings
+ position_embeddings = {}
+ for layer_type in set(self.config.layer_types):
+ position_embeddings[layer_type] = self.rotary_emb(hidden_states, position_ids, layer_type)
+
+ # dropout
+ hidden_states = self.dropout(hidden_states)
+
+ for i, layer_module in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = layer_module(
+ hidden_states,
+ position_embeddings[self.config.layer_types[i]],
+ self_attn_mask_mapping[self.config.layer_types[i]],
+ position_ids,
+ **kwargs,
+ )
+
+ hidden_states = self.norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ )
+
+
+class T5Gemma2Encoder(T5Gemma2PreTrainedModel):
+ config: T5Gemma2EncoderConfig
+
+ def __init__(
+ self,
+ config: T5Gemma2EncoderConfig,
+ eoi_token_index: int = 256_000,
+ ):
+ super().__init__(config)
+
+ self.text_model = T5Gemma2TextEncoder._from_config(config.text_config, eoi_token_index=eoi_token_index)
+ self.vision_tower = AutoModel.from_config(config=config.vision_config)
+ self.multi_modal_projector = T5Gemma2MultiModalProjector(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.text_model.get_input_embeddings()
+
+ def set_input_embeddings(self, new_embeddings):
+ return self.text_model.set_input_embeddings(new_embeddings)
+
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self, pixel_values: torch.Tensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple | BaseModelOutputWithPooling:
+ # pixel_values: (batch_size, channels, height, width)
+ # image_features: Image feature tensor of shape (num_images, image_length, embed_dim).
+ vision_outputs = self.vision_tower(pixel_values=pixel_values, return_dict=True, **kwargs)
+ last_hidden_state = vision_outputs.last_hidden_state
+ image_features = self.multi_modal_projector(last_hidden_state)
+ vision_outputs.pooler_output = image_features
+
+ return vision_outputs
+
+ def get_image_placeholder_mask(
+ self,
+ input_ids: torch.LongTensor | None,
+ inputs_embeds: torch.FloatTensor | None,
+ image_features: torch.FloatTensor,
+ ):
+ """
+ Obtains multimodal placeholder mask from `input_ids` or `inputs_embeds`, and checks that the placeholder token count is
+ equal to the length of multimodal features. If the lengths are different, an error is raised.
+ """
+ image_token_id = self.config.image_token_id
+ if input_ids is None:
+ if inputs_embeds is None:
+ raise ValueError("Either `input_ids` or `inputs_embeds` has to be provided.")
+ special_image_mask = inputs_embeds == self.get_input_embeddings()(
+ torch.tensor(image_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ special_image_mask = special_image_mask.all(-1)
+ else:
+ special_image_mask = input_ids == image_token_id
+
+ n_image_tokens = special_image_mask.sum()
+ special_image_mask = special_image_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+ n_image_features = image_features.shape[0] * image_features.shape[1]
+ torch_compilable_check(
+ inputs_embeds[special_image_mask].numel() == image_features.numel(),
+ f"Image features and image tokens do not match: tokens: {n_image_tokens}, features {n_image_features}",
+ )
+ return special_image_mask
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ # Unused for processor compatibility kept in signature.
+ token_type_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ if inputs_embeds is None:
+ inputs_embeds = self.text_model.embed_tokens(input_ids)
+
+ if pixel_values is not None:
+ image_features = self.get_image_features(pixel_values, return_dict=True).pooler_output
+ image_features = image_features.to(inputs_embeds.device, inputs_embeds.dtype)
+
+ image_mask = self.get_image_placeholder_mask(
+ input_ids, inputs_embeds=inputs_embeds, image_features=image_features
+ )
+
+ inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_features)
+
+ outputs = self.text_model(
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+ return outputs
+
+
+class T5Gemma2Decoder(T5Gemma2PreTrainedModel):
+ config: T5Gemma2DecoderConfig
+ _can_record_outputs = {
+ "attentions": OutputRecorder(T5Gemma2MergedAttention, index=1),
+ "cross_attentions": OutputRecorder(T5Gemma2MergedAttention, index=2),
+ "hidden_states": T5Gemma2DecoderLayer,
+ }
+
+ def __init__(self, config: T5Gemma2DecoderConfig, eoi_token_index: int = 256_000):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+
+ self.embed_tokens = T5Gemma2TextScaledWordEmbedding(
+ config.vocab_size,
+ config.hidden_size,
+ config.pad_token_id,
+ embed_scale=config.hidden_size**0.5,
+ eoi_token_index=eoi_token_index,
+ )
+ self.norm = T5Gemma2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.gradient_checkpointing = False
+
+ self.layers = nn.ModuleList(
+ [T5Gemma2DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.rotary_emb = T5Gemma2RotaryEmbedding(config)
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPastAndCrossAttentions:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+ if encoder_hidden_states is None:
+ raise ValueError("`encoder_hidden_states` must be given in decoder")
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if not self.training and use_cache and past_key_values is None:
+ past_key_values = EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache())
+
+ if position_ids is None:
+ past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+ position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens
+ position_ids = position_ids.unsqueeze(0)
+
+ if not isinstance(self_attn_mask_mapping := attention_mask, dict):
+ # this masking function does nothing to masking but forces `allow_is_causal_skip` to be False
+ # as we always need a mask during decoding for merged attention.
+ dummy_and_mask_function = lambda *args: torch.tensor(True, dtype=torch.bool) # noqa
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ "past_key_values": past_key_values.self_attention_cache if past_key_values is not None else None,
+ "position_ids": position_ids,
+ "and_mask_function": dummy_and_mask_function,
+ }
+ self_attn_mask_mapping = {
+ "full_attention": create_causal_mask(**mask_kwargs),
+ "sliding_attention": create_sliding_window_causal_mask(**mask_kwargs),
+ }
+
+ if not isinstance(cross_attn_mask_mapping := encoder_attention_mask, dict):
+ cross_attn_mask_mapping = {
+ "full_attention": create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ and_mask_function=dummy_and_mask_function,
+ )
+ }
+
+ merged_attn_mask_mapping = {
+ "full_attention": torch.cat(
+ [self_attn_mask_mapping["full_attention"], cross_attn_mask_mapping["full_attention"]], dim=-1
+ ),
+ "sliding_attention": torch.cat(
+ [self_attn_mask_mapping["sliding_attention"], cross_attn_mask_mapping["full_attention"]], dim=-1
+ ),
+ }
+
+ # input layer
+ hidden_states = inputs_embeds
+
+ # global and local position embeddings
+ position_embeddings = {}
+ for layer_type in set(self.config.layer_types):
+ position_embeddings[layer_type] = self.rotary_emb(hidden_states, position_ids, layer_type)
+
+ # dropout
+ hidden_states = self.dropout(hidden_states)
+
+ for i, layer_module in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = layer_module(
+ hidden_states,
+ position_embeddings[self.config.layer_types[i]],
+ merged_attn_mask_mapping[self.config.layer_types[i]],
+ position_ids,
+ past_key_values,
+ use_cache,
+ encoder_hidden_states,
+ **kwargs,
+ )
+
+ hidden_states = self.norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class T5Gemma2Model(T5Gemma2PreTrainedModel):
+ _tied_weights_keys = {
+ "decoder.embed_tokens.weight": "encoder.text_model.embed_tokens.weight",
+ "decoder.embed_tokens.eoi_embedding": "encoder.text_model.embed_tokens.eoi_embedding",
+ }
+
+ def __init__(self, config: T5Gemma2Config):
+ super().__init__(config)
+
+ # setup encoder and decoder
+ self.encoder = T5Gemma2Encoder(config.encoder, config.eoi_token_index)
+ self.decoder = T5Gemma2Decoder(config.decoder, config.eoi_token_index)
+
+ self.post_init()
+
+ def get_encoder(self):
+ return self.encoder
+
+ def get_decoder(self):
+ return self.decoder
+
+ def get_input_embeddings(self):
+ return self.encoder.get_input_embeddings()
+
+ def set_input_embeddings(self, new_embeddings):
+ return self.encoder.set_input_embeddings(new_embeddings)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ # encoder inputs
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ # decoder inputs
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ # others (mainly inference or cache related)
+ encoder_outputs: BaseModelOutput | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ decoder_inputs_embeds: torch.Tensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> Seq2SeqModelOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ """
+ # encoder
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ pixel_values=pixel_values,
+ return_dict=True,
+ **kwargs,
+ )
+
+ encoder_hidden_states = encoder_outputs.last_hidden_state
+
+ # decoder
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ position_ids=decoder_position_ids,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ return_dict=True,
+ **kwargs,
+ )
+
+ return Seq2SeqModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+class T5Gemma2ForConditionalGeneration(T5Gemma2PreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {
+ "lm_head.out_proj.weight": "model.encoder.text_model.embed_tokens.weight",
+ }
+ _tp_plan = {"lm_head.out_proj": "colwise_gather_output"}
+ _pp_plan = {"lm_head.out_proj": (["hidden_states"], ["logits"])}
+
+ def __init__(self, config: T5Gemma2Config):
+ super().__init__(config)
+
+ self.model = T5Gemma2Model(config)
+ self.vocab_size = config.decoder.vocab_size
+ self.lm_head = T5Gemma2LMHead(config.decoder.hidden_size, self.vocab_size)
+ self.loss_type = "ForMaskedLM"
+
+ self.post_init()
+
+ def set_output_embeddings(self, new_embeddings):
+ self.lm_head.out_proj = new_embeddings
+
+ def get_output_embeddings(self):
+ return self.lm_head.out_proj
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ def get_encoder(self):
+ return self.model.get_encoder()
+
+ def get_decoder(self):
+ return self.model.get_decoder()
+
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self, pixel_values: torch.Tensor, **kwargs: Unpack[TransformersKwargs]
+ ) -> tuple | BaseModelOutputWithPooling:
+ return self.get_encoder().get_image_features(pixel_values, **kwargs)
+
+ @property
+ def vision_tower(self):
+ return self.get_encoder().vision_tower
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ # encoder inputs
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ # decoder inputs
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ # others (mainly inference or cache related)
+ encoder_outputs: BaseModelOutput | None = None,
+ past_key_values: EncoderDecoderCache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ logits_to_keep: int | torch.Tensor = 0,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | Seq2SeqLMOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+ """
+
+ if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
+ # get decoder inputs from shifting lm labels to the right
+ decoder_input_ids = self.prepare_decoder_input_ids_from_labels(labels)
+
+ decoder_outputs: Seq2SeqModelOutput = self.model(
+ input_ids=input_ids,
+ pixel_values=pixel_values,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = decoder_outputs.last_hidden_state
+ # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+ slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+ logits = self.lm_head(hidden_states[:, slice_indices, :])
+
+ decoder_config = self.config.decoder
+ if decoder_config.final_logit_softcapping is not None:
+ logits = logits / decoder_config.final_logit_softcapping
+ logits = torch.tanh(logits)
+ logits = logits * decoder_config.final_logit_softcapping
+
+ loss = None
+ if labels is not None:
+ # Input has right-shifted so we directly perform masked lm loss
+ loss = self.loss_function(logits, labels, self.vocab_size, **kwargs)
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.decoder_hidden_states,
+ decoder_attentions=decoder_outputs.decoder_attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=decoder_outputs.encoder_last_hidden_state,
+ encoder_hidden_states=decoder_outputs.encoder_hidden_states,
+ encoder_attentions=decoder_outputs.encoder_attentions,
+ )
+
+ def _prepare_cache_for_generation(
+ self,
+ generation_config: GenerationConfig,
+ model_kwargs: dict,
+ generation_mode: GenerationMode,
+ batch_size: int,
+ max_cache_length: int,
+ ) -> bool:
+ """Override cache preparation to support T5Gemma2-specific EncoderDecoder Cache."""
+
+ # Build cache and past_key_values structure first and then override as needed.
+ super()._prepare_cache_for_generation(
+ generation_config,
+ model_kwargs,
+ generation_mode,
+ batch_size,
+ max_cache_length,
+ )
+
+ # If use_cache is False, do not prepare the cache.
+ if generation_config.use_cache is False:
+ return
+
+ cache_implementation = generation_config.cache_implementation
+ if cache_implementation is None:
+ offload_cache = False
+ else:
+ offload_cache = "offloaded" in generation_config.cache_implementation
+
+ # Main change: use full cache for cross-attention.
+ cross_attn_config = copy.deepcopy(self.config.get_text_config(decoder=True))
+
+ # cross-attention does not use sliding window
+ cross_attn_config.sliding_window = None
+ cross_attn_config.layer_types = ["full_attention"] * cross_attn_config.num_hidden_layers
+
+ cross_attn_cache_kwargs = {
+ "config": cross_attn_config,
+ "offloading": offload_cache,
+ }
+
+ past_key_values = model_kwargs.get("past_key_values")
+ if past_key_values is not None:
+ if not isinstance(past_key_values, EncoderDecoderCache):
+ raise ValueError(
+ "The `past_key_values` in `model_kwargs` must be of type `EncoderDecoderCache` for T5Gemma2 model."
+ )
+
+ # Cache already established, no need to re-initialize.
+ if len(past_key_values.is_updated) > 0 and past_key_values.is_updated.get(0):
+ return
+
+ cross_attn_cls = type(past_key_values.cross_attention_cache)
+ if cross_attn_cls == StaticCache:
+ cross_attn_cache_kwargs["max_cache_len"] = model_kwargs["encoder_outputs"][0].shape[1]
+ # Update cross-attention cache only (switch from sliding_window to full).
+ past_key_values.cross_attention_cache = cross_attn_cls(**cross_attn_cache_kwargs)
+ else:
+ # Initialize new cache.
+ model_kwargs["past_key_values"] = EncoderDecoderCache(
+ DynamicCache(
+ **{
+ "config": self.config.get_text_config(decoder=True),
+ "offloading": offload_cache,
+ }
+ ), # self-attention cache
+ DynamicCache(), # cross-attention cache
+ )
+
+ if hasattr(self, "_cache") and self._cache is not None:
+ if not isinstance(self._cache, EncoderDecoderCache):
+ raise ValueError("The internal cache must be of type `EncoderDecoderCache` for T5Gemma2 model.")
+
+ self._cache = model_kwargs["past_key_values"]
+
+
+@auto_docstring
+class T5Gemma2ForSequenceClassification(T5Gemma2PreTrainedModel):
+ def __init__(self, config: T5Gemma2Config):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+ self.hidden_size = config.decoder.hidden_size
+
+ self.model = T5Gemma2Model(config)
+
+ classifier_dropout = getattr(config, "classifier_dropout_rate", 0.1)
+ self.score = T5Gemma2ClassificationHead(self.hidden_size, self.num_labels, classifier_dropout)
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.Tensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> SequenceClassifierOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ if inputs_embeds is not None or decoder_inputs_embeds is not None:
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__}."
+ )
+
+ if input_ids is None:
+ raise ValueError("You have to specify input_ids")
+
+ if decoder_input_ids is None:
+ decoder_input_ids = self.prepare_decoder_input_ids_from_labels(input_ids)
+
+ outputs: Seq2SeqModelOutput = self.model(
+ input_ids,
+ pixel_values=pixel_values,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=False,
+ **kwargs,
+ )
+
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.decoder_hidden_states
+ attentions = outputs.decoder_attentions
+
+ logits = self.score(last_hidden_state)
+
+ batch_size = input_ids.shape[0]
+ # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
+ non_pad_mask = (decoder_input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
+ token_indices = torch.arange(decoder_input_ids.shape[-1], device=logits.device, dtype=torch.int32)
+ last_non_pad_token = (token_indices * non_pad_mask).argmax(-1)
+ last_non_pad_token = torch.clamp(last_non_pad_token, max=decoder_input_ids.shape[-1] - 1)
+
+ pooled_logits = logits[torch.arange(batch_size, device=logits.device), last_non_pad_token]
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits=logits, labels=labels, pooled_logits=pooled_logits, config=self.config)
+
+ return SequenceClassifierOutput(
+ loss=loss,
+ logits=pooled_logits,
+ hidden_states=hidden_states,
+ attentions=attentions,
+ )
+
+
+@auto_docstring
+class T5Gemma2ForTokenClassification(T5Gemma2PreTrainedModel):
+ def __init__(self, config: T5Gemma2Config):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+ self.hidden_size = config.decoder.hidden_size
+
+ self.model = T5Gemma2Model(config)
+
+ classifier_dropout = getattr(config, "classifier_dropout_rate", 0.1)
+ self.score = T5Gemma2ClassificationHead(self.hidden_size, self.num_labels, classifier_dropout)
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.get_input_embeddings()
+
+ def set_input_embeddings(self, value):
+ self.model.set_input_embeddings(value)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.Tensor | None = None,
+ decoder_position_ids: torch.LongTensor | None = None,
+ encoder_outputs: BaseModelOutput | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TokenClassifierOutput:
+ r"""
+ decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
+ Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
+ config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ if inputs_embeds is not None or decoder_inputs_embeds is not None:
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__}."
+ )
+
+ if input_ids is None:
+ raise ValueError("You have to specify input_ids")
+
+ if decoder_input_ids is None:
+ decoder_input_ids = self.prepare_decoder_input_ids_from_labels(input_ids)
+
+ outputs: Seq2SeqModelOutput = self.model(
+ input_ids,
+ pixel_values=pixel_values,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ decoder_position_ids=decoder_position_ids,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=False,
+ **kwargs,
+ )
+ last_hidden_state = outputs.last_hidden_state
+ hidden_states = outputs.decoder_hidden_states
+ attentions = outputs.decoder_attentions
+
+ logits = self.score(last_hidden_state)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits, labels, self.config)
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=hidden_states,
+ attentions=attentions,
+ )
+
+
+__all__ = [
+ "T5Gemma2Config",
+ "T5Gemma2TextConfig",
+ "T5Gemma2EncoderConfig",
+ "T5Gemma2DecoderConfig",
+ "T5Gemma2ForConditionalGeneration",
+ "T5Gemma2Model",
+ "T5Gemma2Encoder",
+ "T5Gemma2PreTrainedModel",
+ "T5Gemma2ForSequenceClassification",
+ "T5Gemma2ForTokenClassification",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/table_transformer/__init__.py b/lib/python3.11/site-packages/transformers/models/table_transformer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ebd1da6fdaeea49c47590e03c86474733265baa
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/table_transformer/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_table_transformer import *
+ from .modeling_table_transformer import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/table_transformer/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/table_transformer/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e306db89c349856e6b37e0f5f7a724ec9d9daccc
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/table_transformer/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/table_transformer/__pycache__/configuration_table_transformer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/table_transformer/__pycache__/configuration_table_transformer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5f9116ca20f1fa54c7506e006bd851dead54db87
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/table_transformer/__pycache__/configuration_table_transformer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/table_transformer/__pycache__/modeling_table_transformer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/table_transformer/__pycache__/modeling_table_transformer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..854d1e456ce6c7ee24b357849b691c0dc21aca4d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/table_transformer/__pycache__/modeling_table_transformer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/table_transformer/configuration_table_transformer.py b/lib/python3.11/site-packages/transformers/models/table_transformer/configuration_table_transformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e844d0309e7ed1efd975f15c496988686506e92
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/table_transformer/configuration_table_transformer.py
@@ -0,0 +1,117 @@
+# Copyright The HuggingFace Inc. 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.
+"""Table Transformer model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import consolidate_backbone_kwargs_to_config
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import AutoConfig
+
+
+@auto_docstring(checkpoint="microsoft/table-transformer-detection")
+@strict
+class TableTransformerConfig(PreTrainedConfig):
+ r"""
+ num_queries (`int`, *optional*, defaults to 100):
+ Number of object queries, i.e. detection slots. This is the maximal number of objects
+ [`TableTransformerModel`] can detect in a single image. For COCO, we recommend 100 queries.
+ auxiliary_loss (`bool`, *optional*, defaults to `False`):
+ Whether auxiliary decoding losses (loss at each decoder layer) are to be used.
+ position_embedding_type (`str`, *optional*, defaults to `"sine"`):
+ Type of position embeddings to be used on top of the image features. One of `"sine"` or `"learned"`.
+ dilation (`bool`, *optional*, defaults to `False`):
+ Whether to replace stride with dilation in the last convolutional block (DC5). Only supported when
+ `use_timm_backbone` = `True`.
+
+ Examples:
+
+ ```python
+ >>> from transformers import TableTransformerModel, TableTransformerConfig
+
+ >>> # Initializing a Table Transformer microsoft/table-transformer-detection style configuration
+ >>> configuration = TableTransformerConfig()
+
+ >>> # Initializing a model from the microsoft/table-transformer-detection style configuration
+ >>> model = TableTransformerModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "table-transformer"
+ sub_configs = {"backbone_config": AutoConfig}
+ keys_to_ignore_at_inference = ["past_key_values"]
+ attribute_map = {
+ "hidden_size": "d_model",
+ "num_attention_heads": "encoder_attention_heads",
+ "num_hidden_layers": "encoder_layers",
+ }
+
+ backbone_config: dict | PreTrainedConfig | None = None
+ num_channels: int = 3
+ num_queries: int = 100
+ encoder_layers: int = 6
+ encoder_ffn_dim: int = 2048
+ encoder_attention_heads: int = 8
+ decoder_layers: int = 6
+ decoder_ffn_dim: int = 2048
+ decoder_attention_heads: int = 8
+ encoder_layerdrop: float | int = 0.0
+ decoder_layerdrop: float | int = 0.0
+ is_encoder_decoder: bool = True
+ activation_function: str = "relu"
+ d_model: int = 256
+ dropout: float | int = 0.1
+ attention_dropout: float | int = 0.0
+ activation_dropout: float | int = 0.0
+ init_std: float = 0.02
+ init_xavier_std: float = 1.0
+ auxiliary_loss: bool = False
+ position_embedding_type: str = "sine"
+ dilation: bool = False
+ class_cost: int = 1
+ bbox_cost: int = 5
+ giou_cost: int = 2
+ mask_loss_coefficient: int = 1
+ dice_loss_coefficient: int = 1
+ bbox_loss_coefficient: int = 5
+ giou_loss_coefficient: int = 2
+ eos_coefficient: float = 0.1
+
+ def __post_init__(self, **kwargs):
+ backbone_kwargs = kwargs.get("backbone_kwargs", {})
+ timm_default_kwargs = {
+ "num_channels": backbone_kwargs.get("num_channels", self.num_channels),
+ "features_only": True,
+ "use_pretrained_backbone": False,
+ "out_indices": backbone_kwargs.get("out_indices", [1, 2, 3, 4]),
+ }
+ if self.dilation:
+ timm_default_kwargs["output_stride"] = backbone_kwargs.get("output_stride", 16)
+
+ self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+ backbone_config=self.backbone_config,
+ default_backbone="resnet50",
+ default_config_type="resnet",
+ default_config_kwargs={"out_features": ["stage4"]},
+ timm_default_kwargs=timm_default_kwargs,
+ **kwargs,
+ )
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["TableTransformerConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/table_transformer/modeling_table_transformer.py b/lib/python3.11/site-packages/transformers/models/table_transformer/modeling_table_transformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a91e4cc60095b30d1595aedc34eb69a1b09ff07
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/table_transformer/modeling_table_transformer.py
@@ -0,0 +1,1308 @@
+# Copyright 2022 Microsoft Research and The HuggingFace Inc. 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.
+"""PyTorch Table Transformer model."""
+
+import math
+from dataclasses import dataclass
+
+import torch
+from torch import Tensor, nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...backbone_utils import load_backbone
+from ...masking_utils import create_bidirectional_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, BaseModelOutputWithCrossAttentions, Seq2SeqModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import (
+ ModelOutput,
+ auto_docstring,
+ logging,
+)
+from .configuration_table_transformer import TableTransformerConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for outputs of the TABLE_TRANSFORMER decoder. This class adds one attribute to BaseModelOutputWithCrossAttentions,
+ namely an optional stack of intermediate decoder activations, i.e. the output of each decoder layer, each of them
+ gone through a layernorm. This is useful when training the model with auxiliary decoding losses.
+ """
+)
+@dataclass
+# Copied from transformers.models.detr.modeling_detr.DetrDecoderOutput with DETR->TABLE_TRANSFORMER,Detr->TableTransformer
+class TableTransformerDecoderOutput(BaseModelOutputWithCrossAttentions):
+ r"""
+ cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` and `config.add_cross_attention=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax,
+ used to compute the weighted average in the cross-attention heads.
+ intermediate_hidden_states (`torch.FloatTensor` of shape `(config.decoder_layers, batch_size, num_queries, hidden_size)`, *optional*, returned when `config.auxiliary_loss=True`):
+ Intermediate decoder activations, i.e. the output of each decoder layer, each of them gone through a
+ layernorm.
+ """
+
+ intermediate_hidden_states: torch.FloatTensor | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for outputs of the TABLE_TRANSFORMER encoder-decoder model. This class adds one attribute to Seq2SeqModelOutput,
+ namely an optional stack of intermediate decoder activations, i.e. the output of each decoder layer, each of them
+ gone through a layernorm. This is useful when training the model with auxiliary decoding losses.
+ """
+)
+@dataclass
+# Copied from transformers.models.detr.modeling_detr.DetrModelOutput with DETR->TABLE_TRANSFORMER,Detr->TableTransformer
+class TableTransformerModelOutput(Seq2SeqModelOutput):
+ r"""
+ last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Sequence of hidden-states at the output of the last layer of the decoder of the model.
+ intermediate_hidden_states (`torch.FloatTensor` of shape `(config.decoder_layers, batch_size, sequence_length, hidden_size)`, *optional*, returned when `config.auxiliary_loss=True`):
+ Intermediate decoder activations, i.e. the output of each decoder layer, each of them gone through a
+ layernorm.
+ """
+
+ intermediate_hidden_states: torch.FloatTensor | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Output type of [`TableTransformerForObjectDetection`].
+ """
+)
+@dataclass
+# Copied from transformers.models.detr.modeling_detr.DetrObjectDetectionOutput with Detr->TableTransformer,DetrImageProcessor->DetrImageProcessor
+class TableTransformerObjectDetectionOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` are provided)):
+ Total loss as a linear combination of a negative log-likehood (cross-entropy) for class prediction and a
+ bounding box loss. The latter is defined as a linear combination of the L1 loss and the generalized
+ scale-invariant IoU loss.
+ loss_dict (`Dict`, *optional*):
+ A dictionary containing the individual losses. Useful for logging.
+ logits (`torch.FloatTensor` of shape `(batch_size, num_queries, num_classes + 1)`):
+ Classification logits (including no-object) for all queries.
+ pred_boxes (`torch.FloatTensor` of shape `(batch_size, num_queries, 4)`):
+ Normalized boxes coordinates for all queries, represented as (center_x, center_y, width, height). These
+ values are normalized in [0, 1], relative to the size of each individual image in the batch (disregarding
+ possible padding). You can use [`~TableTransformerImageProcessor.post_process_object_detection`] to retrieve the
+ unnormalized bounding boxes.
+ auxiliary_outputs (`list[Dict]`, *optional*):
+ Optional, only returned when auxiliary losses are activated (i.e. `config.auxiliary_loss` is set to `True`)
+ and labels are provided. It is a list of dictionaries containing the two above keys (`logits` and
+ `pred_boxes`) for each decoder layer.
+ last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Sequence of hidden-states at the output of the last layer of the decoder of the model.
+ """
+
+ loss: torch.FloatTensor | None = None
+ loss_dict: dict | None = None
+ logits: torch.FloatTensor | None = None
+ pred_boxes: torch.FloatTensor | None = None
+ auxiliary_outputs: list[dict] | None = None
+ last_hidden_state: torch.FloatTensor | None = None
+ decoder_hidden_states: tuple[torch.FloatTensor] | None = None
+ decoder_attentions: tuple[torch.FloatTensor] | None = None
+ cross_attentions: tuple[torch.FloatTensor] | None = None
+ encoder_last_hidden_state: torch.FloatTensor | None = None
+ encoder_hidden_states: tuple[torch.FloatTensor] | None = None
+ encoder_attentions: tuple[torch.FloatTensor] | None = None
+
+
+# Copied from transformers.models.detr.modeling_detr.DetrFrozenBatchNorm2d with Detr->TableTransformer
+class TableTransformerFrozenBatchNorm2d(nn.Module):
+ """
+ BatchNorm2d where the batch statistics and the affine parameters are fixed.
+
+ Copy-paste from torchvision.misc.ops with added eps before rqsrt, without which any other models than
+ torchvision.models.resnet[18,34,50,101] produce nans.
+ """
+
+ def __init__(self, n):
+ super().__init__()
+ self.register_buffer("weight", torch.ones(n))
+ self.register_buffer("bias", torch.zeros(n))
+ self.register_buffer("running_mean", torch.zeros(n))
+ self.register_buffer("running_var", torch.ones(n))
+
+ def _load_from_state_dict(
+ self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+ ):
+ num_batches_tracked_key = prefix + "num_batches_tracked"
+ if num_batches_tracked_key in state_dict:
+ del state_dict[num_batches_tracked_key]
+
+ super()._load_from_state_dict(
+ state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+ )
+
+ def forward(self, x):
+ # move reshapes to the beginning
+ # to make it user-friendly
+ weight = self.weight.reshape(1, -1, 1, 1)
+ bias = self.bias.reshape(1, -1, 1, 1)
+ running_var = self.running_var.reshape(1, -1, 1, 1)
+ running_mean = self.running_mean.reshape(1, -1, 1, 1)
+ epsilon = 1e-5
+ scale = weight * (running_var + epsilon).rsqrt()
+ bias = bias - running_mean * scale
+ return x * scale + bias
+
+
+# Copied from transformers.models.detr.modeling_detr.replace_batch_norm with Detr->TableTransformer
+def replace_batch_norm(model):
+ r"""
+ Recursively replace all `torch.nn.BatchNorm2d` with `TableTransformerFrozenBatchNorm2d`.
+
+ Args:
+ model (torch.nn.Module):
+ input model
+ """
+ for name, module in model.named_children():
+ if isinstance(module, nn.BatchNorm2d):
+ new_module = TableTransformerFrozenBatchNorm2d(module.num_features)
+
+ if module.weight.device != torch.device("meta"):
+ new_module.weight.copy_(module.weight)
+ new_module.bias.copy_(module.bias)
+ new_module.running_mean.copy_(module.running_mean)
+ new_module.running_var.copy_(module.running_var)
+
+ model._modules[name] = new_module
+
+ if len(list(module.children())) > 0:
+ replace_batch_norm(module)
+
+
+# TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrConvEncoder with Detr->TableTransformer
+class TableTransformerConvEncoder(nn.Module):
+ """
+ Convolutional backbone, using either the AutoBackbone API or one from the timm library.
+
+ nn.BatchNorm2d layers are replaced by TableTransformerFrozenBatchNorm2d as defined above.
+
+ """
+
+ def __init__(self, config):
+ super().__init__()
+
+ self.config = config
+
+ backbone = load_backbone(config)
+ self.intermediate_channel_sizes = backbone.channels
+
+ # replace batch norm by frozen batch norm
+ with torch.no_grad():
+ replace_batch_norm(backbone)
+
+ # We used to load with timm library directly instead of the AutoBackbone API
+ # so we need to unwrap the `backbone._backbone` module to load weights without mismatch
+ is_timm_model = False
+ if hasattr(backbone, "_backbone"):
+ backbone = backbone._backbone
+ is_timm_model = True
+ self.model = backbone
+
+ backbone_model_type = config.backbone_config.model_type
+ if "resnet" in backbone_model_type:
+ for name, parameter in self.model.named_parameters():
+ if is_timm_model:
+ if "layer2" not in name and "layer3" not in name and "layer4" not in name:
+ parameter.requires_grad_(False)
+ else:
+ if "stage.1" not in name and "stage.2" not in name and "stage.3" not in name:
+ parameter.requires_grad_(False)
+
+ def forward(self, pixel_values: torch.Tensor, pixel_mask: torch.Tensor):
+ # send pixel_values through the model to get list of feature maps
+ features = self.model(pixel_values)
+ if isinstance(features, dict):
+ features = features.feature_maps
+
+ out = []
+ for feature_map in features:
+ # downsample pixel_mask to match shape of corresponding feature_map
+ mask = nn.functional.interpolate(pixel_mask[None].float(), size=feature_map.shape[-2:]).to(torch.bool)[0]
+ out.append((feature_map, mask))
+ return out
+
+
+# TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrConvModel with Detr->TableTransformer
+class TableTransformerConvModel(nn.Module):
+ """
+ This module adds 2D position embeddings to all intermediate feature maps of the convolutional encoder.
+ """
+
+ def __init__(self, conv_encoder, position_embedding):
+ super().__init__()
+ self.conv_encoder = conv_encoder
+ self.position_embedding = position_embedding
+
+ def forward(self, pixel_values, pixel_mask):
+ # send pixel_values and pixel_mask through backbone to get list of (feature_map, pixel_mask) tuples
+ out = self.conv_encoder(pixel_values, pixel_mask)
+ pos = []
+ for feature_map, mask in out:
+ # position encoding
+ pos.append(self.position_embedding(feature_map, mask).to(feature_map.dtype))
+
+ return out, pos
+
+
+# TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrSinePositionEmbedding with Detr->TableTransformer
+class TableTransformerSinePositionEmbedding(nn.Module):
+ """
+ This is a more standard version of the position embedding, very similar to the one used by the Attention is all you
+ need paper, generalized to work on images.
+ """
+
+ def __init__(self, embedding_dim=64, temperature=10000, normalize=False, scale=None):
+ super().__init__()
+ self.embedding_dim = embedding_dim
+ self.temperature = temperature
+ self.normalize = normalize
+ if scale is not None and normalize is False:
+ raise ValueError("normalize should be True if scale is passed")
+ if scale is None:
+ scale = 2 * math.pi
+ self.scale = scale
+
+ def forward(self, pixel_values, pixel_mask):
+ if pixel_mask is None:
+ raise ValueError("No pixel mask provided")
+ y_embed = pixel_mask.cumsum(1, dtype=torch.float32)
+ x_embed = pixel_mask.cumsum(2, dtype=torch.float32)
+ if self.normalize:
+ y_embed = y_embed / (y_embed[:, -1:, :] + 1e-6) * self.scale
+ x_embed = x_embed / (x_embed[:, :, -1:] + 1e-6) * self.scale
+
+ dim_t = torch.arange(self.embedding_dim, dtype=torch.int64, device=pixel_values.device).float()
+ dim_t = self.temperature ** (2 * torch.div(dim_t, 2, rounding_mode="floor") / self.embedding_dim)
+
+ pos_x = x_embed[:, :, :, None] / dim_t
+ pos_y = y_embed[:, :, :, None] / dim_t
+ pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
+ pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
+ pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
+ return pos
+
+
+# TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrLearnedPositionEmbedding with Detr->TableTransformer
+class TableTransformerLearnedPositionEmbedding(nn.Module):
+ """
+ This module learns positional embeddings up to a fixed maximum size.
+ """
+
+ def __init__(self, embedding_dim=256):
+ super().__init__()
+ self.row_embeddings = nn.Embedding(50, embedding_dim)
+ self.column_embeddings = nn.Embedding(50, embedding_dim)
+
+ def forward(self, pixel_values, pixel_mask=None):
+ height, width = pixel_values.shape[-2:]
+ width_values = torch.arange(width, device=pixel_values.device)
+ height_values = torch.arange(height, device=pixel_values.device)
+ x_emb = self.column_embeddings(width_values)
+ y_emb = self.row_embeddings(height_values)
+ pos = torch.cat([x_emb.unsqueeze(0).repeat(height, 1, 1), y_emb.unsqueeze(1).repeat(1, width, 1)], dim=-1)
+ pos = pos.permute(2, 0, 1)
+ pos = pos.unsqueeze(0)
+ pos = pos.repeat(pixel_values.shape[0], 1, 1, 1)
+ return pos
+
+
+# TODO: use modular - Copied from transformers.models.detr.modeling_detr.build_position_encoding with Detr->TableTransformer
+def build_position_encoding(config):
+ n_steps = config.d_model // 2
+ if config.position_embedding_type == "sine":
+ # TODO find a better way of exposing other arguments
+ position_embedding = TableTransformerSinePositionEmbedding(n_steps, normalize=True)
+ elif config.position_embedding_type == "learned":
+ position_embedding = TableTransformerLearnedPositionEmbedding(n_steps)
+ else:
+ raise ValueError(f"Not supported {config.position_embedding_type}")
+
+ return position_embedding
+
+
+# TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrAttention with DETR->TABLE_TRANSFORMER,Detr->TableTransformer
+class TableTransformerAttention(nn.Module):
+ """
+ Multi-headed attention from 'Attention Is All You Need' paper.
+
+ Here, we add position embeddings to the queries and keys (as explained in the TABLE_TRANSFORMER paper).
+ """
+
+ def __init__(
+ self,
+ embed_dim: int,
+ num_heads: int,
+ dropout: float = 0.0,
+ bias: bool = True,
+ ):
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.num_heads = num_heads
+ self.dropout = dropout
+ self.head_dim = embed_dim // num_heads
+ if self.head_dim * num_heads != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+ f" {num_heads})."
+ )
+ self.scaling = self.head_dim**-0.5
+
+ self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+ def _shape(self, tensor: torch.Tensor, seq_len: int, batch_size: int):
+ return tensor.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
+
+ def with_pos_embed(self, tensor: torch.Tensor, object_queries: Tensor | None):
+ return tensor if object_queries is None else tensor + object_queries
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ object_queries: torch.Tensor | None = None,
+ key_value_states: torch.Tensor | None = None,
+ spatial_position_embeddings: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ """Input shape: Batch x Time x Channel"""
+ # if key_value_states are provided this layer is used as a cross-attention layer
+ # for the decoder
+ is_cross_attention = key_value_states is not None
+ batch_size, target_len, embed_dim = hidden_states.size()
+
+ # add position embeddings to the hidden states before projecting to queries and keys
+ if object_queries is not None:
+ hidden_states_original = hidden_states
+ hidden_states = self.with_pos_embed(hidden_states, object_queries)
+
+ # add key-value position embeddings to the key value states
+ if spatial_position_embeddings is not None:
+ key_value_states_original = key_value_states
+ key_value_states = self.with_pos_embed(key_value_states, spatial_position_embeddings)
+
+ # get query proj
+ query_states = self.q_proj(hidden_states) * self.scaling
+ # get key, value proj
+ if is_cross_attention:
+ # cross_attentions
+ key_states = self._shape(self.k_proj(key_value_states), -1, batch_size)
+ value_states = self._shape(self.v_proj(key_value_states_original), -1, batch_size)
+ else:
+ # self_attention
+ key_states = self._shape(self.k_proj(hidden_states), -1, batch_size)
+ value_states = self._shape(self.v_proj(hidden_states_original), -1, batch_size)
+
+ proj_shape = (batch_size * self.num_heads, -1, self.head_dim)
+ query_states = self._shape(query_states, target_len, batch_size).view(*proj_shape)
+ key_states = key_states.view(*proj_shape)
+ value_states = value_states.view(*proj_shape)
+
+ source_len = key_states.size(1)
+
+ attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))
+
+ if attn_weights.size() != (batch_size * self.num_heads, target_len, source_len):
+ raise ValueError(
+ f"Attention weights should be of size {(batch_size * self.num_heads, target_len, source_len)}, but is"
+ f" {attn_weights.size()}"
+ )
+
+ if attention_mask is not None:
+ if attention_mask.size() != (batch_size, 1, target_len, source_len):
+ raise ValueError(
+ f"Attention mask should be of size {(batch_size, 1, target_len, source_len)}, but is"
+ f" {attention_mask.size()}"
+ )
+ if attention_mask.dtype == torch.bool:
+ attention_mask = torch.zeros_like(attention_mask, dtype=attn_weights.dtype).masked_fill_(
+ attention_mask, -torch.inf
+ )
+ attn_weights = attn_weights.view(batch_size, self.num_heads, target_len, source_len) + attention_mask
+ attn_weights = attn_weights.view(batch_size * self.num_heads, target_len, source_len)
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+
+ if output_attentions:
+ # this operation is a bit awkward, but it's required to
+ # make sure that attn_weights keeps its gradient.
+ # In order to do so, attn_weights have to reshaped
+ # twice and have to be reused in the following
+ attn_weights_reshaped = attn_weights.view(batch_size, self.num_heads, target_len, source_len)
+ attn_weights = attn_weights_reshaped.view(batch_size * self.num_heads, target_len, source_len)
+ else:
+ attn_weights_reshaped = None
+
+ attn_probs = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+ attn_output = torch.bmm(attn_probs, value_states)
+
+ if attn_output.size() != (batch_size * self.num_heads, target_len, self.head_dim):
+ raise ValueError(
+ f"`attn_output` should be of size {(batch_size, self.num_heads, target_len, self.head_dim)}, but is"
+ f" {attn_output.size()}"
+ )
+
+ attn_output = attn_output.view(batch_size, self.num_heads, target_len, self.head_dim)
+ attn_output = attn_output.transpose(1, 2)
+ attn_output = attn_output.reshape(batch_size, target_len, embed_dim)
+
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights_reshaped
+
+
+class TableTransformerEncoderLayer(nn.Module):
+ # TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrEncoderLayer.__init__ with Detr->TableTransformer
+ def __init__(self, config: TableTransformerConfig):
+ super().__init__()
+ self.embed_dim = config.d_model
+ self.self_attn = TableTransformerAttention(
+ embed_dim=self.embed_dim,
+ num_heads=config.encoder_attention_heads,
+ dropout=config.attention_dropout,
+ )
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.dropout = config.dropout
+ self.activation_fn = ACT2FN[config.activation_function]
+ self.activation_dropout = config.activation_dropout
+ self.fc1 = nn.Linear(self.embed_dim, config.encoder_ffn_dim)
+ self.fc2 = nn.Linear(config.encoder_ffn_dim, self.embed_dim)
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ object_queries: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ ):
+ """
+ Args:
+ hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+ attention_mask (`torch.FloatTensor`): attention mask of size
+ `(batch, 1, target_len, source_len)` where padding elements are indicated by very large negative
+ values.
+ object_queries (`torch.FloatTensor`, *optional*): object queries, to be added to hidden_states.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ """
+ residual = hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+
+ hidden_states, attn_weights = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ object_queries=object_queries,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+ hidden_states = residual + hidden_states
+
+ if self.training:
+ if not torch.isfinite(hidden_states).all():
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (attn_weights,)
+
+ return outputs
+
+
+class TableTransformerDecoderLayer(GradientCheckpointingLayer):
+ # TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrDecoderLayer.__init__ with Detr->TableTransformer
+ def __init__(self, config: TableTransformerConfig):
+ super().__init__()
+ self.embed_dim = config.d_model
+
+ self.self_attn = TableTransformerAttention(
+ embed_dim=self.embed_dim,
+ num_heads=config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ )
+ self.dropout = config.dropout
+ self.activation_fn = ACT2FN[config.activation_function]
+ self.activation_dropout = config.activation_dropout
+
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.encoder_attn = TableTransformerAttention(
+ self.embed_dim,
+ config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ )
+ self.encoder_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.fc1 = nn.Linear(self.embed_dim, config.decoder_ffn_dim)
+ self.fc2 = nn.Linear(config.decoder_ffn_dim, self.embed_dim)
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ object_queries: torch.Tensor | None = None,
+ query_position_embeddings: torch.Tensor | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = False,
+ ):
+ """
+ Args:
+ hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+ attention_mask (`torch.FloatTensor`): attention mask of size
+ `(batch, 1, target_len, source_len)` where padding elements are indicated by very large negative
+ values.
+ object_queries (`torch.FloatTensor`, *optional*):
+ object queries that are added to the queries and keys
+ in the cross-attention layer.
+ query_position_embeddings (`torch.FloatTensor`, *optional*):
+ object queries that are added to the queries and keys
+ in the self-attention layer.
+ encoder_hidden_states (`torch.FloatTensor`):
+ cross attention input to the layer of shape `(batch, seq_len, embed_dim)`
+ encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size
+ `(batch, 1, target_len, source_len)` where padding elements are indicated by very large negative
+ values.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ """
+ residual = hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+
+ # Self Attention
+ hidden_states, self_attn_weights = self.self_attn(
+ hidden_states=hidden_states,
+ object_queries=query_position_embeddings,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.encoder_attn_layer_norm(hidden_states)
+
+ # Cross-Attention Block
+ cross_attn_weights = None
+ if encoder_hidden_states is not None:
+ hidden_states, cross_attn_weights = self.encoder_attn(
+ hidden_states=hidden_states,
+ object_queries=query_position_embeddings,
+ key_value_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ spatial_position_embeddings=object_queries,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ # Fully Connected
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (self_attn_weights, cross_attn_weights)
+
+ return outputs
+
+
+@auto_docstring
+class TableTransformerPreTrainedModel(PreTrainedModel):
+ config: TableTransformerConfig
+ base_model_prefix = "model"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ _no_split_modules = [
+ r"TableTransformerConvEncoder",
+ r"TableTransformerEncoderLayer",
+ r"TableTransformerDecoderLayer",
+ ]
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ std = self.config.init_std
+
+ if isinstance(module, TableTransformerLearnedPositionEmbedding):
+ init.uniform_(module.row_embeddings.weight)
+ init.uniform_(module.column_embeddings.weight)
+ if isinstance(module, (nn.Linear, nn.Conv2d)):
+ init.normal_(module.weight, mean=0.0, std=std)
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, nn.Embedding):
+ init.normal_(module.weight, mean=0.0, std=std)
+ # Here we need the check explicitly, as we slice the weight in the `zeros_` call, so it looses the flag
+ if module.padding_idx is not None and not getattr(module.weight, "_is_hf_initialized", False):
+ init.zeros_(module.weight[module.padding_idx])
+
+
+class TableTransformerEncoder(TableTransformerPreTrainedModel):
+ """
+ Transformer encoder consisting of *config.encoder_layers* self attention layers. Each layer is a
+ [`TableTransformerEncoderLayer`].
+
+ The encoder updates the flattened feature map through multiple self-attention layers.
+
+ Small tweak for Table Transformer:
+
+ - object_queries are added to the forward pass.
+
+ Args:
+ config: TableTransformerConfig
+ """
+
+ def __init__(self, config: TableTransformerConfig):
+ super().__init__(config)
+
+ self.dropout = config.dropout
+ self.layerdrop = config.encoder_layerdrop
+
+ self.layers = nn.ModuleList([TableTransformerEncoderLayer(config) for _ in range(config.encoder_layers)])
+
+ self.layernorm = nn.LayerNorm(config.d_model)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ inputs_embeds=None,
+ attention_mask=None,
+ object_queries=None,
+ output_attentions=None,
+ output_hidden_states=None,
+ return_dict=None,
+ **kwargs,
+ ):
+ r"""
+ Args:
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Flattened feature map (output of the backbone + projection layer) that is passed to the encoder.
+
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding pixel features. Mask values selected in `[0, 1]`:
+
+ - 1 for pixel features that are real (i.e. **not masked**),
+ - 0 for pixel features that are padding (i.e. **masked**).
+
+ [What are attention masks?](../glossary#attention-mask)
+
+ object_queries (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Position embeddings that are added to the queries and keys in each self-attention layer.
+
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+ for more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ hidden_states = inputs_embeds
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+ # expand attention_mask
+ if attention_mask is not None:
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ )
+
+ encoder_states = () if output_hidden_states else None
+ all_attentions = () if output_attentions else None
+ for encoder_layer in self.layers:
+ if output_hidden_states:
+ encoder_states = encoder_states + (hidden_states,)
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ to_drop = False
+ if self.training:
+ dropout_probability = torch.rand([])
+ if dropout_probability < self.layerdrop: # skip the layer
+ to_drop = True
+
+ if to_drop:
+ layer_outputs = (None, None)
+ else:
+ # we add object_queries as extra input to the encoder_layer
+ layer_outputs = encoder_layer(
+ hidden_states,
+ attention_mask,
+ object_queries=object_queries,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = layer_outputs[0]
+
+ if output_attentions:
+ all_attentions = all_attentions + (layer_outputs[1],)
+
+ if output_hidden_states:
+ encoder_states = encoder_states + (hidden_states,)
+
+ hidden_states = self.layernorm(hidden_states)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, encoder_states, all_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states, hidden_states=encoder_states, attentions=all_attentions
+ )
+
+
+# TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrDecoder with DETR->TABLE_TRANSFORMER,Detr->TableTransformer
+class TableTransformerDecoder(TableTransformerPreTrainedModel):
+ """
+ Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`TableTransformerDecoderLayer`].
+
+ The decoder updates the query embeddings through multiple self-attention and cross-attention layers.
+
+ Some small tweaks for TABLE_TRANSFORMER:
+
+ - object_queries and query_position_embeddings are added to the forward pass.
+ - if self.config.auxiliary_loss is set to True, also returns a stack of activations from all decoding layers.
+
+ Args:
+ config: TableTransformerConfig
+ """
+
+ def __init__(self, config: TableTransformerConfig):
+ super().__init__(config)
+ self.dropout = config.dropout
+ self.layerdrop = config.decoder_layerdrop
+
+ self.layers = nn.ModuleList([TableTransformerDecoderLayer(config) for _ in range(config.decoder_layers)])
+ # in TABLE_TRANSFORMER, the decoder uses layernorm after the last decoder layer output
+ self.layernorm = nn.LayerNorm(config.d_model)
+
+ self.gradient_checkpointing = False
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ inputs_embeds=None,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ object_queries=None,
+ query_position_embeddings=None,
+ output_attentions=None,
+ output_hidden_states=None,
+ return_dict=None,
+ **kwargs,
+ ):
+ r"""
+ Args:
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ The query embeddings that are passed into the decoder.
+
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on certain queries. Mask values selected in `[0, 1]`:
+
+ - 1 for queries that are **not masked**,
+ - 0 for queries that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*):
+ Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
+ of the decoder.
+ encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, encoder_sequence_length)`, *optional*):
+ Mask to avoid performing cross-attention on padding pixel_values of the encoder. Mask values selected
+ in `[0, 1]`:
+
+ - 1 for pixels that are real (i.e. **not masked**),
+ - 0 for pixels that are padding (i.e. **masked**).
+
+ object_queries (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Object queries that are added to the queries and keys in each cross-attention layer.
+ query_position_embeddings (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`):
+ , *optional*): Position embeddings that are added to the values and keys in each self-attention layer.
+
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+ for more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if inputs_embeds is not None:
+ hidden_states = inputs_embeds
+
+ if attention_mask is not None:
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ )
+
+ # expand encoder attention mask
+ if encoder_hidden_states is not None and encoder_attention_mask is not None:
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+
+ # optional intermediate hidden states
+ intermediate = () if self.config.auxiliary_loss else None
+
+ # decoder layers
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attns = () if output_attentions else None
+ all_cross_attentions = () if (output_attentions and encoder_hidden_states is not None) else None
+
+ for idx, decoder_layer in enumerate(self.layers):
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+ if self.training:
+ dropout_probability = torch.rand([])
+ if dropout_probability < self.layerdrop:
+ continue
+
+ layer_outputs = decoder_layer(
+ hidden_states,
+ attention_mask,
+ object_queries,
+ query_position_embeddings,
+ encoder_hidden_states, # as a positional argument for gradient checkpointing
+ encoder_attention_mask=encoder_attention_mask,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = layer_outputs[0]
+
+ if self.config.auxiliary_loss:
+ hidden_states = self.layernorm(hidden_states)
+ intermediate += (hidden_states,)
+
+ if output_attentions:
+ all_self_attns += (layer_outputs[1],)
+
+ if encoder_hidden_states is not None:
+ all_cross_attentions += (layer_outputs[2],)
+
+ # finally, apply layernorm
+ hidden_states = self.layernorm(hidden_states)
+
+ # add hidden states from the last decoder layer
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+
+ # stack intermediate decoder activations
+ if self.config.auxiliary_loss:
+ intermediate = torch.stack(intermediate)
+
+ if not return_dict:
+ return tuple(
+ v
+ for v in [hidden_states, all_hidden_states, all_self_attns, all_cross_attentions, intermediate]
+ if v is not None
+ )
+ return TableTransformerDecoderOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attns,
+ cross_attentions=all_cross_attentions,
+ intermediate_hidden_states=intermediate,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ The bare Table Transformer Model (consisting of a backbone and encoder-decoder Transformer) outputting raw
+ hidden-states without any specific head on top.
+ """
+)
+class TableTransformerModel(TableTransformerPreTrainedModel):
+ # TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrModel.__init__ with Detr->TableTransformer
+ def __init__(self, config: TableTransformerConfig):
+ super().__init__(config)
+
+ # Create backbone + positional encoding
+ backbone = TableTransformerConvEncoder(config)
+ object_queries = build_position_encoding(config)
+ self.backbone = TableTransformerConvModel(backbone, object_queries)
+
+ # Create projection layer
+ self.input_projection = nn.Conv2d(backbone.intermediate_channel_sizes[-1], config.d_model, kernel_size=1)
+
+ self.query_position_embeddings = nn.Embedding(config.num_queries, config.d_model)
+
+ self.encoder = TableTransformerEncoder(config)
+ self.decoder = TableTransformerDecoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def freeze_backbone(self):
+ for name, param in self.backbone.conv_encoder.model.named_parameters():
+ param.requires_grad_(False)
+
+ def unfreeze_backbone(self):
+ for name, param in self.backbone.conv_encoder.model.named_parameters():
+ param.requires_grad_(True)
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ pixel_mask: torch.FloatTensor | None = None,
+ decoder_attention_mask: torch.FloatTensor | None = None,
+ encoder_outputs: torch.FloatTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | TableTransformerModelOutput:
+ r"""
+ decoder_attention_mask (`torch.FloatTensor` of shape `(batch_size, num_queries)`, *optional*):
+ Not used by default. Can be used to mask object queries.
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing the flattened feature map (output of the backbone + projection layer), you
+ can choose to directly pass a flattened representation of an image.
+ decoder_inputs_embeds (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`, *optional*):
+ Optionally, instead of initializing the queries with a tensor of zeros, you can choose to directly pass an
+ embedded representation.
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, TableTransformerModel
+ >>> from huggingface_hub import hf_hub_download
+ >>> from PIL import Image
+
+ >>> file_path = hf_hub_download(repo_id="nielsr/example-pdf", repo_type="dataset", filename="example_pdf.png")
+ >>> image = Image.open(file_path).convert("RGB")
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("microsoft/table-transformer-detection")
+ >>> model = TableTransformerModel.from_pretrained("microsoft/table-transformer-detection")
+
+ >>> # prepare image for the model
+ >>> inputs = image_processor(images=image, return_tensors="pt")
+
+ >>> # forward pass
+ >>> outputs = model(**inputs)
+
+ >>> # the last hidden states are the final query embeddings of the Transformer decoder
+ >>> # these are of shape (batch_size, num_queries, hidden_size)
+ >>> last_hidden_states = outputs.last_hidden_state
+ >>> list(last_hidden_states.shape)
+ [1, 15, 256]
+ ```"""
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ batch_size, num_channels, height, width = pixel_values.shape
+ device = pixel_values.device
+
+ if pixel_mask is None:
+ pixel_mask = torch.ones(((batch_size, height, width)), device=device)
+
+ # First, sent pixel_values + pixel_mask through Backbone to obtain the features
+ # pixel_values should be of shape (batch_size, num_channels, height, width)
+ # pixel_mask should be of shape (batch_size, height, width)
+ features, position_embeddings_list = self.backbone(pixel_values, pixel_mask)
+
+ # get final feature map and downsampled mask
+ feature_map, mask = features[-1]
+
+ if mask is None:
+ raise ValueError("Backbone does not return downsampled pixel mask")
+
+ # Second, apply 1x1 convolution to reduce the channel dimension to d_model (256 by default)
+ projected_feature_map = self.input_projection(feature_map)
+
+ # Third, flatten the feature map + object queries of shape NxCxHxW to NxCxHW, and permute it to NxHWxC
+ # In other words, turn their shape into (batch_size, sequence_length, hidden_size)
+ flattened_features = projected_feature_map.flatten(2).permute(0, 2, 1)
+ object_queries = position_embeddings_list[-1].flatten(2).permute(0, 2, 1)
+
+ flattened_mask = mask.flatten(1)
+
+ # Fourth, sent flattened_features + flattened_mask + object queries through encoder
+ # flattened_features is a Tensor of shape (batch_size, height*width, hidden_size)
+ # flattened_mask is a Tensor of shape (batch_size, height*width)
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ inputs_embeds=flattened_features,
+ attention_mask=flattened_mask,
+ object_queries=object_queries,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ # If the user passed a tuple for encoder_outputs, we wrap it in a BaseModelOutput when return_dict=True
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ # Fifth, sent query embeddings + object queries through the decoder (which is conditioned on the encoder output)
+ query_position_embeddings = self.query_position_embeddings.weight.unsqueeze(0).repeat(batch_size, 1, 1)
+ queries = torch.zeros_like(query_position_embeddings)
+
+ # decoder outputs consists of (dec_features, dec_hidden, dec_attn)
+ decoder_outputs = self.decoder(
+ inputs_embeds=queries,
+ attention_mask=None,
+ object_queries=object_queries,
+ query_position_embeddings=query_position_embeddings,
+ encoder_hidden_states=encoder_outputs[0],
+ encoder_attention_mask=flattened_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if not return_dict:
+ return decoder_outputs + encoder_outputs
+
+ return TableTransformerModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ intermediate_hidden_states=decoder_outputs.intermediate_hidden_states,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Table Transformer Model (consisting of a backbone and encoder-decoder Transformer) with object detection heads on
+ top, for tasks such as COCO detection.
+ """
+)
+class TableTransformerForObjectDetection(TableTransformerPreTrainedModel):
+ # TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrForObjectDetection.__init__ with Detr->TableTransformer
+ def __init__(self, config: TableTransformerConfig):
+ super().__init__(config)
+
+ # DETR encoder-decoder model
+ self.model = TableTransformerModel(config)
+
+ # Object detection heads
+ self.class_labels_classifier = nn.Linear(
+ config.d_model, config.num_labels + 1
+ ) # We add one for the "no object" class
+ self.bbox_predictor = TableTransformerMLPPredictionHead(
+ input_dim=config.d_model, hidden_dim=config.d_model, output_dim=4, num_layers=3
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ pixel_mask: torch.FloatTensor | None = None,
+ decoder_attention_mask: torch.FloatTensor | None = None,
+ encoder_outputs: torch.FloatTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: list[dict] | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | TableTransformerObjectDetectionOutput:
+ r"""
+ decoder_attention_mask (`torch.FloatTensor` of shape `(batch_size, num_queries)`, *optional*):
+ Not used by default. Can be used to mask object queries.
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing the flattened feature map (output of the backbone + projection layer), you
+ can choose to directly pass a flattened representation of an image.
+ decoder_inputs_embeds (`torch.FloatTensor` of shape `(batch_size, num_queries, hidden_size)`, *optional*):
+ Optionally, instead of initializing the queries with a tensor of zeros, you can choose to directly pass an
+ embedded representation.
+ labels (`list[Dict]` of len `(batch_size,)`, *optional*):
+ Labels for computing the bipartite matching loss. List of dicts, each dictionary containing at least the
+ following 2 keys: 'class_labels' and 'boxes' (the class labels and bounding boxes of an image in the batch
+ respectively). The class labels themselves should be a `torch.LongTensor` of len `(number of bounding boxes
+ in the image,)` and the boxes a `torch.FloatTensor` of shape `(number of bounding boxes in the image, 4)`.
+
+ Examples:
+
+ ```python
+ >>> from huggingface_hub import hf_hub_download
+ >>> from transformers import AutoImageProcessor, TableTransformerForObjectDetection
+ >>> import torch
+ >>> from PIL import Image
+
+ >>> file_path = hf_hub_download(repo_id="nielsr/example-pdf", repo_type="dataset", filename="example_pdf.png")
+ >>> image = Image.open(file_path).convert("RGB")
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("microsoft/table-transformer-detection")
+ >>> model = TableTransformerForObjectDetection.from_pretrained("microsoft/table-transformer-detection")
+
+ >>> inputs = image_processor(images=image, return_tensors="pt")
+ >>> outputs = model(**inputs)
+
+ >>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
+ >>> target_sizes = torch.tensor([image.size[::-1]])
+ >>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[
+ ... 0
+ ... ]
+
+ >>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+ ... box = [round(i, 2) for i in box.tolist()]
+ ... print(
+ ... f"Detected {model.config.id2label[label.item()]} with confidence "
+ ... f"{round(score.item(), 3)} at location {box}"
+ ... )
+ Detected table with confidence 1.0 at location [202.1, 210.59, 1119.22, 385.09]
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # First, sent images through TABLE_TRANSFORMER base model to obtain encoder + decoder outputs
+ outputs = self.model(
+ pixel_values,
+ pixel_mask=pixel_mask,
+ decoder_attention_mask=decoder_attention_mask,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = outputs[0]
+
+ # class logits + predicted bounding boxes
+ logits = self.class_labels_classifier(sequence_output)
+ pred_boxes = self.bbox_predictor(sequence_output).sigmoid()
+
+ loss, loss_dict, auxiliary_outputs = None, None, None
+ if labels is not None:
+ outputs_class, outputs_coord = None, None
+ if self.config.auxiliary_loss:
+ intermediate = outputs.intermediate_hidden_states if return_dict else outputs[4]
+ outputs_class = self.class_labels_classifier(intermediate)
+ outputs_coord = self.bbox_predictor(intermediate).sigmoid()
+ loss, loss_dict, auxiliary_outputs = self.loss_function(
+ logits, labels, self.device, pred_boxes, self.config, outputs_class, outputs_coord
+ )
+
+ if not return_dict:
+ if auxiliary_outputs is not None:
+ output = (logits, pred_boxes) + auxiliary_outputs + outputs
+ else:
+ output = (logits, pred_boxes) + outputs
+ return ((loss, loss_dict) + output) if loss is not None else output
+
+ return TableTransformerObjectDetectionOutput(
+ loss=loss,
+ loss_dict=loss_dict,
+ logits=logits,
+ pred_boxes=pred_boxes,
+ auxiliary_outputs=auxiliary_outputs,
+ last_hidden_state=outputs.last_hidden_state,
+ decoder_hidden_states=outputs.decoder_hidden_states,
+ decoder_attentions=outputs.decoder_attentions,
+ cross_attentions=outputs.cross_attentions,
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+ encoder_hidden_states=outputs.encoder_hidden_states,
+ encoder_attentions=outputs.encoder_attentions,
+ )
+
+
+# TODO: use modular - Copied from transformers.models.detr.modeling_detr.DetrMLPPredictionHead with Detr->TableTransformer,detr->table_transformer
+class TableTransformerMLPPredictionHead(nn.Module):
+ """
+ Very simple multi-layer perceptron (MLP, also called FFN), used to predict the normalized center coordinates,
+ height and width of a bounding box w.r.t. an image.
+
+ Copied from https://github.com/facebookresearch/table_transformer/blob/master/models/table_transformer.py
+
+ """
+
+ def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
+ super().__init__()
+ self.num_layers = num_layers
+ h = [hidden_dim] * (num_layers - 1)
+ self.layers = nn.ModuleList(nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]))
+
+ def forward(self, x):
+ for i, layer in enumerate(self.layers):
+ x = nn.functional.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
+ return x
+
+
+__all__ = ["TableTransformerForObjectDetection", "TableTransformerModel", "TableTransformerPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/tapas/__init__.py b/lib/python3.11/site-packages/transformers/models/tapas/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d85329883381e5e889f2c066fa4b24bb44acf09a
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tapas/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2024 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_tapas import *
+ from .modeling_tapas import *
+ from .tokenization_tapas import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/tapas/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/tapas/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eaf270b71ab36df80e7232217296e9059695a2c6
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/tapas/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/tapas/__pycache__/configuration_tapas.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/tapas/__pycache__/configuration_tapas.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f550cb046ebe8d99f38aee07e86c2ce058b5765
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/tapas/__pycache__/configuration_tapas.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/tapas/configuration_tapas.py b/lib/python3.11/site-packages/transformers/models/tapas/configuration_tapas.py
new file mode 100644
index 0000000000000000000000000000000000000000..91b4c49669b24007308c59e1bec18168f4bb34a9
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tapas/configuration_tapas.py
@@ -0,0 +1,155 @@
+# Copyright 2020 Google Research and 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.
+"""
+TAPAS configuration. Based on the BERT configuration with added parameters.
+
+Hyperparameters are taken from run_task_main.py and hparam_utils.py of the original implementation. URLS:
+
+- https://github.com/google-research/tapas/blob/master/tapas/run_task_main.py
+- https://github.com/google-research/tapas/blob/master/tapas/utils/hparam_utils.py
+
+"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="google/tapas-base-finetuned-sqa")
+@strict
+class TapasConfig(PreTrainedConfig):
+ r"""
+ type_vocab_sizes (`list[int]`, *optional*, defaults to `[3, 256, 256, 2, 256, 256, 10]`):
+ The vocabulary sizes of the `token_type_ids` passed when calling [`TapasModel`].
+ positive_label_weight (`float`, *optional*, defaults to 10.0):
+ Weight for positive labels.
+ num_aggregation_labels (`int`, *optional*, defaults to 0):
+ The number of aggregation operators to predict.
+ aggregation_loss_weight (`float`, *optional*, defaults to 1.0):
+ Importance weight for the aggregation loss.
+ use_answer_as_supervision (`bool`, *optional*):
+ Whether to use the answer as the only supervision for aggregation examples.
+ answer_loss_importance (`float`, *optional*, defaults to 1.0):
+ Importance weight for the regression loss.
+ use_normalized_answer_loss (`bool`, *optional*, defaults to `False`):
+ Whether to normalize the answer loss by the maximum of the predicted and expected value.
+ huber_loss_delta (`float`, *optional*):
+ Delta parameter used to calculate the regression loss.
+ temperature (`float`, *optional*, defaults to 1.0):
+ Value used to control (OR change) the skewness of cell logits probabilities.
+ aggregation_temperature (`float`, *optional*, defaults to 1.0):
+ Scales aggregation logits to control the skewness of probabilities.
+ use_gumbel_for_cells (`bool`, *optional*, defaults to `False`):
+ Whether to apply Gumbel-Softmax to cell selection.
+ use_gumbel_for_aggregation (`bool`, *optional*, defaults to `False`):
+ Whether to apply Gumbel-Softmax to aggregation selection.
+ average_approximation_function (`string`, *optional*, defaults to `"ratio"`):
+ Method to calculate the expected average of cells in the weak supervision case. One of `"ratio"`,
+ `"first_order"` or `"second_order"`.
+ cell_selection_preference (`float`, *optional*):
+ Preference for cell selection in ambiguous cases. Only applicable in case of weak supervision for
+ aggregation (WTQ, WikiSQL). If the total mass of the aggregation probabilities (excluding the "NONE"
+ operator) is higher than this hyperparameter, then aggregation is predicted for an example.
+ answer_loss_cutoff (`float`, *optional*):
+ Ignore examples with answer loss larger than cutoff.
+ max_num_rows (`int`, *optional*, defaults to 64):
+ Maximum number of rows.
+ max_num_columns (`int`, *optional*, defaults to 32):
+ Maximum number of columns.
+ average_logits_per_cell (`bool`, *optional*, defaults to `False`):
+ Whether to average logits per cell.
+ select_one_column (`bool`, *optional*, defaults to `True`):
+ Whether to constrain the model to only select cells from a single column.
+ allow_empty_column_selection (`bool`, *optional*, defaults to `False`):
+ Whether to allow not to select any column.
+ init_cell_selection_weights_to_zero (`bool`, *optional*, defaults to `False`):
+ Whether to initialize cell selection weights to 0 so that the initial probabilities are 50%.
+ reset_position_index_per_cell (`bool`, *optional*, defaults to `True`):
+ Whether to restart position indexes at every cell (i.e. use relative position embeddings).
+ disable_per_token_loss (`bool`, *optional*, defaults to `False`):
+ Whether to disable any (strong or weak) supervision on cells.
+ aggregation_labels (`dict[int, label]`, *optional*):
+ The aggregation labels used to aggregate the results. For example, the WTQ models have the following
+ aggregation labels: `{0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}`
+ no_aggregation_label_index (`int`, *optional*):
+ If the aggregation labels are defined and one of these labels represents "No aggregation", this should be
+ set to its index. For example, the WTQ models have the "NONE" aggregation label at index 0, so that value
+ should be set to 0 for these models.
+
+ Example:
+
+ ```python
+ >>> from transformers import TapasModel, TapasConfig
+
+ >>> # Initializing a default (SQA) Tapas configuration
+ >>> configuration = TapasConfig()
+ >>> # Initializing a model from the configuration
+ >>> model = TapasModel(configuration)
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "tapas"
+
+ vocab_size: int = 30522
+ hidden_size: int = 768
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ intermediate_size: int = 3072
+ hidden_act: str = "gelu"
+ hidden_dropout_prob: float | int = 0.1
+ attention_probs_dropout_prob: float | int = 0.1
+ max_position_embeddings: int = 1024
+ type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10)
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-12
+ pad_token_id: int | None = 0
+ bos_token_id: int | None = None
+ eos_token_id: int | list[int] | None = None
+ positive_label_weight: float = 10.0
+ num_aggregation_labels: int = 0
+ aggregation_loss_weight: float = 1.0
+ use_answer_as_supervision: bool | None = None
+ answer_loss_importance: float = 1.0
+ use_normalized_answer_loss: bool = False
+ huber_loss_delta: float | None = None
+ temperature: float = 1.0
+ aggregation_temperature: float = 1.0
+ use_gumbel_for_cells: bool = False
+ use_gumbel_for_aggregation: bool = False
+ average_approximation_function: str = "ratio"
+ cell_selection_preference: float | None = None
+ answer_loss_cutoff: float | int | None = None
+ max_num_rows: int = 64
+ max_num_columns: int = 32
+ average_logits_per_cell: bool = False
+ select_one_column: bool = True
+ allow_empty_column_selection: bool = False
+ init_cell_selection_weights_to_zero: bool = False
+ reset_position_index_per_cell: bool = True
+ disable_per_token_loss: bool = False
+ aggregation_labels: dict | None = None
+ no_aggregation_label_index: int | None = None
+ is_decoder: bool = False
+ add_cross_attention: bool = False
+ tie_word_embeddings: bool = True
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.aggregation_labels, dict):
+ self.aggregation_labels = {int(k): v for k, v in self.aggregation_labels.items()}
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["TapasConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/tapas/modeling_tapas.py b/lib/python3.11/site-packages/transformers/models/tapas/modeling_tapas.py
new file mode 100644
index 0000000000000000000000000000000000000000..040fe7590371328b87ba2a19f3896fbada03fcdb
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tapas/modeling_tapas.py
@@ -0,0 +1,2106 @@
+# Copyright 2020 Google Research and 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.
+"""PyTorch TAPAS model."""
+
+import enum
+import math
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...masking_utils import create_bidirectional_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling, MaskedLMOutput, SequenceClassifierOutput
+from ...modeling_utils import PreTrainedModel
+from ...pytorch_utils import apply_chunking_to_forward
+from ...utils import ModelOutput, auto_docstring, logging
+from .configuration_tapas import TapasConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+EPSILON_ZERO_DIVISION = 1e-10
+CLOSE_ENOUGH_TO_LOG_ZERO = -10000.0
+
+
+@auto_docstring(
+ custom_intro="""
+ Output type of [`TapasForQuestionAnswering`].
+ """
+)
+@dataclass
+class TableQuestionAnsweringOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` (and possibly `answer`, `aggregation_labels`, `numeric_values` and `numeric_values_scale` are provided)):
+ Total loss as the sum of the hierarchical cell selection log-likelihood loss and (optionally) the
+ semi-supervised regression loss and (optionally) supervised loss for aggregations.
+ logits (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Prediction scores of the cell selection head, for every token.
+ logits_aggregation (`torch.FloatTensor`, *optional*, of shape `(batch_size, num_aggregation_labels)`):
+ Prediction scores of the aggregation head, for every aggregation operator.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ logits_aggregation: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+class TapasEmbeddings(nn.Module):
+ """
+ Construct the embeddings from word, position and token_type embeddings. Same as BertEmbeddings but with a number of
+ additional token type embeddings to encode tabular structure.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ # we do not include config.disabled_features and config.disable_position_embeddings from the original implementation
+ # word embeddings
+ self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+ # position embeddings
+ self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+ # token type embeddings
+ for i, type_vocab_sizes in enumerate(config.type_vocab_sizes):
+ name = f"token_type_embeddings_{i}"
+ setattr(self, name, nn.Embedding(type_vocab_sizes, config.hidden_size))
+
+ self.number_of_token_type_embeddings = len(config.type_vocab_sizes)
+
+ self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ self.config = config
+
+ def forward(self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None):
+ if input_ids is not None:
+ input_shape = input_ids.size()
+ else:
+ input_shape = inputs_embeds.size()[:-1]
+
+ seq_length = input_shape[1]
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+ if position_ids is None:
+ # create absolute position embeddings
+ position_ids = torch.arange(seq_length, dtype=torch.long, device=device)
+ position_ids = position_ids.unsqueeze(0).expand(input_shape)
+ # when self.config.reset_position_index_per_cell is set to True, create relative position embeddings
+ if self.config.reset_position_index_per_cell:
+ # shape (batch_size, seq_len)
+ col_index = IndexMap(token_type_ids[:, :, 1], self.config.type_vocab_sizes[1], batch_dims=1)
+ # shape (batch_size, seq_len)
+ row_index = IndexMap(token_type_ids[:, :, 2], self.config.type_vocab_sizes[2], batch_dims=1)
+ # shape (batch_size, seq_len)
+ full_index = ProductIndexMap(col_index, row_index)
+ # shape (max_rows * max_columns,). First absolute position for every cell
+ first_position_per_segment = reduce_min(position_ids, full_index)[0]
+ # ? shape (batch_size, seq_len). First absolute position of the cell for every token
+ first_position = gather(first_position_per_segment, full_index)
+ # shape (1, seq_len)
+ position = torch.arange(seq_length, dtype=torch.long, device=device).unsqueeze(0)
+ position_ids = torch.min(
+ torch.as_tensor(self.config.max_position_embeddings - 1, device=device), position - first_position
+ )
+
+ if token_type_ids is None:
+ token_type_ids = torch.zeros(
+ (input_shape + self.number_of_token_type_embeddings), dtype=torch.long, device=device
+ )
+
+ if inputs_embeds is None:
+ inputs_embeds = self.word_embeddings(input_ids)
+
+ position_embeddings = self.position_embeddings(position_ids)
+
+ embeddings = inputs_embeds + position_embeddings
+
+ for i in range(self.number_of_token_type_embeddings):
+ name = f"token_type_embeddings_{i}"
+ embeddings += getattr(self, name)(token_type_ids[:, :, i])
+
+ embeddings = self.LayerNorm(embeddings)
+ embeddings = self.dropout(embeddings)
+ return embeddings
+
+
+class TapasSelfAttention(nn.Module):
+ def __init__(self, config, layer_idx=None):
+ super().__init__()
+ if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+ raise ValueError(
+ f"The hidden size {config.hidden_size} is not a multiple of the number of attention "
+ f"heads {config.num_attention_heads}"
+ )
+
+ self.num_attention_heads = config.num_attention_heads
+ self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+ self.all_head_size = self.num_attention_heads * self.attention_head_size
+
+ self.query = nn.Linear(config.hidden_size, self.all_head_size)
+ self.key = nn.Linear(config.hidden_size, self.all_head_size)
+ self.value = nn.Linear(config.hidden_size, self.all_head_size)
+
+ self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+ self.is_decoder = config.is_decoder
+ self.layer_idx = layer_idx
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ past_key_values=None,
+ output_attentions=False,
+ **kwargs,
+ ):
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.attention_head_size)
+ query_layer = self.query(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ is_updated = False
+ is_cross_attention = encoder_hidden_states is not None
+ if past_key_values is not None:
+ if isinstance(past_key_values, EncoderDecoderCache):
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ if is_cross_attention:
+ # after the first generated id, we can subsequently re-use all key/value_layer from cache
+ curr_past_key_values = past_key_values.cross_attention_cache
+ else:
+ curr_past_key_values = past_key_values.self_attention_cache
+ else:
+ curr_past_key_values = past_key_values
+
+ current_states = encoder_hidden_states if is_cross_attention else hidden_states
+ if is_cross_attention and past_key_values is not None and is_updated:
+ # reuse k,v, cross_attentions
+ key_layer = curr_past_key_values.layers[self.layer_idx].keys
+ value_layer = curr_past_key_values.layers[self.layer_idx].values
+ else:
+ key_layer = self.key(current_states).view(hidden_shape).transpose(1, 2)
+ value_layer = self.value(current_states).view(hidden_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ # save all key/value_layer to cache to be re-used for fast auto-regressive generation
+ key_layer, value_layer = curr_past_key_values.update(key_layer, value_layer, self.layer_idx)
+ # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+ if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+ past_key_values.is_updated[self.layer_idx] = True
+
+ # Take the dot product between "query" and "key" to get the raw attention scores.
+ attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+ attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+ if attention_mask is not None:
+ # Apply the attention mask is (precomputed for all layers in TapasModel forward() function)
+ attention_scores = attention_scores + attention_mask
+
+ # Normalize the attention scores to probabilities.
+ attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+ # This is actually dropping out entire tokens to attend to, which might
+ # seem a bit unusual, but is taken from the original Transformer paper.
+ attention_probs = self.dropout(attention_probs)
+
+ context_layer = torch.matmul(attention_probs, value_layer)
+
+ context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+ new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+ context_layer = context_layer.view(*new_context_layer_shape)
+
+ outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+ if self.is_decoder:
+ outputs = outputs + (past_key_values,)
+ return outputs
+
+
+# Copied from transformers.models.bert.modeling_bert.BertSelfOutput
+class TapasSelfOutput(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+ self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.LayerNorm(hidden_states + input_tensor)
+ return hidden_states
+
+
+class TapasAttention(nn.Module):
+ def __init__(self, config, layer_idx=None):
+ super().__init__()
+ self.self = TapasSelfAttention(config, layer_idx=layer_idx)
+ self.output = TapasSelfOutput(config)
+
+ # Copied from transformers.models.rembert.modeling_rembert.RemBertAttention.forward
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ past_key_values: Cache | None = None,
+ output_attentions: bool | None = False,
+ **kwargs,
+ ) -> tuple[torch.Tensor]:
+ self_outputs = self.self(
+ hidden_states,
+ attention_mask=attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+ attention_output = self.output(self_outputs[0], hidden_states)
+ outputs = (attention_output,) + self_outputs[1:] # add attentions if we output them
+ return outputs
+
+
+# Copied from transformers.models.bert.modeling_bert.BertIntermediate
+class TapasIntermediate(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.bert.modeling_bert.BertOutput
+class TapasOutput(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+ self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.LayerNorm(hidden_states + input_tensor)
+ return hidden_states
+
+
+class TapasLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_idx=None):
+ super().__init__()
+ self.chunk_size_feed_forward = config.chunk_size_feed_forward
+ self.seq_len_dim = 1
+ self.attention = TapasAttention(config, layer_idx=layer_idx)
+ self.is_decoder = config.is_decoder
+ self.add_cross_attention = config.add_cross_attention
+ if self.add_cross_attention:
+ if not self.is_decoder:
+ raise ValueError(f"{self} should be used as a decoder model if cross attention is added")
+ self.crossattention = TapasAttention(config, layer_idx=layer_idx)
+ self.intermediate = TapasIntermediate(config)
+ self.output = TapasOutput(config)
+
+ # Copied from transformers.models.rembert.modeling_rembert.RemBertLayer.forward
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.FloatTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.FloatTensor | None = None,
+ past_key_values: Cache | None = None,
+ output_attentions: bool | None = False,
+ **kwargs,
+ ) -> tuple[torch.Tensor]:
+ self_attention_outputs = self.attention(
+ hidden_states,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ past_key_values=past_key_values,
+ )
+ attention_output = self_attention_outputs[0]
+ outputs = self_attention_outputs[1:] # add self attentions if we output attention weights
+
+ if self.is_decoder and encoder_hidden_states is not None:
+ if not hasattr(self, "crossattention"):
+ raise ValueError(
+ f"If `encoder_hidden_states` are passed, {self} has to be instantiated with cross-attention layers"
+ " by setting `config.add_cross_attention=True`"
+ )
+
+ cross_attention_outputs = self.crossattention(
+ attention_output,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+ attention_output = cross_attention_outputs[0]
+ outputs = outputs + cross_attention_outputs[1:] # add cross attentions if we output attention weights
+
+ layer_output = apply_chunking_to_forward(
+ self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
+ )
+ outputs = (layer_output,) + outputs
+
+ return outputs
+
+ # Copied from transformers.models.bert.modeling_bert.BertLayer.feed_forward_chunk
+ def feed_forward_chunk(self, attention_output):
+ intermediate_output = self.intermediate(attention_output)
+ layer_output = self.output(intermediate_output, attention_output)
+ return layer_output
+
+
+class TapasEncoder(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.layer = nn.ModuleList([TapasLayer(config, layer_idx=i) for i in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ past_key_values=None,
+ use_cache=None,
+ output_attentions=False,
+ output_hidden_states=False,
+ return_dict=True,
+ **kwargs,
+ ):
+ if use_cache and past_key_values is None:
+ past_key_values = EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache(config=self.config))
+
+ all_hidden_states = () if output_hidden_states else None
+ all_attentions = () if output_attentions else None
+ for i, layer_module in enumerate(self.layer):
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ layer_outputs = layer_module(
+ hidden_states,
+ attention_mask,
+ encoder_hidden_states, # as a positional argument for gradient checkpointing
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+ hidden_states = layer_outputs[0]
+ if output_attentions:
+ all_attentions = all_attentions + (layer_outputs[1],)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_attentions
+ )
+
+
+# Copied from transformers.models.bert.modeling_bert.BertPooler
+class TapasPooler(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+ self.activation = nn.Tanh()
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ # We "pool" the model by simply taking the hidden state corresponding
+ # to the first token.
+ first_token_tensor = hidden_states[:, 0]
+ pooled_output = self.dense(first_token_tensor)
+ pooled_output = self.activation(pooled_output)
+ return pooled_output
+
+
+# Copied from transformers.models.bert.modeling_bert.BertPredictionHeadTransform with Bert->Tapas
+class TapasPredictionHeadTransform(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+ if isinstance(config.hidden_act, str):
+ self.transform_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.transform_act_fn = config.hidden_act
+ self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.transform_act_fn(hidden_states)
+ hidden_states = self.LayerNorm(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->Tapas
+class TapasLMPredictionHead(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.transform = TapasPredictionHeadTransform(config)
+
+ # The output weights are the same as the input embeddings, but there is
+ # an output-only bias for each token.
+ self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=True)
+ self.bias = nn.Parameter(torch.zeros(config.vocab_size))
+
+ def forward(self, hidden_states):
+ hidden_states = self.transform(hidden_states)
+ hidden_states = self.decoder(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.bert.modeling_bert.BertOnlyMLMHead with Bert->Tapas
+class TapasOnlyMLMHead(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.predictions = TapasLMPredictionHead(config)
+
+ def forward(self, sequence_output: torch.Tensor) -> torch.Tensor:
+ prediction_scores = self.predictions(sequence_output)
+ return prediction_scores
+
+
+@auto_docstring
+class TapasPreTrainedModel(PreTrainedModel):
+ config: TapasConfig
+ base_model_prefix = "tapas"
+ supports_gradient_checkpointing = True
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ super()._init_weights(module)
+ if isinstance(module, TapasLMPredictionHead):
+ init.zeros_(module.bias)
+ if isinstance(module, TapasForQuestionAnswering):
+ if module.config.init_cell_selection_weights_to_zero:
+ init.zeros_(module.output_weights)
+ init.zeros_(module.column_output_weights)
+ else:
+ init.normal_(module.output_weights, std=module.config.initializer_range)
+ init.normal_(module.column_output_weights, std=module.config.initializer_range)
+ init.zeros_(module.output_bias)
+ init.zeros_(module.column_output_bias)
+
+
+@auto_docstring
+class TapasModel(TapasPreTrainedModel):
+ """
+ This class is a small change compared to [`BertModel`], taking into account the additional token type ids.
+
+ The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
+ cross-attention is added between the self-attention layers, following the architecture described in [Attention is
+ all you need](https://huggingface.co/papers/1706.03762) by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
+ Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
+
+ """
+
+ def __init__(self, config, add_pooling_layer=True):
+ r"""
+ add_pooling_layer (bool, *optional*, defaults to `True`):
+ Whether to add a pooling layer
+ """
+ super().__init__(config)
+ self.config = config
+
+ self.embeddings = TapasEmbeddings(config)
+ self.encoder = TapasEncoder(config)
+
+ self.pooler = TapasPooler(config) if add_pooling_layer else None
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings.word_embeddings
+
+ def set_input_embeddings(self, value):
+ self.embeddings.word_embeddings = value
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ token_type_ids: torch.LongTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ token_type_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, 7)`, *optional*):
+ Token indices that encode tabular structure. Indices can be obtained using [`AutoTokenizer`]. See this
+ class for more info.
+
+ [What are token type IDs?](../glossary#token-type-ids)
+ position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices of positions of each input sequence tokens in the position embeddings. If
+ `reset_position_index_per_cell` of [`TapasConfig`] is set to `True`, relative position embeddings will be
+ used. Selected in the range `[0, config.max_position_embeddings - 1]`.
+
+ [What are position IDs?](../glossary#position-ids)
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, TapasModel
+ >>> import pandas as pd
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
+ >>> model = TapasModel.from_pretrained("google/tapas-base")
+
+ >>> data = {
+ ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
+ ... "Age": ["56", "45", "59"],
+ ... "Number of movies": ["87", "53", "69"],
+ ... }
+ >>> table = pd.DataFrame.from_dict(data)
+ >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"]
+
+ >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
+ >>> outputs = model(**inputs)
+
+ >>> last_hidden_states = outputs.last_hidden_state
+ ```"""
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if input_ids is not None and inputs_embeds is not None:
+ raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+ elif input_ids is not None:
+ self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
+ input_shape = input_ids.size()
+ elif inputs_embeds is not None:
+ input_shape = inputs_embeds.size()[:-1]
+ else:
+ raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+ if attention_mask is None:
+ attention_mask = torch.ones(input_shape, device=device)
+ if token_type_ids is None:
+ token_type_ids = torch.zeros(
+ (*input_shape, len(self.config.type_vocab_sizes)), dtype=torch.long, device=device
+ )
+
+ embedding_output = self.embeddings(
+ input_ids=input_ids, position_ids=position_ids, token_type_ids=token_type_ids, inputs_embeds=inputs_embeds
+ )
+
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=embedding_output,
+ attention_mask=attention_mask,
+ )
+
+ if encoder_attention_mask is not None:
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=embedding_output,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+
+ encoder_outputs = self.encoder(
+ embedding_output,
+ attention_mask=attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ sequence_output = encoder_outputs[0]
+ pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
+
+ if not return_dict:
+ return (sequence_output, pooled_output) + encoder_outputs[1:]
+
+ return BaseModelOutputWithPooling(
+ last_hidden_state=sequence_output,
+ pooler_output=pooled_output,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring
+class TapasForMaskedLM(TapasPreTrainedModel):
+ _tied_weights_keys = {
+ "cls.predictions.decoder.bias": "cls.predictions.bias",
+ "cls.predictions.decoder.weight": "tapas.embeddings.word_embeddings.weight",
+ }
+ config: TapasConfig
+ base_model_prefix = "tapas"
+
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.tapas = TapasModel(config, add_pooling_layer=False)
+ self.cls = TapasOnlyMLMHead(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_output_embeddings(self):
+ return self.cls.predictions.decoder
+
+ def set_output_embeddings(self, new_embeddings):
+ self.cls.predictions.decoder = new_embeddings
+ self.cls.predictions.bias = new_embeddings.bias
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ token_type_ids: torch.LongTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | MaskedLMOutput:
+ r"""
+ token_type_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, 7)`, *optional*):
+ Token indices that encode tabular structure. Indices can be obtained using [`AutoTokenizer`]. See this
+ class for more info.
+
+ [What are token type IDs?](../glossary#token-type-ids)
+ position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices of positions of each input sequence tokens in the position embeddings. If
+ `reset_position_index_per_cell` of [`TapasConfig`] is set to `True`, relative position embeddings will be
+ used. Selected in the range `[0, config.max_position_embeddings - 1]`.
+
+ [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
+ config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the
+ loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, TapasForMaskedLM
+ >>> import pandas as pd
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
+ >>> model = TapasForMaskedLM.from_pretrained("google/tapas-base")
+
+ >>> data = {
+ ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
+ ... "Age": ["56", "45", "59"],
+ ... "Number of movies": ["87", "53", "69"],
+ ... }
+ >>> table = pd.DataFrame.from_dict(data)
+
+ >>> inputs = tokenizer(
+ ... table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="pt"
+ ... )
+ >>> labels = tokenizer(
+ ... table=table, queries="How many movies has George Clooney played in?", return_tensors="pt"
+ ... )["input_ids"]
+
+ >>> outputs = model(**inputs, labels=labels)
+ >>> logits = outputs.logits
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.tapas(
+ input_ids,
+ attention_mask=attention_mask,
+ token_type_ids=token_type_ids,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = outputs[0]
+ prediction_scores = self.cls(sequence_output)
+
+ masked_lm_loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss() # -100 index = padding token
+ masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
+
+ if not return_dict:
+ output = (prediction_scores,) + outputs[2:]
+ return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
+
+ return MaskedLMOutput(
+ loss=masked_lm_loss,
+ logits=prediction_scores,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Tapas Model with a cell selection head and optional aggregation head on top for question-answering tasks on tables
+ (linear layers on top of the hidden-states output to compute `logits` and optional `logits_aggregation`), e.g. for
+ SQA, WTQ or WikiSQL-supervised tasks.
+ """
+)
+class TapasForQuestionAnswering(TapasPreTrainedModel):
+ def __init__(self, config: TapasConfig):
+ super().__init__(config)
+
+ # base model
+ self.tapas = TapasModel(config)
+
+ # dropout (only used when training)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ # cell selection heads
+ self.output_weights = nn.Parameter(torch.empty(config.hidden_size))
+ self.column_output_weights = nn.Parameter(torch.empty(config.hidden_size))
+ self.output_bias = nn.Parameter(torch.empty([]))
+ self.column_output_bias = nn.Parameter(torch.empty([]))
+
+ # aggregation head
+ if config.num_aggregation_labels > 0:
+ self.aggregation_classifier = nn.Linear(config.hidden_size, config.num_aggregation_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ token_type_ids: torch.LongTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ table_mask: torch.LongTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ aggregation_labels: torch.LongTensor | None = None,
+ float_answer: torch.FloatTensor | None = None,
+ numeric_values: torch.FloatTensor | None = None,
+ numeric_values_scale: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | TableQuestionAnsweringOutput:
+ r"""
+ token_type_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, 7)`, *optional*):
+ Token indices that encode tabular structure. Indices can be obtained using [`AutoTokenizer`]. See this
+ class for more info.
+
+ [What are token type IDs?](../glossary#token-type-ids)
+ position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices of positions of each input sequence tokens in the position embeddings. If
+ `reset_position_index_per_cell` of [`TapasConfig`] is set to `True`, relative position embeddings will be
+ used. Selected in the range `[0, config.max_position_embeddings - 1]`.
+
+ [What are position IDs?](../glossary#position-ids)
+ table_mask (`torch.LongTensor` of shape `(batch_size, seq_length)`, *optional*):
+ Mask for the table. Indicates which tokens belong to the table (1). Question tokens, table headers and
+ padding are 0.
+ labels (`torch.LongTensor` of shape `(batch_size, seq_length)`, *optional*):
+ Labels per token for computing the hierarchical cell selection loss. This encodes the positions of the
+ answer appearing in the table. Can be obtained using [`AutoTokenizer`].
+
+ - 1 for tokens that are **part of the answer**,
+ - 0 for tokens that are **not part of the answer**.
+ aggregation_labels (`torch.LongTensor` of shape `(batch_size, )`, *optional*):
+ Aggregation function index for every example in the batch for computing the aggregation loss. Indices
+ should be in `[0, ..., config.num_aggregation_labels - 1]`. Only required in case of strong supervision for
+ aggregation (WikiSQL-supervised).
+ float_answer (`torch.FloatTensor` of shape `(batch_size, )`, *optional*):
+ Float answer for every example in the batch. Set to *float('nan')* for cell selection questions. Only
+ required in case of weak supervision (WTQ) to calculate the aggregate mask and regression loss.
+ numeric_values (`torch.FloatTensor` of shape `(batch_size, seq_length)`, *optional*):
+ Numeric values of every token, NaN for tokens which are not numeric values. Can be obtained using
+ [`AutoTokenizer`]. Only required in case of weak supervision for aggregation (WTQ) to calculate the
+ regression loss.
+ numeric_values_scale (`torch.FloatTensor` of shape `(batch_size, seq_length)`, *optional*):
+ Scale of the numeric values of every token. Can be obtained using [`AutoTokenizer`]. Only required in case
+ of weak supervision for aggregation (WTQ) to calculate the regression loss.
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, TapasForQuestionAnswering
+ >>> import pandas as pd
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq")
+ >>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq")
+
+ >>> data = {
+ ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
+ ... "Age": ["56", "45", "59"],
+ ... "Number of movies": ["87", "53", "69"],
+ ... }
+ >>> table = pd.DataFrame.from_dict(data)
+ >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"]
+
+ >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
+ >>> outputs = model(**inputs)
+
+ >>> logits = outputs.logits
+ >>> logits_aggregation = outputs.logits_aggregation
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.tapas(
+ input_ids,
+ attention_mask=attention_mask,
+ token_type_ids=token_type_ids,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = outputs[0]
+ pooled_output = outputs[1]
+
+ sequence_output = self.dropout(sequence_output)
+
+ if input_ids is not None:
+ input_shape = input_ids.size()
+ else:
+ input_shape = inputs_embeds.size()[:-1]
+
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+ # Construct indices for the table.
+ if token_type_ids is None:
+ token_type_ids = torch.zeros(
+ (*input_shape, len(self.config.type_vocab_sizes)), dtype=torch.long, device=device
+ )
+
+ token_types = [
+ "segment_ids",
+ "column_ids",
+ "row_ids",
+ "prev_labels",
+ "column_ranks",
+ "inv_column_ranks",
+ "numeric_relations",
+ ]
+
+ row_ids = token_type_ids[:, :, token_types.index("row_ids")]
+ column_ids = token_type_ids[:, :, token_types.index("column_ids")]
+
+ row_index = IndexMap(
+ indices=torch.min(row_ids, torch.as_tensor(self.config.max_num_rows - 1, device=row_ids.device)),
+ num_segments=self.config.max_num_rows,
+ batch_dims=1,
+ )
+ col_index = IndexMap(
+ indices=torch.min(column_ids, torch.as_tensor(self.config.max_num_columns - 1, device=column_ids.device)),
+ num_segments=self.config.max_num_columns,
+ batch_dims=1,
+ )
+ cell_index = ProductIndexMap(row_index, col_index)
+
+ # Masks.
+ input_shape = input_ids.size() if input_ids is not None else inputs_embeds.size()[:-1]
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
+ if attention_mask is None:
+ attention_mask = torch.ones(input_shape, device=device)
+ # Table cells only, without question tokens and table headers.
+ if table_mask is None:
+ table_mask = torch.where(row_ids > 0, torch.ones_like(row_ids), torch.zeros_like(row_ids))
+ # torch.FloatTensor[batch_size, seq_length]
+ input_mask_float = attention_mask.to(device=device, dtype=torch.float)
+ table_mask_float = table_mask.to(device=device, dtype=torch.float)
+ # Mask for cells that exist in the table (i.e. that are not padding).
+ cell_mask, _ = reduce_mean(input_mask_float, cell_index)
+
+ # Compute logits per token. These are used to select individual cells.
+ logits = compute_token_logits(sequence_output, self.config.temperature, self.output_weights, self.output_bias)
+
+ # Compute logits per column. These are used to select a column.
+ column_logits = None
+ if self.config.select_one_column:
+ column_logits = compute_column_logits(
+ sequence_output,
+ self.column_output_weights,
+ self.column_output_bias,
+ cell_index,
+ cell_mask,
+ self.config.allow_empty_column_selection,
+ )
+
+ # Aggregation logits
+ logits_aggregation = None
+ if self.config.num_aggregation_labels > 0:
+ logits_aggregation = self.aggregation_classifier(pooled_output)
+
+ # Total loss calculation
+ total_loss = 0.0
+ calculate_loss = False
+ if labels is not None:
+ calculate_loss = True
+ is_supervised = not self.config.num_aggregation_labels > 0 or not self.config.use_answer_as_supervision
+
+ # Semi-supervised cell selection in case of no aggregation:
+ # If the answer (the denotation) appears directly in the table we might
+ # select the answer without applying any aggregation function. There are
+ # some ambiguous cases, see utils._calculate_aggregate_mask for more info.
+ # `aggregate_mask` is 1 for examples where we chose to aggregate and 0
+ # for examples where we chose to select the answer directly.
+ # `labels` encodes the positions of the answer appearing in the table.
+ if is_supervised:
+ aggregate_mask = None
+ else:
+ if float_answer is not None:
+ assert labels.shape[0] == float_answer.shape[0], (
+ "Make sure the answers are a FloatTensor of shape (batch_size,)"
+ )
+ # <float32>[batch_size]
+ aggregate_mask = _calculate_aggregate_mask(
+ float_answer,
+ pooled_output,
+ self.config.cell_selection_preference,
+ labels,
+ self.aggregation_classifier,
+ )
+ else:
+ raise ValueError("You have to specify float answers in order to calculate the aggregate mask")
+
+ # Cell selection log-likelihood
+ if self.config.average_logits_per_cell:
+ logits_per_cell, _ = reduce_mean(logits, cell_index)
+ logits = gather(logits_per_cell, cell_index)
+ dist_per_token = torch.distributions.Bernoulli(logits=logits)
+
+ # Compute cell selection loss per example.
+ selection_loss_per_example = None
+ if not self.config.select_one_column:
+ weight = torch.where(
+ labels == 0,
+ torch.ones_like(labels, dtype=torch.float32),
+ self.config.positive_label_weight * torch.ones_like(labels, dtype=torch.float32),
+ )
+ selection_loss_per_token = -dist_per_token.log_prob(labels) * weight
+ selection_loss_per_example = torch.sum(selection_loss_per_token * input_mask_float, dim=1) / (
+ torch.sum(input_mask_float, dim=1) + EPSILON_ZERO_DIVISION
+ )
+ else:
+ selection_loss_per_example, logits = _single_column_cell_selection_loss(
+ logits, column_logits, labels, cell_index, col_index, cell_mask
+ )
+ dist_per_token = torch.distributions.Bernoulli(logits=logits)
+
+ # Supervised cell selection
+ if self.config.disable_per_token_loss:
+ pass
+ elif is_supervised:
+ total_loss += torch.mean(selection_loss_per_example)
+ else:
+ # For the not supervised case, do not assign loss for cell selection
+ total_loss += torch.mean(selection_loss_per_example * (1.0 - aggregate_mask))
+
+ # Semi-supervised regression loss and supervised loss for aggregations
+ if self.config.num_aggregation_labels > 0:
+ if is_supervised:
+ # Note that `aggregate_mask` is None if the setting is supervised.
+ if aggregation_labels is not None:
+ assert labels.shape[0] == aggregation_labels.shape[0], (
+ "Make sure the aggregation labels are a LongTensor of shape (batch_size,)"
+ )
+ per_example_additional_loss = _calculate_aggregation_loss(
+ logits_aggregation,
+ aggregate_mask,
+ aggregation_labels,
+ self.config.use_answer_as_supervision,
+ self.config.num_aggregation_labels,
+ self.config.aggregation_loss_weight,
+ )
+ else:
+ raise ValueError(
+ "You have to specify aggregation labels in order to calculate the aggregation loss"
+ )
+ else:
+ # Set aggregation labels to zeros
+ aggregation_labels = torch.zeros(labels.shape[0], dtype=torch.long, device=labels.device)
+ per_example_additional_loss = _calculate_aggregation_loss(
+ logits_aggregation,
+ aggregate_mask,
+ aggregation_labels,
+ self.config.use_answer_as_supervision,
+ self.config.num_aggregation_labels,
+ self.config.aggregation_loss_weight,
+ )
+
+ if self.config.use_answer_as_supervision:
+ if numeric_values is not None and numeric_values_scale is not None:
+ assert numeric_values.shape == numeric_values_scale.shape
+ # Add regression loss for numeric answers which require aggregation.
+ answer_loss, large_answer_loss_mask = _calculate_regression_loss(
+ float_answer,
+ aggregate_mask,
+ dist_per_token,
+ numeric_values,
+ numeric_values_scale,
+ table_mask_float,
+ logits_aggregation,
+ self.config,
+ )
+ per_example_additional_loss += answer_loss
+ # Zero loss for examples with answer_loss > cutoff.
+ per_example_additional_loss *= large_answer_loss_mask
+ else:
+ raise ValueError(
+ "You have to specify numeric values and numeric values scale in order to calculate the"
+ " regression loss"
+ )
+
+ total_loss += torch.mean(per_example_additional_loss)
+
+ else:
+ # if no label ids are provided, set them to zeros in order to properly compute logits
+ labels = torch.zeros_like(logits)
+ _, logits = _single_column_cell_selection_loss(
+ logits, column_logits, labels, cell_index, col_index, cell_mask
+ )
+ if not return_dict:
+ output = (logits, logits_aggregation) + outputs[2:]
+ return ((total_loss,) + output) if calculate_loss else output
+
+ return TableQuestionAnsweringOutput(
+ loss=total_loss if calculate_loss else None,
+ logits=logits,
+ logits_aggregation=logits_aggregation,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Tapas Model with a sequence classification head on top (a linear layer on top of the pooled output), e.g. for table
+ entailment tasks, such as TabFact (Chen et al., 2020).
+ """
+)
+class TapasForSequenceClassification(TapasPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ self.tapas = TapasModel(config)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ token_type_ids: torch.LongTensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.Tensor] | SequenceClassifierOutput:
+ r"""
+ token_type_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, 7)`, *optional*):
+ Token indices that encode tabular structure. Indices can be obtained using [`AutoTokenizer`]. See this
+ class for more info.
+
+ [What are token type IDs?](../glossary#token-type-ids)
+ position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices of positions of each input sequence tokens in the position embeddings. If
+ `reset_position_index_per_cell` of [`TapasConfig`] is set to `True`, relative position embeddings will be
+ used. Selected in the range `[0, config.max_position_embeddings - 1]`.
+
+ [What are position IDs?](../glossary#position-ids)
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy). Note: this is called
+ "classification_class_index" in the original implementation.
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, TapasForSequenceClassification
+ >>> import torch
+ >>> import pandas as pd
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-tabfact")
+ >>> model = TapasForSequenceClassification.from_pretrained("google/tapas-base-finetuned-tabfact")
+
+ >>> data = {
+ ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
+ ... "Age": ["56", "45", "59"],
+ ... "Number of movies": ["87", "53", "69"],
+ ... }
+ >>> table = pd.DataFrame.from_dict(data)
+ >>> queries = [
+ ... "There is only one actor who is 45 years old",
+ ... "There are 3 actors which played in more than 60 movies",
+ ... ]
+
+ >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
+ >>> labels = torch.tensor([1, 0]) # 1 means entailed, 0 means refuted
+
+ >>> outputs = model(**inputs, labels=labels)
+ >>> loss = outputs.loss
+ >>> logits = outputs.logits
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.tapas(
+ input_ids,
+ attention_mask=attention_mask,
+ token_type_ids=token_type_ids,
+ position_ids=position_ids,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ pooled_output = outputs[1]
+
+ pooled_output = self.dropout(pooled_output)
+ logits = self.classifier(pooled_output)
+
+ loss = None
+ if labels is not None:
+ if self.config.problem_type is None:
+ if self.num_labels == 1:
+ self.config.problem_type = "regression"
+ elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+ self.config.problem_type = "single_label_classification"
+ else:
+ self.config.problem_type = "multi_label_classification"
+
+ if self.config.problem_type == "regression":
+ loss_fct = MSELoss()
+ if self.num_labels == 1:
+ loss = loss_fct(logits.squeeze(), labels.squeeze())
+ else:
+ loss = loss_fct(logits, labels)
+ elif self.config.problem_type == "single_label_classification":
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+ elif self.config.problem_type == "multi_label_classification":
+ loss_fct = BCEWithLogitsLoss()
+ loss = loss_fct(logits, labels)
+ if not return_dict:
+ output = (logits,) + outputs[2:]
+ return ((loss,) + output) if loss is not None else output
+
+ return SequenceClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+""" TAPAS utilities."""
+
+
+class AverageApproximationFunction(str, enum.Enum):
+ RATIO = "ratio"
+ FIRST_ORDER = "first_order"
+ SECOND_ORDER = "second_order"
+
+
+# Beginning of everything related to segmented tensors
+
+
+class IndexMap:
+ """Index grouping entries within a tensor."""
+
+ def __init__(self, indices, num_segments, batch_dims=0):
+ """
+ Creates an index
+
+ Args:
+ indices (`torch.LongTensor`, same shape as a *values* Tensor to which the indices refer):
+ Tensor containing the indices.
+ num_segments (`torch.LongTensor`):
+ Scalar tensor, the number of segments. All elements in a batched segmented tensor must have the same
+ number of segments (although many segments can be empty).
+ batch_dims (`int`, *optional*, defaults to 0):
+ The number of batch dimensions. The first *batch_dims* dimensions of a SegmentedTensor are treated as
+ batch dimensions. Segments in different batch elements are always distinct even if they have the same
+ index.
+ """
+ self.indices = torch.as_tensor(indices, device=indices.device)
+ self.num_segments = torch.as_tensor(num_segments, device=indices.device)
+ self.batch_dims = batch_dims
+
+ def batch_shape(self):
+ return self.indices.size()[: self.batch_dims] # returns a torch.Size object
+
+
+class ProductIndexMap(IndexMap):
+ """The product of two indices."""
+
+ def __init__(self, outer_index, inner_index):
+ """
+ Combines indices i and j into pairs (i, j). The result is an index where each segment (i, j) is the
+ intersection of segments i and j. For example if the inputs represent table cells indexed by respectively rows
+ and columns the output will be a table indexed by (row, column) pairs, i.e. by cell. The implementation
+ combines indices {0, .., n - 1} and {0, .., m - 1} into {0, .., nm - 1}. The output has *num_segments* equal to
+ *outer_index.num_segments* * *inner_index.num_segments*
+
+ Args:
+ outer_index (`IndexMap`):
+ IndexMap.
+ inner_index (`IndexMap`):
+ IndexMap, must have the same shape as *outer_index*.
+ """
+ if outer_index.batch_dims != inner_index.batch_dims:
+ raise ValueError("outer_index.batch_dims and inner_index.batch_dims must be the same.")
+
+ super().__init__(
+ indices=(inner_index.indices + outer_index.indices * inner_index.num_segments),
+ num_segments=inner_index.num_segments * outer_index.num_segments,
+ batch_dims=inner_index.batch_dims,
+ )
+ self.outer_index = outer_index
+ self.inner_index = inner_index
+
+ def project_outer(self, index):
+ """Projects an index with the same index set onto the outer components."""
+ indices = torch.div(index.indices, self.inner_index.num_segments, rounding_mode="floor").type(torch.long)
+ return IndexMap(indices=indices, num_segments=self.outer_index.num_segments, batch_dims=index.batch_dims)
+
+ def project_inner(self, index):
+ """Projects an index with the same index set onto the inner components."""
+ return IndexMap(
+ indices=torch.fmod(index.indices, self.inner_index.num_segments)
+ .type(torch.float)
+ .floor()
+ .type(torch.long),
+ num_segments=self.inner_index.num_segments,
+ batch_dims=index.batch_dims,
+ )
+
+
+def gather(values, index, name="segmented_gather"):
+ """
+ Gathers from *values* using the index map. For each element in the domain of the index map this operation looks up
+ a value for that index in *values*. Two elements from the same segment always get assigned the same value.
+
+ Args:
+ values (`torch.Tensor` of shape (B1, ..., Bn, num_segments, V1, ...)):
+ Tensor with segment values.
+ index (`IndexMap` of shape (B1, ..., Bn, I1, ..., Ik)):
+ IndexMap.
+ name (`str`, *optional*, defaults to 'segmented_gather'):
+ Name for the operation. Currently not used
+
+ Returns:
+ `tuple(torch.Tensor)`: Tensor of shape (B1, ..., Bn, I1, ..., Ik, V1, ...) with the gathered values.
+ """
+ indices = index.indices
+ # first, check whether the indices of the index represent scalar values (i.e. not vectorized)
+ if len(values.shape[index.batch_dims :]) < 2:
+ return torch.gather(
+ values,
+ index.batch_dims,
+ indices.view(
+ values.size()[0], -1
+ ), # torch.gather expects index to have the same number of dimensions as values
+ ).view(indices.size())
+ else:
+ # this means we have a vectorized version
+ # we have to adjust the index
+ indices = indices.unsqueeze(-1).expand(values.shape)
+ return torch.gather(values, index.batch_dims, indices)
+
+
+def flatten(index, name="segmented_flatten"):
+ """
+ Flattens a batched index map (which is typically of shape batch_size, seq_length) to a 1d index map. This operation
+ relabels the segments to keep batch elements distinct. The k-th batch element will have indices shifted by
+ *num_segments* * (k - 1). The result is a tensor with *num_segments* multiplied by the number of elements in the
+ batch.
+
+ Args:
+ index (`IndexMap`):
+ IndexMap to flatten.
+ name (`str`, *optional*, defaults to 'segmented_flatten'):
+ Name for the operation. Currently not used
+
+ Returns:
+ (`IndexMap`): The flattened IndexMap.
+ """
+ # first, get batch_size as scalar tensor
+ batch_size = torch.prod(torch.tensor(list(index.batch_shape())))
+ # next, create offset as 1-D tensor of length batch_size,
+ # and multiply element-wise by num segments (to offset different elements in the batch) e.g. if batch size is 2: [0, 64]
+ offset = torch.arange(start=0, end=batch_size, device=index.num_segments.device) * index.num_segments
+ offset = offset.view(index.batch_shape())
+ for _ in range(index.batch_dims, len(index.indices.size())): # typically range(1,2)
+ offset = offset.unsqueeze(-1)
+
+ indices = offset + index.indices
+ return IndexMap(indices=indices.view(-1), num_segments=index.num_segments * batch_size, batch_dims=0)
+
+
+def range_index_map(batch_shape, num_segments, name="range_index_map"):
+ """
+ Constructs an index map equal to range(num_segments).
+
+ Args:
+ batch_shape (`torch.Size`):
+ Batch shape
+ num_segments (`int`):
+ Number of segments
+ name (`str`, *optional*, defaults to 'range_index_map'):
+ Name for the operation. Currently not used
+
+ Returns:
+ (`IndexMap`): IndexMap of shape batch_shape with elements equal to range(num_segments).
+ """
+ device = num_segments.device if torch.is_tensor(num_segments) else "cpu"
+ batch_shape = torch.as_tensor(
+ batch_shape, dtype=torch.long, device=device
+ ) # create a rank 1 tensor vector containing batch_shape (e.g. [2])
+ assert len(batch_shape.size()) == 1
+ num_segments = torch.as_tensor(
+ num_segments, device=device
+ ) # create a rank 0 tensor (scalar) containing num_segments (e.g. 64)
+ assert len(num_segments.size()) == 0
+
+ indices = torch.arange(
+ start=0, end=num_segments, device=num_segments.device
+ ) # create a rank 1 vector with num_segments elements
+ new_tensor = torch.cat(
+ [torch.ones_like(batch_shape, dtype=torch.long, device=num_segments.device), num_segments.unsqueeze(dim=0)],
+ dim=0,
+ )
+ # new_tensor is just a vector of [1 64] for example (assuming only 1 batch dimension)
+ new_shape = [int(x) for x in new_tensor.tolist()]
+ indices = indices.view(new_shape)
+
+ multiples = torch.cat([batch_shape, torch.as_tensor([1], device=device)], dim=0)
+ indices = indices.repeat(multiples.tolist())
+ # equivalent (in Numpy:)
+ # indices = torch.as_tensor(np.tile(indices.numpy(), multiples.tolist()))
+
+ return IndexMap(indices=indices, num_segments=num_segments, batch_dims=list(batch_shape.size())[0])
+
+
+def _segment_reduce(values, index, segment_reduce_fn, name):
+ """
+ Applies a segment reduction segment-wise.
+
+ Args:
+ values (`torch.Tensor`):
+ Tensor with segment values.
+ index (`IndexMap`):
+ IndexMap.
+ segment_reduce_fn (`str`):
+ Name for the reduce operation. One of "sum", "mean", "max" or "min".
+ name (`str`):
+ Name for the operation. Currently not used
+
+ Returns:
+ (`IndexMap`): IndexMap of shape batch_shape with elements equal to range(num_segments).
+ """
+ # Flatten the batch dimensions, as segments ops (scatter) do not support batching.
+ # However if `values` has extra dimensions to the right keep them
+ # unflattened. Segmented ops support vector-valued operations.
+ flat_index = flatten(index)
+ vector_shape = values.size()[len(index.indices.size()) :] # torch.Size object
+ flattened_shape = torch.cat(
+ [torch.as_tensor([-1], dtype=torch.long), torch.as_tensor(vector_shape, dtype=torch.long)], dim=0
+ )
+ # changed "view" by "reshape" in the following line
+ flat_values = values.reshape(flattened_shape.tolist())
+
+ out = torch.zeros(int(flat_index.num_segments), dtype=torch.float, device=flat_values.device)
+ segment_means = out.scatter_reduce(
+ dim=0, index=flat_index.indices.long(), src=flat_values.float(), reduce=segment_reduce_fn, include_self=False
+ )
+
+ device = index.num_segments.device
+ # Unflatten the values.
+ new_shape = torch.cat(
+ [
+ torch.as_tensor(index.batch_shape(), dtype=torch.long, device=device),
+ torch.as_tensor(index.num_segments, dtype=torch.long, device=device).unsqueeze(dim=0),
+ torch.as_tensor(vector_shape, dtype=torch.long, device=device),
+ ],
+ dim=0,
+ )
+
+ output_values = segment_means.clone().view(new_shape.tolist()).to(values.dtype)
+ output_index = range_index_map(index.batch_shape(), index.num_segments)
+ return output_values, output_index
+
+
+def reduce_sum(values, index, name="segmented_reduce_sum"):
+ """
+ Sums a tensor over its segments.
+
+ Outputs 0 for empty segments.
+
+ This operations computes the sum over segments, with support for:
+
+ - Batching using the first dimensions [B1, B2, ..., Bn]. Each element in a batch can have different indices.
+ - Vectorization using the last dimension [V1, V2, ...]. If they are present, the output will be a sum of
+ vectors rather than scalars. Only the middle dimensions [I1, ..., Ik] are reduced by the operation.
+
+ Args:
+ values (`torch.Tensor` of shape [B1, B2, ..., Bn, I1, .., Ik, V1, V2, ..]):
+ Tensor containing the values of which the sum must be taken segment-wise.
+ index (`IndexMap`, indices are of shape [B1, B2, ..., Bn, I1, .., Ik].):
+ Index defining the segments.
+ name (`str`, *optional*, defaults to 'segmented_reduce_sum'):
+ Name for the operation. Currently not used
+
+ Returns:
+ output_values (`torch.Tensor`of shape [B1, B2, ..., Bn, num_segments, V1, V2, ..]): Tensor containing the
+ output values. output_index (`IndexMap`): IndexMap with shape [B1, B2, ..., Bn, num_segments]. .
+ """
+ return _segment_reduce(values, index, "sum", name)
+
+
+def reduce_mean(values, index, name="segmented_reduce_mean"):
+ """
+ Averages a tensor over its segments.
+
+ Outputs 0 for empty segments.
+
+ This operations computes the mean over segments, with support for:
+
+ - Batching using the first dimensions [B1, B2, ..., Bn]. Each element in a batch can have different indices.
+ - Vectorization using the last dimension [V1, V2, ...]. If they are present, the output will be a mean of
+ vectors rather than scalars.
+
+ Only the middle dimensions [I1, ..., Ik] are reduced by the operation.
+
+ Args:
+ values (`torch.Tensor` of shape [B1, B2, ..., Bn, I1, .., Ik, V1, V2, ..]):
+ Tensor containing the values of which the mean must be taken segment-wise.
+ index (`IndexMap`, indices are of shape [B1, B2, ..., Bn, I1, .., Ik].):
+ Index defining the segments.
+ name (`str`, *optional*, defaults to 'segmented_reduce_sum'):
+ Name for the operation. Currently not used
+
+ Returns:
+ output_values (`torch.Tensor`of shape [B1, B2, ..., Bn, num_segments, V1, V2, ..]): Tensor containing the
+ output values. output_index (`IndexMap`): IndexMap with shape [B1, B2, ..., Bn, num_segments].
+ """
+ return _segment_reduce(values, index, "mean", name)
+
+
+def reduce_max(values, index, name="segmented_reduce_max"):
+ """
+ Computes the maximum over segments.
+
+ This operation computes the maximum over segments, with support for:
+
+ - Batching using the first dimensions [B1, B2, ..., Bn]. Each element in a batch can have different indices.
+ - Vectorization using the last dimension [V1, V2, ...]. If they are present, the output will be an element-wise
+ maximum of vectors rather than scalars.
+
+ Only the middle dimensions [I1, ..., Ik] are reduced by the operation.
+
+ Args:
+ values (`torch.Tensor` of shape [B1, B2, ..., Bn, I1, .., Ik, V1, V2, ..]):
+ Tensor containing the values of which the max must be taken segment-wise.
+ index (`IndexMap`, indices are of shape [B1, B2, ..., Bn, I1, .., Ik].):
+ Index defining the segments.
+ name (`str`, *optional*, defaults to 'segmented_reduce_sum'):
+ Name for the operation. Currently not used
+
+ Returns:
+ output_values (`torch.Tensor`of shape [B1, B2, ..., Bn, num_segments, V1, V2, ..]): Tensor containing the
+ output values. output_index (`IndexMap`): IndexMap with shape [B1, B2, ..., Bn, num_segments].
+ """
+ return _segment_reduce(values, index, "amax", name)
+
+
+def reduce_min(values, index, name="segmented_reduce_min"):
+ """
+ Computes the minimum over segments.
+
+ This operations computes the minimum over segments, with support for:
+
+ - Batching using the first dimensions [B1, B2, ..., Bn]. Each element in a batch can have different indices.
+ - Vectorization using the last dimension [V1, V2, ...]. If they are present, the output will be an element-wise
+ minimum of vectors rather than scalars.
+
+ Only the middle dimensions [I1, ..., Ik] are reduced by the operation.
+
+ Args:
+ values (`torch.Tensor` of shape [B1, B2, ..., Bn, I1, .., Ik, V1, V2, ..]):
+ Tensor containing the values of which the min must be taken segment-wise.
+ index (`IndexMap`, indices are of shape [B1, B2, ..., Bn, I1, .., Ik].):
+ Index defining the segments.
+ name (`str`, *optional*, defaults to 'segmented_reduce_sum'):
+ Name for the operation. Currently not used
+
+ Returns:
+ output_values (`torch.Tensor`of shape [B1, B2, ..., Bn, num_segments, V1, V2, ..]): Tensor containing the
+ output values. output_index (`IndexMap`): IndexMap with shape [B1, B2, ..., Bn, num_segments].
+ """
+ return _segment_reduce(values, index, "amin", name)
+
+
+# End of everything related to segmented tensors
+
+
+def compute_column_logits(
+ sequence_output, column_output_weights, column_output_bias, cell_index, cell_mask, allow_empty_column_selection
+):
+ """
+ Computes the column logits.
+
+ Args:
+ sequence_output (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Also known as last_hidden_state. Sequence of hidden-states at the output of the last layer of the model.
+ column_output_weights (`torch.FloatTensor` of shape `(hidden_size)`):
+ Weights of the linear layer for column selection.
+ column_output_bias (`torch.FloatTensor` of shape `()`):
+ Bias of the linear layer for column selection.
+ cell_index (`ProductIndexMap`):
+ Index that groups tokens into cells.
+ cell_mask (`torch.FloatTensor` of shape `(batch_size, max_num_rows * max_num_cols)`):
+ Mask for cells that exist in the table (i.e. that are not padding).
+ allow_empty_column_selection (`bool`):
+ Whether to allow not to select any column
+
+ Returns:
+ column_logits (`torch.FloatTensor`of shape `(batch_size, max_num_cols)`): Tensor containing the column logits
+ for every example in the batch.
+ """
+
+ # First, compute the token logits (batch_size, seq_len) - without temperature
+ token_logits = torch.einsum("bsj,j->bs", sequence_output, column_output_weights) + column_output_bias
+
+ # Next, average the logits per cell (batch_size, max_num_cols*max_num_rows)
+ cell_logits, cell_logits_index = reduce_mean(token_logits, cell_index)
+
+ # Finally, average the logits per column (batch_size, max_num_cols)
+ column_index = cell_index.project_inner(cell_logits_index)
+ column_logits, out_index = reduce_sum(cell_logits * cell_mask, column_index)
+
+ cell_count, _ = reduce_sum(cell_mask, column_index)
+ column_logits /= cell_count + EPSILON_ZERO_DIVISION
+
+ # Mask columns that do not appear in the example.
+ is_padding = torch.logical_and(cell_count < 0.5, ~torch.eq(out_index.indices, 0))
+ column_logits += CLOSE_ENOUGH_TO_LOG_ZERO * torch.as_tensor(
+ is_padding, dtype=torch.float32, device=is_padding.device
+ )
+
+ if not allow_empty_column_selection:
+ column_logits += CLOSE_ENOUGH_TO_LOG_ZERO * torch.as_tensor(
+ torch.eq(out_index.indices, 0), dtype=torch.float32, device=out_index.indices.device
+ )
+
+ return column_logits
+
+
+def _single_column_cell_selection_loss(token_logits, column_logits, labels, cell_index, col_index, cell_mask):
+ """
+ Computes the loss for cell selection constrained to a single column. The loss is a hierarchical log-likelihood. The
+ model first predicts a column and then selects cells within that column (conditioned on the column). Cells outside
+ the selected column are never selected.
+
+ Args:
+ token_logits (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Tensor containing the logits per token.
+ column_logits (`torch.FloatTensor` of shape `(batch_size, max_num_cols)`):
+ Tensor containing the logits per column.
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Labels per token.
+ cell_index (`ProductIndexMap`):
+ Index that groups tokens into cells.
+ col_index (`IndexMap`):
+ Index that groups tokens into columns.
+ cell_mask (`torch.FloatTensor` of shape `(batch_size, max_num_rows * max_num_cols)`):
+ Mask for cells that exist in the table (i.e. that are not padding).
+
+ Returns:
+ selection_loss_per_example (`torch.FloatTensor` of shape `(batch_size,)`): Loss for each example. logits
+ (`torch.FloatTensor` of shape `(batch_size, sequence_length)`): New logits which are only allowed to select
+ cells in a single column. Logits outside of the most likely column according to *column_logits* will be set to
+ a very low value (such that the probabilities are 0).
+ """
+ # Part 1: column loss
+
+ # First find the column we should select. We use the column with maximum number of selected cells.
+ labels_per_column, _ = reduce_sum(torch.as_tensor(labels, dtype=torch.float32, device=labels.device), col_index)
+ # shape of labels_per_column is (batch_size, max_num_cols). It contains the number of label ids for every column, for every example
+ column_label = torch.argmax(labels_per_column, dim=-1) # shape (batch_size,)
+ # Check if there are no selected cells in the column. In that case the model
+ # should predict the special column id 0, which means "select nothing".
+ no_cell_selected = torch.eq(
+ torch.max(labels_per_column, dim=-1)[0], 0
+ ) # no_cell_selected is of shape (batch_size,) and equals True
+ # if an example of the batch has no cells selected (i.e. if there are no labels set to 1 for that example)
+ column_label = torch.where(
+ no_cell_selected.view(column_label.size()), torch.zeros_like(column_label), column_label
+ )
+
+ column_dist = torch.distributions.Categorical(logits=column_logits) # shape (batch_size, max_num_cols)
+ column_loss_per_example = -column_dist.log_prob(column_label)
+
+ # Part 2: cell loss
+
+ # Reduce the labels and logits to per-cell from per-token.
+ # logits_per_cell: shape (batch_size, max_num_rows*max_num_cols) i.e. (batch_size, 64*32)
+ logits_per_cell, _ = reduce_mean(token_logits, cell_index)
+ # labels_per_cell: shape (batch_size, 64*32), indicating whether each cell should be selected (1) or not (0)
+ labels_per_cell, labels_index = reduce_max(
+ torch.as_tensor(labels, dtype=torch.long, device=labels.device), cell_index
+ )
+
+ # Mask for the selected column.
+ # column_id_for_cells: shape (batch_size, 64*32), indicating to which column each cell belongs
+ column_id_for_cells = cell_index.project_inner(labels_index).indices
+ # column_mask: shape (batch_size, 64*32), equal to 1 if cell belongs to column to be selected
+ column_mask = torch.as_tensor(
+ torch.eq(column_id_for_cells, torch.unsqueeze(column_label, dim=-1)),
+ dtype=torch.float32,
+ device=cell_mask.device,
+ )
+
+ # Compute the log-likelihood for cells, but only for the selected column.
+ cell_dist = torch.distributions.Bernoulli(logits=logits_per_cell) # shape (batch_size, 64*32)
+ cell_log_prob = cell_dist.log_prob(labels_per_cell.type(torch.float32)) # shape(batch_size, 64*32)
+
+ cell_loss = -torch.sum(cell_log_prob * column_mask * cell_mask, dim=1)
+
+ # We need to normalize the loss by the number of cells in the column.
+ cell_loss /= torch.sum(column_mask * cell_mask, dim=1) + EPSILON_ZERO_DIVISION
+
+ selection_loss_per_example = column_loss_per_example
+ selection_loss_per_example += torch.where(
+ no_cell_selected.view(selection_loss_per_example.size()),
+ torch.zeros_like(selection_loss_per_example),
+ cell_loss,
+ )
+
+ # Set the probs outside the selected column (selected by the *model*)
+ # to 0. This ensures backwards compatibility with models that select
+ # cells from multiple columns.
+ selected_column_id = torch.as_tensor(
+ torch.argmax(column_logits, dim=-1), dtype=torch.long, device=column_logits.device
+ ) # shape (batch_size,)
+
+ # selected_column_mask: shape (batch_size, 64*32), equal to 1 if cell belongs to column selected by the model
+ selected_column_mask = torch.as_tensor(
+ torch.eq(column_id_for_cells, torch.unsqueeze(selected_column_id, dim=-1)),
+ dtype=torch.float32,
+ device=selected_column_id.device,
+ )
+
+ # Never select cells with the special column id 0.
+ selected_column_mask = torch.where(
+ torch.eq(column_id_for_cells, 0).view(selected_column_mask.size()),
+ torch.zeros_like(selected_column_mask),
+ selected_column_mask,
+ )
+ new_logits_per_cell = logits_per_cell + CLOSE_ENOUGH_TO_LOG_ZERO * (1.0 - cell_mask * selected_column_mask)
+ logits = gather(new_logits_per_cell, cell_index)
+
+ return selection_loss_per_example, logits
+
+
+def compute_token_logits(sequence_output, temperature, output_weights, output_bias):
+ """
+ Computes logits per token
+
+ Args:
+ sequence_output (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Also known as last_hidden_state. Sequence of hidden-states at the output of the last layer of the model.
+ temperature (`float`):
+ Temperature for the Bernoulli distribution.
+ output_weights (`torch.FloatTensor` of shape `(hidden_size,)`):
+ Weights of the linear layer for cell selection.
+ output_bias (`torch.FloatTensor` of shape `()`):
+ Bias of the linear layer for cell selection
+
+ Returns:
+ logits (`torch.FloatTensor` of shape `(batch_size, sequence_length)`): Logits per token.
+ """
+ logits = (torch.einsum("bsj,j->bs", sequence_output, output_weights) + output_bias) / temperature
+
+ return logits
+
+
+def _calculate_aggregate_mask(answer, pooled_output, cell_selection_preference, labels, aggregation_classifier):
+ """
+ Finds examples where the model should select cells with no aggregation.
+
+ Returns a mask that determines for which examples should the model select answers directly from the table, without
+ any aggregation function. If the answer is a piece of text the case is unambiguous as aggregation functions only
+ apply to numbers. If the answer is a number but does not appear in the table then we must use some aggregation
+ case. The ambiguous case is when the answer is a number that also appears in the table. In this case we use the
+ aggregation function probabilities predicted by the model to decide whether to select or aggregate. The threshold
+ for this is a hyperparameter *cell_selection_preference*
+
+ Args:
+ answer (`torch.FloatTensor` of shape `(batch_size, )`):
+ Answer for every example in the batch. Nan if there is no scalar answer.
+ pooled_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`):
+ Output of the pooler (BertPooler) on top of the encoder layer.
+ cell_selection_preference (`float`):
+ Preference for cell selection in ambiguous cases.
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Labels per token. aggregation_classifier (`torch.nn.Linear`): Aggregation head
+
+ Returns:
+ aggregate_mask (`torch.FloatTensor` of shape `(batch_size,)`): A mask set to 1 for examples that should use
+ aggregation functions.
+ """
+ # torch.FloatTensor(batch_size,)
+ aggregate_mask_init = torch.logical_not(torch.isnan(answer)).type(torch.FloatTensor).to(answer.device)
+ logits_aggregation = aggregation_classifier(pooled_output)
+ dist_aggregation = torch.distributions.categorical.Categorical(logits=logits_aggregation)
+ # Index 0 corresponds to "no aggregation".
+ aggregation_ops_total_mass = torch.sum(dist_aggregation.probs[:, 1:], dim=1)
+
+ # Cell selection examples according to current model.
+ is_pred_cell_selection = aggregation_ops_total_mass <= cell_selection_preference
+
+ # Examples with non-empty cell selection supervision.
+ is_cell_supervision_available = torch.sum(labels, dim=1) > 0
+
+ aggregate_mask = torch.where(
+ torch.logical_and(is_pred_cell_selection, is_cell_supervision_available).view(aggregate_mask_init.size()),
+ torch.zeros_like(aggregate_mask_init, dtype=torch.float32),
+ aggregate_mask_init,
+ )
+
+ aggregate_mask = aggregate_mask.detach()
+
+ return aggregate_mask
+
+
+def _calculate_aggregation_loss_known(
+ logits_aggregation, aggregate_mask, aggregation_labels, use_answer_as_supervision, num_aggregation_labels
+):
+ """
+ Calculates aggregation loss when its type is known during training.
+
+ In the weakly supervised setting, the only known information is that for cell selection examples, "no aggregation"
+ should be predicted. For other examples (those that require aggregation), no loss is accumulated. In the setting
+ where aggregation type is always known, standard cross entropy loss is accumulated for all examples
+
+ Args:
+ logits_aggregation (`torch.FloatTensor` of shape `(batch_size, num_aggregation_labels)`):
+ Logits per aggregation operation.
+ aggregate_mask (`torch.FloatTensor` of shape `(batch_size, )`):
+ A mask set to 1 for examples that should use aggregation functions.
+ aggregation_labels (`torch.LongTensor` of shape `(batch_size, )`):
+ Aggregation function id for every example in the batch.
+ use_answer_as_supervision (`bool`, *optional*):
+ Whether to use the answer as the only supervision for aggregation examples.
+ num_aggregation_labels (`int`, *optional*, defaults to 0):
+ The number of aggregation operators to predict.
+
+ Returns:
+ aggregation_loss_known (`torch.FloatTensor` of shape `(batch_size,)`): Aggregation loss (when its type is known
+ during training) per example.
+ """
+ if use_answer_as_supervision:
+ # Prepare "no aggregation" targets for cell selection examples.
+ target_aggregation = torch.zeros_like(aggregate_mask, dtype=torch.long)
+ else:
+ # Use aggregation supervision as the target.
+ target_aggregation = aggregation_labels
+
+ one_hot_labels = nn.functional.one_hot(target_aggregation, num_classes=num_aggregation_labels).type(torch.float32)
+ log_probs = nn.functional.log_softmax(logits_aggregation, dim=-1)
+
+ # torch.FloatTensor[batch_size]
+ per_example_aggregation_intermediate = -torch.sum(one_hot_labels * log_probs, dim=-1)
+ if use_answer_as_supervision:
+ # Accumulate loss only for examples requiring cell selection
+ # (no aggregation).
+ return per_example_aggregation_intermediate * (1 - aggregate_mask)
+ else:
+ return per_example_aggregation_intermediate
+
+
+def _calculate_aggregation_loss_unknown(logits_aggregation, aggregate_mask):
+ """
+ Calculates aggregation loss in the case of answer supervision.
+
+ Args:
+ logits_aggregation (`torch.FloatTensor` of shape `(batch_size, num_aggregation_labels)`):
+ Logits per aggregation operation.
+ aggregate_mask (`torch.FloatTensor` of shape `(batch_size, )`):
+ A mask set to 1 for examples that should use aggregation functions
+
+ Returns:
+ aggregation_loss_unknown (`torch.FloatTensor` of shape `(batch_size,)`): Aggregation loss (in case of answer
+ supervision) per example.
+ """
+ dist_aggregation = torch.distributions.categorical.Categorical(logits=logits_aggregation)
+ # Index 0 corresponds to "no aggregation".
+ aggregation_ops_total_mass = torch.sum(dist_aggregation.probs[:, 1:], dim=1)
+ # Predict some aggregation in case of an answer that needs aggregation.
+ # This increases the probability of all aggregation functions, in a way
+ # similar to MML, but without considering whether the function gives the
+ # correct answer.
+ return -torch.log(aggregation_ops_total_mass) * aggregate_mask
+
+
+def _calculate_aggregation_loss(
+ logits_aggregation,
+ aggregate_mask,
+ aggregation_labels,
+ use_answer_as_supervision,
+ num_aggregation_labels,
+ aggregation_loss_weight,
+):
+ """
+ Calculates the aggregation loss per example.
+
+ Args:
+ logits_aggregation (`torch.FloatTensor` of shape `(batch_size, num_aggregation_labels)`):
+ Logits per aggregation operation.
+ aggregate_mask (`torch.FloatTensor` of shape `(batch_size, )`):
+ A mask set to 1 for examples that should use aggregation functions.
+ aggregation_labels (`torch.LongTensor` of shape `(batch_size, )`):
+ Aggregation function id for every example in the batch.
+ use_answer_as_supervision (`bool`, *optional*):
+ Whether to use the answer as the only supervision for aggregation examples.
+ num_aggregation_labels (`int`, *optional*, defaults to 0):
+ The number of aggregation operators to predict.
+ aggregation_loss_weight (`float`, *optional*, defaults to 1.0):
+ Importance weight for the aggregation loss.
+
+ Returns:
+ aggregation_loss (`torch.FloatTensor` of shape `(batch_size,)`): Aggregation loss per example.
+ """
+ per_example_aggregation_loss = _calculate_aggregation_loss_known(
+ logits_aggregation, aggregate_mask, aggregation_labels, use_answer_as_supervision, num_aggregation_labels
+ )
+
+ if use_answer_as_supervision:
+ # Add aggregation loss for numeric answers that need aggregation.
+ per_example_aggregation_loss += _calculate_aggregation_loss_unknown(logits_aggregation, aggregate_mask)
+ return aggregation_loss_weight * per_example_aggregation_loss
+
+
+def _calculate_expected_result(
+ dist_per_cell, numeric_values, numeric_values_scale, input_mask_float, logits_aggregation, config
+):
+ """
+ Calculates the expected result given cell and aggregation probabilities.
+
+ Args:
+ dist_per_cell (`torch.distributions.Bernoulli`):
+ Cell selection distribution for each cell.
+ numeric_values (`torch.FloatTensor` of shape `(batch_size, seq_length)`):
+ Numeric values of every token. Nan for tokens which are not numeric values.
+ numeric_values_scale (`torch.FloatTensor` of shape `(batch_size, seq_length)`):
+ Scale of the numeric values of every token.
+ input_mask_float (`torch.FloatTensor` of shape `(batch_size, seq_length)`):
+ Mask for the table, without question tokens and table headers.
+ logits_aggregation (`torch.FloatTensor` of shape `(batch_size, num_aggregation_labels)`):
+ Logits per aggregation operation.
+ config ([`TapasConfig`]):
+ Model configuration class with all the hyperparameters of the model
+
+ Returns:
+ expected_result (`torch.FloatTensor` of shape `(batch_size,)`): The expected result per example.
+ """
+ if config.use_gumbel_for_cells:
+ gumbel_dist = torch.distributions.RelaxedBernoulli(
+ # The token logits where already divided by the temperature and used for
+ # computing cell selection errors so we need to multiply it again here
+ temperature=config.temperature,
+ logits=dist_per_cell.logits * config.temperature,
+ )
+ scaled_probability_per_cell = gumbel_dist.sample()
+ else:
+ scaled_probability_per_cell = dist_per_cell.probs
+
+ # <float32>[batch_size, seq_length]
+ scaled_probability_per_cell = (scaled_probability_per_cell / numeric_values_scale) * input_mask_float
+ count_result = torch.sum(scaled_probability_per_cell, dim=1)
+ numeric_values_masked = torch.where(
+ torch.isnan(numeric_values), torch.zeros_like(numeric_values), numeric_values
+ ) # Mask non-numeric table values to zero.
+ sum_result = torch.sum(scaled_probability_per_cell * numeric_values_masked, dim=1)
+ avg_approximation = config.average_approximation_function
+ if avg_approximation == AverageApproximationFunction.RATIO:
+ average_result = sum_result / (count_result + EPSILON_ZERO_DIVISION)
+ elif avg_approximation == AverageApproximationFunction.FIRST_ORDER:
+ # The sum of all probabilities except that correspond to other cells
+ # Ex here stands for expectation, more explicitly the expectation of the sum of N-1 Bernoulli random variables plus
+ # the constant 1, which is computed as adding all N expected values and subtracting the extra one. It corresponds to X_c
+ # in Appendix D of the original TAPAS paper which is trying to approximate the average of a random set.
+ ex = torch.sum(scaled_probability_per_cell, dim=1, keepdim=True) - scaled_probability_per_cell + 1
+ average_result = torch.sum(numeric_values_masked * scaled_probability_per_cell / ex, dim=1)
+ elif avg_approximation == AverageApproximationFunction.SECOND_ORDER:
+ # The sum of all probabilities except that correspond to other cells
+ ex = torch.sum(scaled_probability_per_cell, dim=1, keepdim=True) - scaled_probability_per_cell + 1
+ pointwise_var = scaled_probability_per_cell * (1 - scaled_probability_per_cell)
+ var = torch.sum(pointwise_var, dim=1, keepdim=True) - pointwise_var
+
+ multiplier = (var / torch.square(ex) + 1) / ex
+ average_result = torch.sum(numeric_values_masked * scaled_probability_per_cell * multiplier, dim=1)
+ else:
+ raise ValueError(f"Invalid average_approximation_function: {config.average_approximation_function}")
+
+ if config.use_gumbel_for_aggregation:
+ gumbel_dist = torch.distributions.RelaxedOneHotCategorical(
+ config.aggregation_temperature, logits=logits_aggregation[:, 1:]
+ )
+ # <float32>[batch_size, num_aggregation_labels - 1]
+ aggregation_op_only_probs = gumbel_dist.sample()
+ else:
+ # <float32>[batch_size, num_aggregation_labels - 1]
+ aggregation_op_only_probs = nn.functional.softmax(
+ logits_aggregation[:, 1:] / config.aggregation_temperature, dim=-1
+ )
+
+ all_results = torch.cat(
+ [
+ torch.unsqueeze(sum_result, dim=1),
+ torch.unsqueeze(average_result, dim=1),
+ torch.unsqueeze(count_result, dim=1),
+ ],
+ dim=1,
+ )
+
+ expected_result = torch.sum(all_results * aggregation_op_only_probs, dim=1)
+ return expected_result
+
+
+# PyTorch does not currently support Huber loss with custom delta so we define it ourself
+def huber_loss(input, target, delta: float = 1.0):
+ errors = torch.abs(input - target) # shape (batch_size,)
+ return torch.where(errors < delta, 0.5 * errors**2, errors * delta - (0.5 * delta**2))
+
+
+def _calculate_regression_loss(
+ answer,
+ aggregate_mask,
+ dist_per_cell,
+ numeric_values,
+ numeric_values_scale,
+ input_mask_float,
+ logits_aggregation,
+ config,
+):
+ """
+ Calculates the regression loss per example.
+
+ Args:
+ answer (`torch.FloatTensor` of shape `(batch_size,)`):
+ Answer for every example in the batch. Nan if there is no scalar answer.
+ aggregate_mask (`torch.FloatTensor` of shape `(batch_size,)`):
+ A mask set to 1 for examples that should use aggregation functions.
+ dist_per_cell (`torch.distributions.Bernoulli`):
+ Cell selection distribution for each cell.
+ numeric_values (`torch.FloatTensor` of shape `(batch_size, seq_length)`):
+ Numeric values of every token. Nan for tokens which are not numeric values.
+ numeric_values_scale (`torch.FloatTensor` of shape `(batch_size, seq_length)`):
+ Scale of the numeric values of every token.
+ input_mask_float (`torch.FloatTensor` of shape `(batch_size, seq_length)`):
+ Mask for the table, without question tokens and table headers.
+ logits_aggregation (`torch.FloatTensor` of shape `(batch_size, num_aggregation_labels)`):
+ Logits per aggregation operation.
+ config ([`TapasConfig`]):
+ Model configuration class with all the parameters of the model
+
+ Returns:
+ per_example_answer_loss_scaled (`torch.FloatTensor` of shape `(batch_size,)`): Scales answer loss for each
+ example in the batch. large_answer_loss_mask (`torch.FloatTensor` of shape `(batch_size,)`): A mask which is 1
+ for examples for which their answer loss is larger than the answer_loss_cutoff.
+ """
+ # float32 (batch_size,)
+ expected_result = _calculate_expected_result(
+ dist_per_cell, numeric_values, numeric_values_scale, input_mask_float, logits_aggregation, config
+ )
+
+ # float32 (batch_size,)
+ answer_masked = torch.where(torch.isnan(answer), torch.zeros_like(answer), answer)
+
+ if config.use_normalized_answer_loss:
+ normalizer = (torch.max(torch.abs(expected_result), torch.abs(answer_masked)) + EPSILON_ZERO_DIVISION).detach()
+
+ normalized_answer_masked = answer_masked / normalizer
+ normalized_expected_result = expected_result / normalizer
+ per_example_answer_loss = huber_loss(
+ normalized_expected_result * aggregate_mask, normalized_answer_masked * aggregate_mask
+ )
+ else:
+ per_example_answer_loss = huber_loss(
+ expected_result * aggregate_mask, answer_masked * aggregate_mask, delta=config.huber_loss_delta
+ )
+
+ if config.answer_loss_cutoff is None:
+ large_answer_loss_mask = torch.ones_like(per_example_answer_loss, dtype=torch.float32)
+
+ else:
+ large_answer_loss_mask = torch.where(
+ per_example_answer_loss > config.answer_loss_cutoff,
+ torch.zeros_like(per_example_answer_loss, dtype=torch.float32),
+ torch.ones_like(per_example_answer_loss, dtype=torch.float32),
+ )
+ per_example_answer_loss_scaled = config.answer_loss_importance * (per_example_answer_loss * aggregate_mask)
+
+ return per_example_answer_loss_scaled, large_answer_loss_mask
+
+
+__all__ = [
+ "TapasForMaskedLM",
+ "TapasForQuestionAnswering",
+ "TapasForSequenceClassification",
+ "TapasModel",
+ "TapasPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/tapas/tokenization_tapas.py b/lib/python3.11/site-packages/transformers/models/tapas/tokenization_tapas.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d100c8f6f4dad3ceb44d4252ca6ab5c712fd7eb
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tapas/tokenization_tapas.py
@@ -0,0 +1,2786 @@
+# Copyright 2020 Google Research and 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.
+"""Tokenization class for TAPAS model."""
+
+import collections
+import datetime
+import enum
+import itertools
+import math
+import os
+import re
+import unicodedata
+from collections.abc import Callable, Generator
+from dataclasses import dataclass
+from typing import Union
+
+import numpy as np
+
+from ...tokenization_python import PreTrainedTokenizer, Trie, _is_control, _is_punctuation, _is_whitespace
+from ...tokenization_utils_base import (
+ ENCODE_KWARGS_DOCSTRING,
+ VERY_LARGE_INTEGER,
+ BatchEncoding,
+ EncodedInput,
+ PreTokenizedInput,
+ TextInput,
+)
+from ...utils import ExplicitEnum, PaddingStrategy, TensorType, add_end_docstrings, is_pandas_available, logging
+
+
+if is_pandas_available():
+ import pandas as pd
+
+logger = logging.get_logger(__name__)
+
+
+VOCAB_FILES_NAMES = {"vocab_file": "vocab.txt"}
+
+
+class TapasTruncationStrategy(ExplicitEnum):
+ """
+ Possible values for the `truncation` argument in [`~TapasTokenizer.__call__`]. Useful for tab-completion in an IDE.
+ """
+
+ DROP_ROWS_TO_FIT = "drop_rows_to_fit"
+ DO_NOT_TRUNCATE = "do_not_truncate"
+
+
+TableValue = collections.namedtuple("TokenValue", ["token", "column_id", "row_id"])
+
+
+@dataclass(frozen=True)
+class TokenCoordinates:
+ column_index: int
+ row_index: int
+ token_index: int
+
+
+@dataclass
+class TokenizedTable:
+ rows: list[list[list[str]]]
+ selected_tokens: list[TokenCoordinates]
+
+
+@dataclass(frozen=True)
+class SerializedExample:
+ tokens: list[str]
+ column_ids: list[int]
+ row_ids: list[int]
+ segment_ids: list[int]
+
+
+def _is_inner_wordpiece(token: str):
+ return token.startswith("##")
+
+
+def load_vocab(vocab_file):
+ """Loads a vocabulary file into a dictionary."""
+ vocab = collections.OrderedDict()
+ with open(vocab_file, "r", encoding="utf-8") as reader:
+ tokens = reader.readlines()
+ for index, token in enumerate(tokens):
+ token = token.rstrip("\n")
+ vocab[token] = index
+ return vocab
+
+
+def whitespace_tokenize(text):
+ """Runs basic whitespace cleaning and splitting on a piece of text."""
+ text = text.strip()
+ if not text:
+ return []
+ tokens = text.split()
+ return tokens
+
+
+TAPAS_ENCODE_PLUS_ADDITIONAL_KWARGS_DOCSTRING = r"""
+ add_special_tokens (`bool`, *optional*, defaults to `True`):
+ Whether or not to encode the sequences with the special tokens relative to their model.
+ padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):
+ Activates and controls padding. Accepts the following values:
+
+ - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+ sequence if provided).
+ - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
+ acceptable input length for the model if that argument is not provided.
+ - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
+ lengths).
+ truncation (`bool`, `str` or [`TapasTruncationStrategy`], *optional*, defaults to `False`):
+ Activates and controls truncation. Accepts the following values:
+
+ - `True` or `'drop_rows_to_fit'`: Truncate to a maximum length specified with the argument `max_length`
+ or to the maximum acceptable input length for the model if that argument is not provided. This will
+ truncate row by row, removing rows from the table.
+ - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths
+ greater than the model maximum admissible input size).
+ max_length (`int`, *optional*):
+ Controls the maximum length to use by one of the truncation/padding parameters.
+
+ If left unset or set to `None`, this will use the predefined model maximum length if a maximum length
+ is required by one of the truncation/padding parameters. If the model has no specific maximum input
+ length (like XLNet) truncation/padding to a maximum length will be deactivated.
+ is_split_into_words (`bool`, *optional*, defaults to `False`):
+ Whether or not the input is already pre-tokenized (e.g., split into words). If set to `True`, the
+ tokenizer assumes the input is already split into words (for instance, by splitting it on whitespace)
+ which it will tokenize. This is useful for NER or token classification.
+ pad_to_multiple_of (`int`, *optional*):
+ If set will pad the sequence to a multiple of the provided value. This is especially useful to enable
+ the use of Tensor Cores on NVIDIA hardware with compute capability `>= 7.5` (Volta).
+ return_tensors (`str` or [`~utils.TensorType`], *optional*):
+ If set, will return tensors instead of list of python integers. Acceptable values are:
+
+ - `'pt'`: Return PyTorch `torch.Tensor` objects.
+ - `'np'`: Return Numpy `np.ndarray` objects.
+"""
+
+
+class TapasTokenizer(PreTrainedTokenizer):
+ r"""
+ Construct a TAPAS tokenizer. Based on WordPiece. Flattens a table and one or more related sentences to be used by
+ TAPAS models.
+
+ This tokenizer inherits from [`PreTrainedTokenizer`] which contains most of the main methods. Users should refer to
+ this superclass for more information regarding those methods. [`TapasTokenizer`] creates several token type ids to
+ encode tabular structure. To be more precise, it adds 7 token type ids, in the following order: `segment_ids`,
+ `column_ids`, `row_ids`, `prev_labels`, `column_ranks`, `inv_column_ranks` and `numeric_relations`:
+
+ - segment_ids: indicate whether a token belongs to the question (0) or the table (1). 0 for special tokens and
+ padding.
+ - column_ids: indicate to which column of the table a token belongs (starting from 1). Is 0 for all question
+ tokens, special tokens and padding.
+ - row_ids: indicate to which row of the table a token belongs (starting from 1). Is 0 for all question tokens,
+ special tokens and padding. Tokens of column headers are also 0.
+ - prev_labels: indicate whether a token was (part of) an answer to the previous question (1) or not (0). Useful in
+ a conversational setup (such as SQA).
+ - column_ranks: indicate the rank of a table token relative to a column, if applicable. For example, if you have a
+ column "number of movies" with values 87, 53 and 69, then the column ranks of these tokens are 3, 1 and 2
+ respectively. 0 for all question tokens, special tokens and padding.
+ - inv_column_ranks: indicate the inverse rank of a table token relative to a column, if applicable. For example, if
+ you have a column "number of movies" with values 87, 53 and 69, then the inverse column ranks of these tokens are
+ 1, 3 and 2 respectively. 0 for all question tokens, special tokens and padding.
+ - numeric_relations: indicate numeric relations between the question and the tokens of the table. 0 for all
+ question tokens, special tokens and padding.
+
+ [`TapasTokenizer`] runs end-to-end tokenization on a table and associated sentences: punctuation splitting and
+ wordpiece.
+
+ Args:
+ vocab_file (`str`):
+ File containing the vocabulary.
+ do_lower_case (`bool`, *optional*, defaults to `True`):
+ Whether or not to lowercase the input when tokenizing.
+ do_basic_tokenize (`bool`, *optional*, defaults to `True`):
+ Whether or not to do basic tokenization before WordPiece.
+ never_split (`Iterable`, *optional*):
+ Collection of tokens which will never be split during tokenization. Only has an effect when
+ `do_basic_tokenize=True`
+ unk_token (`str`, *optional*, defaults to `"[UNK]"`):
+ The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
+ token instead.
+ sep_token (`str`, *optional*, defaults to `"[SEP]"`):
+ The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for
+ sequence classification or for a text and a question for question answering. It is also used as the last
+ token of a sequence built with special tokens.
+ pad_token (`str`, *optional*, defaults to `"[PAD]"`):
+ The token used for padding, for example when batching sequences of different lengths.
+ cls_token (`str`, *optional*, defaults to `"[CLS]"`):
+ The classifier token which is used when doing sequence classification (classification of the whole sequence
+ instead of per-token classification). It is the first token of the sequence when built with special tokens.
+ mask_token (`str`, *optional*, defaults to `"[MASK]"`):
+ The token used for masking values. This is the token used when training this model with masked language
+ modeling. This is the token which the model will try to predict.
+ empty_token (`str`, *optional*, defaults to `"[EMPTY]"`):
+ The token used for empty cell values in a table. Empty cell values include "", "n/a", "nan" and "?".
+ tokenize_chinese_chars (`bool`, *optional*, defaults to `True`):
+ Whether or not to tokenize Chinese characters. This should likely be deactivated for Japanese (see this
+ [issue](https://github.com/huggingface/transformers/issues/328)).
+ strip_accents (`bool`, *optional*):
+ Whether or not to strip all accents. If this option is not specified, then it will be determined by the
+ value for `lowercase` (as in the original BERT).
+ cell_trim_length (`int`, *optional*, defaults to -1):
+ If > 0: Trim cells so that the length is <= this value. Also disables further cell trimming, should thus be
+ used with `truncation` set to `True`.
+ max_column_id (`int`, *optional*):
+ Max column id to extract.
+ max_row_id (`int`, *optional*):
+ Max row id to extract.
+ strip_column_names (`bool`, *optional*, defaults to `False`):
+ Whether to add empty strings instead of column names.
+ update_answer_coordinates (`bool`, *optional*, defaults to `False`):
+ Whether to recompute the answer coordinates from the answer text.
+ min_question_length (`int`, *optional*):
+ Minimum length of each question in terms of tokens (will be skipped otherwise).
+ max_question_length (`int`, *optional*):
+ Maximum length of each question in terms of tokens (will be skipped otherwise).
+ clean_up_tokenization_spaces (`bool`, *optional*, defaults to `True`):
+ Whether or not to cleanup spaces after decoding, cleanup consists in removing potential artifacts like
+ extra spaces.
+ """
+
+ model_input_names = ["input_ids", "attention_mask", "token_type_ids"]
+ vocab_files_names = VOCAB_FILES_NAMES
+
+ def __init__(
+ self,
+ vocab_file,
+ do_lower_case=True,
+ do_basic_tokenize=True,
+ never_split=None,
+ unk_token="[UNK]",
+ sep_token="[SEP]",
+ pad_token="[PAD]",
+ cls_token="[CLS]",
+ mask_token="[MASK]",
+ empty_token="[EMPTY]",
+ tokenize_chinese_chars=True,
+ strip_accents=None,
+ cell_trim_length: int = -1,
+ max_column_id: int | None = None,
+ max_row_id: int | None = None,
+ strip_column_names: bool = False,
+ update_answer_coordinates: bool = False,
+ min_question_length=None,
+ max_question_length=None,
+ model_max_length: int = 512,
+ additional_special_tokens: list[str] | None = None,
+ clean_up_tokenization_spaces=True,
+ **kwargs,
+ ):
+ if not is_pandas_available():
+ raise ImportError("Pandas is required for the TAPAS tokenizer.")
+
+ if additional_special_tokens is not None:
+ if empty_token not in additional_special_tokens:
+ additional_special_tokens.append(empty_token)
+ else:
+ additional_special_tokens = [empty_token]
+
+ if not os.path.isfile(vocab_file):
+ raise ValueError(
+ f"Can't find a vocabulary file at path '{vocab_file}'. To load the vocabulary from a Google pretrained"
+ " model use `tokenizer = BertTokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`"
+ )
+ self.vocab = load_vocab(vocab_file)
+ self.ids_to_tokens = collections.OrderedDict([(ids, tok) for tok, ids in self.vocab.items()])
+ self.do_basic_tokenize = do_basic_tokenize
+ if do_basic_tokenize:
+ self.basic_tokenizer = BasicTokenizer(
+ do_lower_case=do_lower_case,
+ never_split=never_split,
+ tokenize_chinese_chars=tokenize_chinese_chars,
+ strip_accents=strip_accents,
+ )
+ self.wordpiece_tokenizer = WordpieceTokenizer(vocab=self.vocab, unk_token=str(unk_token))
+
+ # Additional properties
+ self.cell_trim_length = cell_trim_length
+ self.max_column_id = (
+ max_column_id
+ if max_column_id is not None
+ else model_max_length
+ if model_max_length is not None
+ else VERY_LARGE_INTEGER
+ )
+ self.max_row_id = (
+ max_row_id
+ if max_row_id is not None
+ else model_max_length
+ if model_max_length is not None
+ else VERY_LARGE_INTEGER
+ )
+ self.strip_column_names = strip_column_names
+ self.update_answer_coordinates = update_answer_coordinates
+ self.min_question_length = min_question_length
+ self.max_question_length = max_question_length
+
+ super().__init__(
+ do_lower_case=do_lower_case,
+ do_basic_tokenize=do_basic_tokenize,
+ never_split=never_split,
+ unk_token=unk_token,
+ sep_token=sep_token,
+ pad_token=pad_token,
+ cls_token=cls_token,
+ mask_token=mask_token,
+ empty_token=empty_token,
+ tokenize_chinese_chars=tokenize_chinese_chars,
+ strip_accents=strip_accents,
+ cell_trim_length=cell_trim_length,
+ max_column_id=max_column_id,
+ max_row_id=max_row_id,
+ strip_column_names=strip_column_names,
+ update_answer_coordinates=update_answer_coordinates,
+ min_question_length=min_question_length,
+ max_question_length=max_question_length,
+ model_max_length=model_max_length,
+ additional_special_tokens=additional_special_tokens,
+ clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+ **kwargs,
+ )
+
+ # Tests override the vocab while reusing a tokenizer_config.json coming from a pretrained model.
+ # This can register base vocab tokens (like [UNK]) as added tokens with mismatched ids (e.g. 100)
+ # and breaks assumptions on token ordering. Drop any added-token entry that overlaps with the vocab
+ # so these tokens rely on the vocab-provided ids.
+ removed_overlap = False
+ for token, added_id in list(self._added_tokens_encoder.items()):
+ if token in self.vocab:
+ self._added_tokens_encoder.pop(token, None)
+ self._added_tokens_decoder.pop(added_id, None)
+ removed_overlap = True
+ if removed_overlap:
+ self.tokens_trie = Trie()
+ self._update_trie()
+
+ @property
+ def do_lower_case(self):
+ return self.basic_tokenizer.do_lower_case
+
+ @property
+ def vocab_size(self):
+ return len(self.vocab)
+
+ def get_vocab(self):
+ return dict(self.vocab, **self.added_tokens_encoder)
+
+ def _tokenize(self, text):
+ if format_text(text) == EMPTY_TEXT:
+ return [self.extra_special_tokens[0]]
+ split_tokens = []
+ if self.do_basic_tokenize:
+ for token in self.basic_tokenizer.tokenize(text, never_split=self.all_special_tokens):
+ # If the token is part of the never_split set
+ if token in self.basic_tokenizer.never_split:
+ split_tokens.append(token)
+ else:
+ split_tokens += self.wordpiece_tokenizer.tokenize(token)
+ else:
+ split_tokens = self.wordpiece_tokenizer.tokenize(text)
+ return split_tokens
+
+ def _convert_token_to_id(self, token):
+ """Converts a token (str) in an id using the vocab."""
+ return self.vocab.get(token, self.vocab.get(self.unk_token))
+
+ def _convert_id_to_token(self, index):
+ """Converts an index (integer) in a token (str) using the vocab."""
+ return self.ids_to_tokens.get(index, self.unk_token)
+
+ def convert_tokens_to_string(self, tokens):
+ """Converts a sequence of tokens (string) in a single string."""
+ out_string = " ".join(tokens).replace(" ##", "").strip()
+ return out_string
+
+ def save_vocabulary(self, save_directory: str, filename_prefix: str | None = None) -> tuple[str]:
+ index = 0
+ if os.path.isdir(save_directory):
+ vocab_file = os.path.join(
+ save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]
+ )
+ else:
+ vocab_file = (filename_prefix + "-" if filename_prefix else "") + save_directory
+ with open(vocab_file, "w", encoding="utf-8") as writer:
+ for token, token_index in sorted(self.vocab.items(), key=lambda kv: kv[1]):
+ if index != token_index:
+ logger.warning(
+ f"Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive."
+ " Please check that the vocabulary is not corrupted!"
+ )
+ index = token_index
+ writer.write(token + "\n")
+ index += 1
+ return (vocab_file,)
+
+ def create_attention_mask_from_sequences(self, query_ids: list[int], table_values: list[TableValue]) -> list[int]:
+ """
+ Creates the attention mask according to the query token IDs and a list of table values.
+
+ Args:
+ query_ids (`list[int]`): list of token IDs corresponding to the ID.
+ table_values (`list[TableValue]`): lift of table values, which are named tuples containing the
+ token value, the column ID and the row ID of said token.
+
+ Returns:
+ `list[int]`: List of ints containing the attention mask values.
+ """
+ return [1] * (1 + len(query_ids) + 1 + len(table_values))
+
+ def create_segment_token_type_ids_from_sequences(
+ self, query_ids: list[int], table_values: list[TableValue]
+ ) -> list[int]:
+ """
+ Creates the segment token type IDs according to the query token IDs and a list of table values.
+
+ Args:
+ query_ids (`list[int]`): list of token IDs corresponding to the ID.
+ table_values (`list[TableValue]`): lift of table values, which are named tuples containing the
+ token value, the column ID and the row ID of said token.
+
+ Returns:
+ `list[int]`: List of ints containing the segment token type IDs values.
+ """
+ table_ids = list(zip(*table_values))[0] if table_values else []
+ return [0] * (1 + len(query_ids) + 1) + [1] * len(table_ids)
+
+ def create_column_token_type_ids_from_sequences(
+ self, query_ids: list[int], table_values: list[TableValue]
+ ) -> list[int]:
+ """
+ Creates the column token type IDs according to the query token IDs and a list of table values.
+
+ Args:
+ query_ids (`list[int]`): list of token IDs corresponding to the ID.
+ table_values (`list[TableValue]`): lift of table values, which are named tuples containing the
+ token value, the column ID and the row ID of said token.
+
+ Returns:
+ `list[int]`: List of ints containing the column token type IDs values.
+ """
+ table_column_ids = list(zip(*table_values))[1] if table_values else []
+ return [0] * (1 + len(query_ids) + 1) + list(table_column_ids)
+
+ def create_row_token_type_ids_from_sequences(
+ self, query_ids: list[int], table_values: list[TableValue]
+ ) -> list[int]:
+ """
+ Creates the row token type IDs according to the query token IDs and a list of table values.
+
+ Args:
+ query_ids (`list[int]`): list of token IDs corresponding to the ID.
+ table_values (`list[TableValue]`): lift of table values, which are named tuples containing the
+ token value, the column ID and the row ID of said token.
+
+ Returns:
+ `list[int]`: List of ints containing the row token type IDs values.
+ """
+ table_row_ids = list(zip(*table_values))[2] if table_values else []
+ return [0] * (1 + len(query_ids) + 1) + list(table_row_ids)
+
+ def build_inputs_with_special_tokens(
+ self, token_ids_0: list[int], token_ids_1: list[int] | None = None
+ ) -> list[int]:
+ """
+ Build model inputs from a question and flattened table for question answering or sequence classification tasks
+ by concatenating and adding special tokens.
+
+ Args:
+ token_ids_0 (`list[int]`): The ids of the question.
+ token_ids_1 (`list[int]`, *optional*): The ids of the flattened table.
+
+ Returns:
+ `list[int]`: The model input with special tokens.
+ """
+ if token_ids_1 is None:
+ raise ValueError("With TAPAS, you must provide both question IDs and table IDs.")
+
+ return [self.cls_token_id] + token_ids_0 + [self.sep_token_id] + token_ids_1
+
+ def get_special_tokens_mask(
+ self, token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False
+ ) -> list[int]:
+ """
+ Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
+ special tokens using the tokenizer `prepare_for_model` method.
+
+ Args:
+ token_ids_0 (`list[int]`):
+ List of question IDs.
+ token_ids_1 (`list[int]`, *optional*):
+ List of flattened table IDs.
+ already_has_special_tokens (`bool`, *optional*, defaults to `False`):
+ Whether or not the token list is already formatted with special tokens for the model.
+
+ Returns:
+ `list[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
+ """
+
+ if already_has_special_tokens:
+ return super().get_special_tokens_mask(
+ token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
+ )
+
+ if token_ids_1 is not None:
+ return [1] + ([0] * len(token_ids_0)) + [1] + ([0] * len(token_ids_1))
+ return [1] + ([0] * len(token_ids_0)) + [1]
+
+ @add_end_docstrings(TAPAS_ENCODE_PLUS_ADDITIONAL_KWARGS_DOCSTRING)
+ def __call__(
+ self,
+ table: Union["pd.DataFrame", TextInput, list[TextInput], None],
+ queries: TextInput
+ | PreTokenizedInput
+ | EncodedInput
+ | list[TextInput]
+ | list[PreTokenizedInput]
+ | list[EncodedInput]
+ | None = None,
+ answer_coordinates: list[tuple] | list[list[tuple]] | None = None,
+ answer_text: list[TextInput] | list[list[TextInput]] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TapasTruncationStrategy = False,
+ max_length: int | None = None,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = None,
+ return_attention_mask: bool | None = None,
+ return_overflowing_tokens: bool = False,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ) -> BatchEncoding:
+ """
+ Main method to tokenize and prepare for the model one or several sequence(s) related to a table.
+
+ Args:
+ table (`pd.DataFrame` or `str` or `list[str]`):
+ Table containing tabular data. Note that all cell values must be text. Use *.astype(str)* on a Pandas
+ dataframe to convert it to string. When passing a string or list of strings, those will be interpreted
+ as queries with an empty table (to support generic tokenizer tests).
+ queries (`str` or `list[str]`):
+ Question or batch of questions related to a table to be encoded. Note that in case of a batch, all
+ questions must refer to the **same** table.
+ answer_coordinates (`list[Tuple]` or `list[list[Tuple]]`, *optional*):
+ Answer coordinates of each table-question pair in the batch. In case only a single table-question pair
+ is provided, then the answer_coordinates must be a single list of one or more tuples. Each tuple must
+ be a (row_index, column_index) pair. The first data row (not the column header row) has index 0. The
+ first column has index 0. In case a batch of table-question pairs is provided, then the
+ answer_coordinates must be a list of lists of tuples (each list corresponding to a single
+ table-question pair).
+ answer_text (`list[str]` or `list[list[str]]`, *optional*):
+ Answer text of each table-question pair in the batch. In case only a single table-question pair is
+ provided, then the answer_text must be a single list of one or more strings. Each string must be the
+ answer text of a corresponding answer coordinate. In case a batch of table-question pairs is provided,
+ then the answer_coordinates must be a list of lists of strings (each list corresponding to a single
+ table-question pair).
+ """
+ if not isinstance(table, pd.DataFrame):
+ if queries is not None:
+ raise AssertionError("Table must be of type pd.DataFrame when queries are provided separately.")
+ inferred_queries = table
+ table = pd.DataFrame.from_dict({})
+ queries = inferred_queries
+
+ # Input type checking for clearer error
+ valid_query = False
+
+ # Check that query has a valid type
+ if queries is None or isinstance(queries, str):
+ valid_query = True
+ elif isinstance(queries, (list, tuple)):
+ if len(queries) == 0 or isinstance(queries[0], str):
+ valid_query = True
+
+ if not valid_query:
+ raise ValueError(
+ "queries input must of type `str` (single example), `list[str]` (batch or single pretokenized"
+ " example). "
+ )
+ is_batched = isinstance(queries, (list, tuple))
+
+ if is_batched:
+ return self.batch_encode_plus(
+ table=table,
+ queries=queries,
+ answer_coordinates=answer_coordinates,
+ answer_text=answer_text,
+ add_special_tokens=add_special_tokens,
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=return_offsets_mapping,
+ return_length=return_length,
+ verbose=verbose,
+ **kwargs,
+ )
+ else:
+ return self.encode_plus(
+ table=table,
+ query=queries,
+ answer_coordinates=answer_coordinates,
+ answer_text=answer_text,
+ add_special_tokens=add_special_tokens,
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=return_offsets_mapping,
+ return_length=return_length,
+ verbose=verbose,
+ **kwargs,
+ )
+
+ @add_end_docstrings(ENCODE_KWARGS_DOCSTRING, TAPAS_ENCODE_PLUS_ADDITIONAL_KWARGS_DOCSTRING)
+ def batch_encode_plus(
+ self,
+ table: "pd.DataFrame",
+ queries: list[TextInput] | list[PreTokenizedInput] | list[EncodedInput] | None = None,
+ answer_coordinates: list[list[tuple]] | None = None,
+ answer_text: list[list[TextInput]] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TapasTruncationStrategy = False,
+ max_length: int | None = None,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = None,
+ return_attention_mask: bool | None = None,
+ return_overflowing_tokens: bool = False,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ) -> BatchEncoding:
+ """
+ Prepare a table and a list of strings for the model.
+
+ <Tip warning={true}>
+
+ This method is deprecated, `__call__` should be used instead.
+
+ </Tip>
+
+ Args:
+ table (`pd.DataFrame`):
+ Table containing tabular data. Note that all cell values must be text. Use *.astype(str)* on a Pandas
+ dataframe to convert it to string.
+ queries (`list[str]`):
+ Batch of questions related to a table to be encoded. Note that all questions must refer to the **same**
+ table.
+ answer_coordinates (`list[Tuple]` or `list[list[Tuple]]`, *optional*):
+ Answer coordinates of each table-question pair in the batch. Each tuple must be a (row_index,
+ column_index) pair. The first data row (not the column header row) has index 0. The first column has
+ index 0. The answer_coordinates must be a list of lists of tuples (each list corresponding to a single
+ table-question pair).
+ answer_text (`list[str]` or `list[list[str]]`, *optional*):
+ Answer text of each table-question pair in the batch. In case a batch of table-question pairs is
+ provided, then the answer_coordinates must be a list of lists of strings (each list corresponding to a
+ single table-question pair). Each string must be the answer text of a corresponding answer coordinate.
+ """
+ if return_token_type_ids is not None and not add_special_tokens:
+ raise ValueError(
+ "Asking to return token_type_ids while setting add_special_tokens to False "
+ "results in an undefined behavior. Please set add_special_tokens to True or "
+ "set return_token_type_ids to None."
+ )
+
+ if (answer_coordinates and not answer_text) or (not answer_coordinates and answer_text):
+ raise ValueError("In case you provide answers, both answer_coordinates and answer_text should be provided")
+ elif answer_coordinates is None and answer_text is None:
+ answer_coordinates = answer_text = [None] * len(queries)
+
+ if "is_split_into_words" in kwargs:
+ raise NotImplementedError("Currently TapasTokenizer only supports questions as strings.")
+
+ if return_offsets_mapping:
+ raise NotImplementedError(
+ "return_offset_mapping is not available when using Python tokenizers. "
+ "To use this feature, change your tokenizer to one deriving from "
+ "transformers.PreTrainedTokenizerFast."
+ )
+
+ return self._batch_encode_plus(
+ table=table,
+ queries=queries,
+ answer_coordinates=answer_coordinates,
+ answer_text=answer_text,
+ add_special_tokens=add_special_tokens,
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=return_offsets_mapping,
+ return_length=return_length,
+ verbose=verbose,
+ **kwargs,
+ )
+
+ def _get_question_tokens(self, query):
+ """Tokenizes the query, taking into account the max and min question length."""
+
+ query_tokens = self.tokenize(query)
+ if self.max_question_length is not None and len(query_tokens) > self.max_question_length:
+ logger.warning("Skipping query as its tokens are longer than the max question length")
+ return "", []
+ if self.min_question_length is not None and len(query_tokens) < self.min_question_length:
+ logger.warning("Skipping query as its tokens are shorter than the min question length")
+ return "", []
+
+ return query, query_tokens
+
+ def _batch_encode_plus(
+ self,
+ table,
+ queries: list[TextInput] | list[PreTokenizedInput] | list[EncodedInput],
+ answer_coordinates: list[list[tuple]] | None = None,
+ answer_text: list[list[TextInput]] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TapasTruncationStrategy = False,
+ max_length: int | None = None,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = True,
+ return_attention_mask: bool | None = None,
+ return_overflowing_tokens: bool = False,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ) -> BatchEncoding:
+ table_tokens = self._tokenize_table(table)
+
+ queries_tokens = []
+ for idx, query in enumerate(queries):
+ query, query_tokens = self._get_question_tokens(query)
+ queries[idx] = query
+ queries_tokens.append(query_tokens)
+
+ batch_outputs = self._batch_prepare_for_model(
+ table,
+ queries,
+ tokenized_table=table_tokens,
+ queries_tokens=queries_tokens,
+ answer_coordinates=answer_coordinates,
+ padding=padding,
+ truncation=truncation,
+ answer_text=answer_text,
+ add_special_tokens=add_special_tokens,
+ max_length=max_length,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ prepend_batch_axis=True,
+ return_attention_mask=return_attention_mask,
+ return_token_type_ids=return_token_type_ids,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_length=return_length,
+ verbose=verbose,
+ )
+
+ return BatchEncoding(batch_outputs)
+
+ def _batch_prepare_for_model(
+ self,
+ raw_table: "pd.DataFrame",
+ raw_queries: list[TextInput] | list[PreTokenizedInput] | list[EncodedInput],
+ tokenized_table: TokenizedTable | None = None,
+ queries_tokens: list[list[str]] | None = None,
+ answer_coordinates: list[list[tuple]] | None = None,
+ answer_text: list[list[TextInput]] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TapasTruncationStrategy = False,
+ max_length: int | None = None,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = True,
+ return_attention_mask: bool | None = True,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ prepend_batch_axis: bool = False,
+ **kwargs,
+ ) -> BatchEncoding:
+ batch_outputs = {}
+
+ for index, example in enumerate(zip(raw_queries, queries_tokens, answer_coordinates, answer_text)):
+ raw_query, query_tokens, answer_coords, answer_txt = example
+ outputs = self.prepare_for_model(
+ raw_table,
+ raw_query,
+ tokenized_table=tokenized_table,
+ query_tokens=query_tokens,
+ answer_coordinates=answer_coords,
+ answer_text=answer_txt,
+ add_special_tokens=add_special_tokens,
+ padding=PaddingStrategy.DO_NOT_PAD.value, # we pad in batch afterwards
+ truncation=truncation,
+ max_length=max_length,
+ pad_to_multiple_of=None, # we pad in batch afterwards
+ padding_side=None, # we pad in batch afterward
+ return_attention_mask=False, # we pad in batch afterwards
+ return_token_type_ids=return_token_type_ids,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_length=return_length,
+ return_tensors=None, # We convert the whole batch to tensors at the end
+ prepend_batch_axis=False,
+ verbose=verbose,
+ prev_answer_coordinates=answer_coordinates[index - 1] if index != 0 else None,
+ prev_answer_text=answer_text[index - 1] if index != 0 else None,
+ )
+
+ for key, value in outputs.items():
+ if key not in batch_outputs:
+ batch_outputs[key] = []
+ batch_outputs[key].append(value)
+
+ batch_outputs = self.pad(
+ batch_outputs,
+ padding=padding,
+ max_length=max_length,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_attention_mask=return_attention_mask,
+ )
+
+ batch_outputs = BatchEncoding(batch_outputs, tensor_type=return_tensors)
+
+ return batch_outputs
+
+ @add_end_docstrings(ENCODE_KWARGS_DOCSTRING)
+ def encode(
+ self,
+ table: Union["pd.DataFrame", TextInput, list[TextInput]],
+ query: TextInput | PreTokenizedInput | EncodedInput | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TapasTruncationStrategy = False,
+ max_length: int | None = None,
+ return_tensors: str | TensorType | None = None,
+ **kwargs,
+ ) -> list[int]:
+ """
+ Prepare a table and a string for the model. This method does not return token type IDs, attention masks, etc.
+ which are necessary for the model to work correctly. Use that method if you want to build your processing on
+ your own, otherwise refer to `__call__`.
+
+ Args:
+ table (`pd.DataFrame` or `str` or `list[str]`):
+ Table containing tabular data. When passing a string or list of strings, those will be interpreted as
+ queries with an empty table (to support generic tokenizer tests).
+ query (`str` or `list[str]`):
+ Question related to a table to be encoded.
+ """
+ if not isinstance(table, pd.DataFrame):
+ if query is not None:
+ raise AssertionError("Table must be of type pd.DataFrame when queries are provided separately.")
+ inferred_query = table
+ table = pd.DataFrame.from_dict({})
+ query = inferred_query
+
+ encoded_inputs = self.encode_plus(
+ table,
+ query=query,
+ add_special_tokens=add_special_tokens,
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ return_tensors=return_tensors,
+ **kwargs,
+ )
+
+ return encoded_inputs["input_ids"]
+
+ @add_end_docstrings(ENCODE_KWARGS_DOCSTRING, TAPAS_ENCODE_PLUS_ADDITIONAL_KWARGS_DOCSTRING)
+ def encode_plus(
+ self,
+ table: Union["pd.DataFrame", TextInput, list[TextInput]],
+ query: TextInput | PreTokenizedInput | EncodedInput | None = None,
+ answer_coordinates: list[tuple] | None = None,
+ answer_text: list[TextInput] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TapasTruncationStrategy = False,
+ max_length: int | None = None,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = None,
+ return_attention_mask: bool | None = None,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ) -> BatchEncoding:
+ """
+ Prepare a table and a string for the model.
+
+ Args:
+ table (`pd.DataFrame` or `str` or `list[str]`):
+ Table containing tabular data. When passing a string or list of strings, those will be interpreted as
+ queries with an empty table (to support generic tokenizer tests).
+ query (`str` or `list[str]`):
+ Question related to a table to be encoded.
+ answer_coordinates (`list[Tuple]` or `list[list[Tuple]]`, *optional*):
+ Answer coordinates of each table-question pair in the batch. The answer_coordinates must be a single
+ list of one or more tuples. Each tuple must be a (row_index, column_index) pair. The first data row
+ (not the column header row) has index 0. The first column has index 0.
+ answer_text (`list[str]` or `list[list[str]]`, *optional*):
+ Answer text of each table-question pair in the batch. The answer_text must be a single list of one or
+ more strings. Each string must be the answer text of a corresponding answer coordinate.
+ """
+ if return_token_type_ids is not None and not add_special_tokens:
+ raise ValueError(
+ "Asking to return token_type_ids while setting add_special_tokens to False "
+ "results in an undefined behavior. Please set add_special_tokens to True or "
+ "set return_token_type_ids to None."
+ )
+
+ if (answer_coordinates and not answer_text) or (not answer_coordinates and answer_text):
+ raise ValueError("In case you provide answers, both answer_coordinates and answer_text should be provided")
+
+ if "is_split_into_words" in kwargs:
+ raise NotImplementedError("Currently TapasTokenizer only supports questions as strings.")
+
+ if return_offsets_mapping:
+ raise NotImplementedError(
+ "return_offset_mapping is not available when using Python tokenizers. "
+ "To use this feature, change your tokenizer to one deriving from "
+ "transformers.PreTrainedTokenizerFast."
+ )
+
+ if not isinstance(table, pd.DataFrame):
+ if query is not None:
+ raise AssertionError("Table must be of type pd.DataFrame when queries are provided separately.")
+ inferred_query = table
+ table = pd.DataFrame.from_dict({})
+ query = inferred_query
+
+ return self._encode_plus(
+ table=table,
+ query=query,
+ answer_coordinates=answer_coordinates,
+ answer_text=answer_text,
+ add_special_tokens=add_special_tokens,
+ truncation=truncation,
+ padding=padding,
+ max_length=max_length,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=return_offsets_mapping,
+ return_length=return_length,
+ verbose=verbose,
+ **kwargs,
+ )
+
+ def _encode_plus(
+ self,
+ table: "pd.DataFrame",
+ query: TextInput | PreTokenizedInput | EncodedInput,
+ answer_coordinates: list[tuple] | None = None,
+ answer_text: list[TextInput] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TapasTruncationStrategy = False,
+ max_length: int | None = None,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = True,
+ return_attention_mask: bool | None = True,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ):
+ if query is None:
+ query = ""
+ logger.warning(
+ "TAPAS is a question answering model but you have not passed a query. Please be aware that the "
+ "model will probably not behave correctly."
+ )
+
+ table_tokens = self._tokenize_table(table)
+ query, query_tokens = self._get_question_tokens(query)
+
+ return self.prepare_for_model(
+ table,
+ query,
+ tokenized_table=table_tokens,
+ query_tokens=query_tokens,
+ answer_coordinates=answer_coordinates,
+ answer_text=answer_text,
+ add_special_tokens=add_special_tokens,
+ truncation=truncation,
+ padding=padding,
+ max_length=max_length,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ prepend_batch_axis=True,
+ return_attention_mask=return_attention_mask,
+ return_token_type_ids=return_token_type_ids,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_length=return_length,
+ verbose=verbose,
+ )
+
+ @add_end_docstrings(ENCODE_KWARGS_DOCSTRING, TAPAS_ENCODE_PLUS_ADDITIONAL_KWARGS_DOCSTRING)
+ def prepare_for_model(
+ self,
+ raw_table: "pd.DataFrame",
+ raw_query: TextInput | PreTokenizedInput | EncodedInput,
+ tokenized_table: TokenizedTable | None = None,
+ query_tokens: TokenizedTable | None = None,
+ answer_coordinates: list[tuple] | None = None,
+ answer_text: list[TextInput] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TapasTruncationStrategy = False,
+ max_length: int | None = None,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = True,
+ return_attention_mask: bool | None = True,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ prepend_batch_axis: bool = False,
+ **kwargs,
+ ) -> BatchEncoding:
+ """
+ Prepares a sequence of input id so that it can be used by the model. It adds special tokens, truncates
+ sequences if overflowing while taking into account the special tokens.
+
+ Args:
+ raw_table (`pd.DataFrame`):
+ The original table before any transformation (like tokenization) was applied to it.
+ raw_query (`TextInput` or `PreTokenizedInput` or `EncodedInput`):
+ The original query before any transformation (like tokenization) was applied to it.
+ tokenized_table (`TokenizedTable`):
+ The table after tokenization.
+ query_tokens (`list[str]`):
+ The query after tokenization.
+ answer_coordinates (`list[Tuple]` or `list[list[Tuple]]`, *optional*):
+ Answer coordinates of each table-question pair in the batch. The answer_coordinates must be a single
+ list of one or more tuples. Each tuple must be a (row_index, column_index) pair. The first data row
+ (not the column header row) has index 0. The first column has index 0.
+ answer_text (`list[str]` or `list[list[str]]`, *optional*):
+ Answer text of each table-question pair in the batch. The answer_text must be a single list of one or
+ more strings. Each string must be the answer text of a corresponding answer coordinate.
+ """
+ if isinstance(padding, bool):
+ if padding and (max_length is not None or pad_to_multiple_of is not None):
+ padding = PaddingStrategy.MAX_LENGTH
+ else:
+ padding = PaddingStrategy.DO_NOT_PAD
+ elif not isinstance(padding, PaddingStrategy):
+ padding = PaddingStrategy(padding)
+
+ if isinstance(truncation, bool):
+ if truncation:
+ truncation = TapasTruncationStrategy.DROP_ROWS_TO_FIT
+ else:
+ truncation = TapasTruncationStrategy.DO_NOT_TRUNCATE
+ elif not isinstance(truncation, TapasTruncationStrategy):
+ truncation = TapasTruncationStrategy(truncation)
+
+ encoded_inputs = {}
+
+ is_part_of_batch = False
+ prev_answer_coordinates, prev_answer_text = None, None
+ if "prev_answer_coordinates" in kwargs and "prev_answer_text" in kwargs:
+ is_part_of_batch = True
+ prev_answer_coordinates = kwargs["prev_answer_coordinates"]
+ prev_answer_text = kwargs["prev_answer_text"]
+
+ num_rows = self._get_num_rows(raw_table, truncation != TapasTruncationStrategy.DO_NOT_TRUNCATE)
+ num_columns = self._get_num_columns(raw_table)
+ _, _, num_tokens = self._get_table_boundaries(tokenized_table)
+
+ if truncation != TapasTruncationStrategy.DO_NOT_TRUNCATE:
+ num_rows, num_tokens = self._get_truncated_table_rows(
+ query_tokens, tokenized_table, num_rows, num_columns, max_length, truncation_strategy=truncation
+ )
+ table_data = list(self._get_table_values(tokenized_table, num_columns, num_rows, num_tokens))
+
+ query_ids = self.convert_tokens_to_ids(query_tokens)
+ table_ids = list(zip(*table_data))[0] if len(table_data) > 0 else list(zip(*table_data))
+ table_ids = self.convert_tokens_to_ids(list(table_ids))
+
+ if "return_overflowing_tokens" in kwargs and kwargs["return_overflowing_tokens"]:
+ raise ValueError("TAPAS does not return overflowing tokens as it works on tables.")
+
+ if add_special_tokens:
+ input_ids = self.build_inputs_with_special_tokens(query_ids, table_ids)
+ else:
+ input_ids = query_ids + table_ids
+
+ if max_length is not None and len(input_ids) > max_length:
+ raise ValueError(
+ "Could not encode the query and table header given the maximum length. Encoding the query and table "
+ f"header results in a length of {len(input_ids)} which is higher than the max_length of {max_length}"
+ )
+
+ encoded_inputs["input_ids"] = input_ids
+
+ segment_ids = self.create_segment_token_type_ids_from_sequences(query_ids, table_data)
+ column_ids = self.create_column_token_type_ids_from_sequences(query_ids, table_data)
+ row_ids = self.create_row_token_type_ids_from_sequences(query_ids, table_data)
+ if not is_part_of_batch or (prev_answer_coordinates is None and prev_answer_text is None):
+ # simply set the prev_labels to zeros
+ prev_labels = [0] * len(row_ids)
+ else:
+ prev_labels = self.get_answer_ids(
+ column_ids, row_ids, table_data, prev_answer_text, prev_answer_coordinates
+ )
+
+ # FIRST: parse both the table and question in terms of numeric values
+
+ raw_table = add_numeric_table_values(raw_table)
+ raw_query = add_numeric_values_to_question(raw_query)
+
+ # SECOND: add numeric-related features (and not parse them in these functions):
+
+ column_ranks, inv_column_ranks = self._get_numeric_column_ranks(column_ids, row_ids, raw_table)
+ numeric_relations = self._get_numeric_relations(raw_query, column_ids, row_ids, raw_table)
+
+ # Load from model defaults
+ if return_token_type_ids is None:
+ return_token_type_ids = "token_type_ids" in self.model_input_names
+ if return_attention_mask is None:
+ return_attention_mask = "attention_mask" in self.model_input_names
+
+ if return_attention_mask:
+ attention_mask = self.create_attention_mask_from_sequences(query_ids, table_data)
+ encoded_inputs["attention_mask"] = attention_mask
+
+ if answer_coordinates is not None and answer_text is not None:
+ labels = self.get_answer_ids(column_ids, row_ids, table_data, answer_text, answer_coordinates)
+ numeric_values = self._get_numeric_values(raw_table, column_ids, row_ids)
+ numeric_values_scale = self._get_numeric_values_scale(raw_table, column_ids, row_ids)
+
+ encoded_inputs["labels"] = labels
+ encoded_inputs["numeric_values"] = numeric_values
+ encoded_inputs["numeric_values_scale"] = numeric_values_scale
+
+ if return_token_type_ids:
+ token_type_ids = [
+ segment_ids,
+ column_ids,
+ row_ids,
+ prev_labels,
+ column_ranks,
+ inv_column_ranks,
+ numeric_relations,
+ ]
+
+ token_type_ids = [list(ids) for ids in list(zip(*token_type_ids))]
+ encoded_inputs["token_type_ids"] = token_type_ids
+
+ if return_special_tokens_mask:
+ if add_special_tokens:
+ encoded_inputs["special_tokens_mask"] = self.get_special_tokens_mask(query_ids, table_ids)
+ else:
+ encoded_inputs["special_tokens_mask"] = [0] * len(input_ids)
+
+ # Check lengths
+ if max_length is None and len(encoded_inputs["input_ids"]) > self.model_max_length and verbose:
+ if not self.deprecation_warnings.get("sequence-length-is-longer-than-the-specified-maximum", False):
+ logger.warning(
+ "Token indices sequence length is longer than the specified maximum sequence length "
+ f"for this model ({len(encoded_inputs['input_ids'])} > {self.model_max_length}). Running this "
+ "sequence through the model will result in indexing errors."
+ )
+ self.deprecation_warnings["sequence-length-is-longer-than-the-specified-maximum"] = True
+
+ # Padding
+ if padding != PaddingStrategy.DO_NOT_PAD or return_attention_mask:
+ encoded_inputs = self.pad(
+ encoded_inputs,
+ max_length=max_length,
+ padding=padding.value,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_attention_mask=return_attention_mask,
+ )
+
+ if return_length:
+ encoded_inputs["length"] = len(encoded_inputs["input_ids"])
+
+ batch_outputs = BatchEncoding(
+ encoded_inputs, tensor_type=return_tensors, prepend_batch_axis=prepend_batch_axis
+ )
+
+ return batch_outputs
+
+ def _get_truncated_table_rows(
+ self,
+ query_tokens: list[str],
+ tokenized_table: TokenizedTable,
+ num_rows: int,
+ num_columns: int,
+ max_length: int,
+ truncation_strategy: str | TapasTruncationStrategy,
+ ) -> tuple[int, int]:
+ """
+ Truncates a sequence pair in-place following the strategy.
+
+ Args:
+ query_tokens (`list[str]`):
+ List of strings corresponding to the tokenized query.
+ tokenized_table (`TokenizedTable`):
+ Tokenized table
+ num_rows (`int`):
+ Total number of table rows
+ num_columns (`int`):
+ Total number of table columns
+ max_length (`int`):
+ Total maximum length.
+ truncation_strategy (`str` or [`TapasTruncationStrategy]`):
+ Truncation strategy to use. Seeing as this method should only be called when truncating, the only
+ available strategy is the `"drop_rows_to_fit"` strategy.
+
+ Returns:
+ `Tuple(int, int)`: tuple containing the number of rows after truncation, and the number of tokens available
+ for each table element.
+ """
+ if not isinstance(truncation_strategy, TapasTruncationStrategy):
+ truncation_strategy = TapasTruncationStrategy(truncation_strategy)
+
+ if max_length is None:
+ max_length = self.model_max_length
+
+ if truncation_strategy == TapasTruncationStrategy.DROP_ROWS_TO_FIT:
+ while True:
+ num_tokens = self._get_max_num_tokens(
+ query_tokens, tokenized_table, num_rows=num_rows, num_columns=num_columns, max_length=max_length
+ )
+
+ if num_tokens is not None:
+ # We could fit the table.
+ break
+
+ # Try to drop a row to fit the table.
+ num_rows -= 1
+
+ if num_rows < 1:
+ break
+ elif truncation_strategy != TapasTruncationStrategy.DO_NOT_TRUNCATE:
+ raise ValueError(f"Unknown truncation strategy {truncation_strategy}.")
+
+ return num_rows, num_tokens or 1
+
+ def _tokenize_table(
+ self,
+ table=None,
+ ):
+ """
+ Tokenizes column headers and cell texts of a table.
+
+ Args:
+ table (`pd.Dataframe`):
+ Table. Returns: `TokenizedTable`: TokenizedTable object.
+ """
+ tokenized_rows = []
+ tokenized_row = []
+ # tokenize column headers
+ for column in table:
+ if self.strip_column_names:
+ tokenized_row.append(self.tokenize(""))
+ else:
+ tokenized_row.append(self.tokenize(column))
+ tokenized_rows.append(tokenized_row)
+
+ # tokenize cell values
+ for idx, row in table.iterrows():
+ tokenized_row = []
+ for cell in row:
+ tokenized_row.append(self.tokenize(cell))
+ tokenized_rows.append(tokenized_row)
+
+ token_coordinates = []
+ for row_index, row in enumerate(tokenized_rows):
+ for column_index, cell in enumerate(row):
+ for token_index, _ in enumerate(cell):
+ token_coordinates.append(
+ TokenCoordinates(
+ row_index=row_index,
+ column_index=column_index,
+ token_index=token_index,
+ )
+ )
+
+ return TokenizedTable(
+ rows=tokenized_rows,
+ selected_tokens=token_coordinates,
+ )
+
+ def _question_encoding_cost(self, question_tokens):
+ # Two extra spots of SEP and CLS.
+ return len(question_tokens) + 2
+
+ def _get_token_budget(self, question_tokens, max_length=None):
+ """
+ Computes the number of tokens left for the table after tokenizing a question, taking into account the max
+ sequence length of the model.
+
+ Args:
+ question_tokens (`list[String]`):
+ List of question tokens. Returns: `int`: the number of tokens left for the table, given the model max
+ length.
+ """
+ return (max_length if max_length is not None else self.model_max_length) - self._question_encoding_cost(
+ question_tokens
+ )
+
+ def _get_table_values(self, table, num_columns, num_rows, num_tokens) -> Generator[TableValue, None, None]:
+ """Iterates over partial table and returns token, column and row indexes."""
+ for tc in table.selected_tokens:
+ # First row is header row.
+ if tc.row_index >= num_rows + 1:
+ continue
+ if tc.column_index >= num_columns:
+ continue
+ cell = table.rows[tc.row_index][tc.column_index]
+ token = cell[tc.token_index]
+ word_begin_index = tc.token_index
+ # Don't add partial words. Find the starting word piece and check if it
+ # fits in the token budget.
+ while word_begin_index >= 0 and _is_inner_wordpiece(cell[word_begin_index]):
+ word_begin_index -= 1
+ if word_begin_index >= num_tokens:
+ continue
+ yield TableValue(token, tc.column_index + 1, tc.row_index)
+
+ def _get_table_boundaries(self, table):
+ """Return maximal number of rows, columns and tokens."""
+ max_num_tokens = 0
+ max_num_columns = 0
+ max_num_rows = 0
+ for tc in table.selected_tokens:
+ max_num_columns = max(max_num_columns, tc.column_index + 1)
+ max_num_rows = max(max_num_rows, tc.row_index + 1)
+ max_num_tokens = max(max_num_tokens, tc.token_index + 1)
+ max_num_columns = min(self.max_column_id, max_num_columns)
+ max_num_rows = min(self.max_row_id, max_num_rows)
+ return max_num_rows, max_num_columns, max_num_tokens
+
+ def _get_table_cost(self, table, num_columns, num_rows, num_tokens):
+ return sum(1 for _ in self._get_table_values(table, num_columns, num_rows, num_tokens))
+
+ def _get_max_num_tokens(self, question_tokens, tokenized_table, num_columns, num_rows, max_length):
+ """Computes max number of tokens that can be squeezed into the budget."""
+ token_budget = self._get_token_budget(question_tokens, max_length)
+ _, _, max_num_tokens = self._get_table_boundaries(tokenized_table)
+ if self.cell_trim_length >= 0 and max_num_tokens > self.cell_trim_length:
+ max_num_tokens = self.cell_trim_length
+ num_tokens = 0
+ for num_tokens in range(max_num_tokens + 1):
+ cost = self._get_table_cost(tokenized_table, num_columns, num_rows, num_tokens + 1)
+ if cost > token_budget:
+ break
+ if num_tokens < max_num_tokens:
+ if self.cell_trim_length >= 0:
+ # We don't allow dynamic trimming if a cell_trim_length is set.
+ return None
+ if num_tokens == 0:
+ return None
+ return num_tokens
+
+ def _get_num_columns(self, table):
+ num_columns = table.shape[1]
+ if num_columns >= self.max_column_id:
+ raise ValueError("Too many columns")
+ return num_columns
+
+ def _get_num_rows(self, table, drop_rows_to_fit):
+ num_rows = table.shape[0]
+ if num_rows >= self.max_row_id:
+ if drop_rows_to_fit:
+ num_rows = self.max_row_id - 1
+ else:
+ raise ValueError("Too many rows")
+ return num_rows
+
+ def _serialize_text(self, question_tokens):
+ """Serializes texts in index arrays."""
+ tokens = []
+ segment_ids = []
+ column_ids = []
+ row_ids = []
+
+ # add [CLS] token at the beginning
+ tokens.append(self.cls_token)
+ segment_ids.append(0)
+ column_ids.append(0)
+ row_ids.append(0)
+
+ for token in question_tokens:
+ tokens.append(token)
+ segment_ids.append(0)
+ column_ids.append(0)
+ row_ids.append(0)
+
+ return tokens, segment_ids, column_ids, row_ids
+
+ def _serialize(
+ self,
+ question_tokens,
+ table,
+ num_columns,
+ num_rows,
+ num_tokens,
+ ):
+ """Serializes table and text."""
+ tokens, segment_ids, column_ids, row_ids = self._serialize_text(question_tokens)
+
+ # add [SEP] token between question and table tokens
+ tokens.append(self.sep_token)
+ segment_ids.append(0)
+ column_ids.append(0)
+ row_ids.append(0)
+
+ for token, column_id, row_id in self._get_table_values(table, num_columns, num_rows, num_tokens):
+ tokens.append(token)
+ segment_ids.append(1)
+ column_ids.append(column_id)
+ row_ids.append(row_id)
+
+ return SerializedExample(
+ tokens=tokens,
+ segment_ids=segment_ids,
+ column_ids=column_ids,
+ row_ids=row_ids,
+ )
+
+ def _get_column_values(self, table, col_index):
+ table_numeric_values = {}
+ for row_index, row in table.iterrows():
+ cell = row[col_index]
+ if cell.numeric_value is not None:
+ table_numeric_values[row_index] = cell.numeric_value
+ return table_numeric_values
+
+ def _get_cell_token_indexes(self, column_ids, row_ids, column_id, row_id):
+ for index in range(len(column_ids)):
+ if column_ids[index] - 1 == column_id and row_ids[index] - 1 == row_id:
+ yield index
+
+ def _get_numeric_column_ranks(self, column_ids, row_ids, table):
+ """Returns column ranks for all numeric columns."""
+
+ ranks = [0] * len(column_ids)
+ inv_ranks = [0] * len(column_ids)
+
+ # original code from tf_example_utils.py of the original implementation
+ if table is not None:
+ for col_index in range(len(table.columns)):
+ table_numeric_values = self._get_column_values(table, col_index)
+
+ if not table_numeric_values:
+ continue
+
+ try:
+ key_fn = get_numeric_sort_key_fn(table_numeric_values.values())
+ except ValueError:
+ continue
+
+ table_numeric_values = {row_index: key_fn(value) for row_index, value in table_numeric_values.items()}
+
+ table_numeric_values_inv = collections.defaultdict(list)
+ for row_index, value in table_numeric_values.items():
+ table_numeric_values_inv[value].append(row_index)
+
+ unique_values = sorted(table_numeric_values_inv.keys())
+
+ for rank, value in enumerate(unique_values):
+ for row_index in table_numeric_values_inv[value]:
+ for index in self._get_cell_token_indexes(column_ids, row_ids, col_index, row_index):
+ ranks[index] = rank + 1
+ inv_ranks[index] = len(unique_values) - rank
+
+ return ranks, inv_ranks
+
+ def _get_numeric_sort_key_fn(self, table_numeric_values, value):
+ """
+ Returns the sort key function for comparing value to table values. The function returned will be a suitable
+ input for the key param of the sort(). See number_annotation_utils._get_numeric_sort_key_fn for details
+
+ Args:
+ table_numeric_values: Numeric values of a column
+ value: Numeric value in the question
+
+ Returns:
+ A function key function to compare column and question values.
+ """
+ if not table_numeric_values:
+ return None
+ all_values = list(table_numeric_values.values())
+ all_values.append(value)
+ try:
+ return get_numeric_sort_key_fn(all_values)
+ except ValueError:
+ return None
+
+ def _get_numeric_relations(self, question, column_ids, row_ids, table):
+ """
+ Returns numeric relations embeddings
+
+ Args:
+ question: Question object.
+ column_ids: Maps word piece position to column id.
+ row_ids: Maps word piece position to row id.
+ table: The table containing the numeric cell values.
+ """
+
+ numeric_relations = [0] * len(column_ids)
+
+ # first, we add any numeric value spans to the question:
+ # Create a dictionary that maps a table cell to the set of all relations
+ # this cell has with any value in the question.
+ cell_indices_to_relations = collections.defaultdict(set)
+ if question is not None and table is not None:
+ for numeric_value_span in question.numeric_spans:
+ for value in numeric_value_span.values:
+ for column_index in range(len(table.columns)):
+ table_numeric_values = self._get_column_values(table, column_index)
+ sort_key_fn = self._get_numeric_sort_key_fn(table_numeric_values, value)
+ if sort_key_fn is None:
+ continue
+ for row_index, cell_value in table_numeric_values.items():
+ relation = get_numeric_relation(value, cell_value, sort_key_fn)
+ if relation is not None:
+ cell_indices_to_relations[column_index, row_index].add(relation)
+
+ # For each cell add a special feature for all its word pieces.
+ for (column_index, row_index), relations in cell_indices_to_relations.items():
+ relation_set_index = 0
+ for relation in relations:
+ assert relation.value >= Relation.EQ.value
+ relation_set_index += 2 ** (relation.value - Relation.EQ.value)
+ for cell_token_index in self._get_cell_token_indexes(column_ids, row_ids, column_index, row_index):
+ numeric_relations[cell_token_index] = relation_set_index
+
+ return numeric_relations
+
+ def _get_numeric_values(self, table, column_ids, row_ids):
+ """Returns numeric values for computation of answer loss."""
+
+ numeric_values = [float("nan")] * len(column_ids)
+
+ if table is not None:
+ num_rows = table.shape[0]
+ num_columns = table.shape[1]
+
+ for col_index in range(num_columns):
+ for row_index in range(num_rows):
+ numeric_value = table.iloc[row_index, col_index].numeric_value
+ if numeric_value is not None:
+ if numeric_value.float_value is None:
+ continue
+ float_value = numeric_value.float_value
+ if float_value == float("inf"):
+ continue
+ for index in self._get_cell_token_indexes(column_ids, row_ids, col_index, row_index):
+ numeric_values[index] = float_value
+
+ return numeric_values
+
+ def _get_numeric_values_scale(self, table, column_ids, row_ids):
+ """Returns a scale to each token to down weigh the value of long words."""
+
+ numeric_values_scale = [1.0] * len(column_ids)
+
+ if table is None:
+ return numeric_values_scale
+
+ num_rows = table.shape[0]
+ num_columns = table.shape[1]
+
+ for col_index in range(num_columns):
+ for row_index in range(num_rows):
+ indices = list(self._get_cell_token_indexes(column_ids, row_ids, col_index, row_index))
+ num_indices = len(indices)
+ if num_indices > 1:
+ for index in indices:
+ numeric_values_scale[index] = float(num_indices)
+
+ return numeric_values_scale
+
+ def _pad_to_seq_length(self, inputs):
+ while len(inputs) > self.model_max_length:
+ inputs.pop()
+ while len(inputs) < self.model_max_length:
+ inputs.append(0)
+
+ def _get_all_answer_ids_from_coordinates(
+ self,
+ column_ids,
+ row_ids,
+ answers_list,
+ ):
+ """Maps lists of answer coordinates to token indexes."""
+ answer_ids = [0] * len(column_ids)
+ found_answers = set()
+ all_answers = set()
+ for answers in answers_list:
+ column_index, row_index = answers
+ all_answers.add((column_index, row_index))
+ for index in self._get_cell_token_indexes(column_ids, row_ids, column_index, row_index):
+ found_answers.add((column_index, row_index))
+ answer_ids[index] = 1
+
+ missing_count = len(all_answers) - len(found_answers)
+ return answer_ids, missing_count
+
+ def _get_all_answer_ids(self, column_ids, row_ids, answer_coordinates):
+ """
+ Maps answer coordinates of a question to token indexes.
+
+ In the SQA format (TSV), the coordinates are given as (row, column) tuples. Here, we first swap them to
+ (column, row) format before calling _get_all_answer_ids_from_coordinates.
+ """
+
+ def _to_coordinates(answer_coordinates_question):
+ return [(coords[1], coords[0]) for coords in answer_coordinates_question]
+
+ return self._get_all_answer_ids_from_coordinates(
+ column_ids, row_ids, answers_list=(_to_coordinates(answer_coordinates))
+ )
+
+ def _find_tokens(self, text, segment):
+ """Return start index of segment in text or None."""
+ logging.info(f"text: {text} {segment}")
+ for index in range(1 + len(text) - len(segment)):
+ for seg_index, seg_token in enumerate(segment):
+ if text[index + seg_index].piece != seg_token.piece:
+ break
+ else:
+ return index
+ return None
+
+ def _find_answer_coordinates_from_answer_text(
+ self,
+ tokenized_table,
+ answer_text,
+ ):
+ """Returns all occurrences of answer_text in the table."""
+ logging.info(f"answer text: {answer_text}")
+ for row_index, row in enumerate(tokenized_table.rows):
+ if row_index == 0:
+ # We don't search for answers in the header.
+ continue
+ for col_index, cell in enumerate(row):
+ token_index = self._find_tokens(cell, answer_text)
+ if token_index is not None:
+ yield TokenCoordinates(
+ row_index=row_index,
+ column_index=col_index,
+ token_index=token_index,
+ )
+
+ def _find_answer_ids_from_answer_texts(
+ self,
+ column_ids,
+ row_ids,
+ tokenized_table,
+ answer_texts,
+ ):
+ """Maps question with answer texts to the first matching token indexes."""
+ answer_ids = [0] * len(column_ids)
+ for answer_text in answer_texts:
+ for coordinates in self._find_answer_coordinates_from_answer_text(
+ tokenized_table,
+ answer_text,
+ ):
+ # Maps answer coordinates to indexes this can fail if tokens / rows have
+ # been pruned.
+ indexes = list(
+ self._get_cell_token_indexes(
+ column_ids,
+ row_ids,
+ column_id=coordinates.column_index,
+ row_id=coordinates.row_index - 1,
+ )
+ )
+ indexes.sort()
+ coordinate_answer_ids = []
+ if indexes:
+ begin_index = coordinates.token_index + indexes[0]
+ end_index = begin_index + len(answer_text)
+ for index in indexes:
+ if index >= begin_index and index < end_index:
+ coordinate_answer_ids.append(index)
+ if len(coordinate_answer_ids) == len(answer_text):
+ for index in coordinate_answer_ids:
+ answer_ids[index] = 1
+ break
+ return answer_ids
+
+ def _get_answer_ids(self, column_ids, row_ids, answer_coordinates):
+ """Maps answer coordinates of a question to token indexes."""
+ answer_ids, missing_count = self._get_all_answer_ids(column_ids, row_ids, answer_coordinates)
+
+ if missing_count:
+ raise ValueError("Couldn't find all answers")
+ return answer_ids
+
+ def get_answer_ids(self, column_ids, row_ids, tokenized_table, answer_texts_question, answer_coordinates_question):
+ if self.update_answer_coordinates:
+ return self._find_answer_ids_from_answer_texts(
+ column_ids,
+ row_ids,
+ tokenized_table,
+ answer_texts=[self.tokenize(at) for at in answer_texts_question],
+ )
+ return self._get_answer_ids(column_ids, row_ids, answer_coordinates_question)
+
+ def _pad(
+ self,
+ encoded_inputs: dict[str, EncodedInput] | BatchEncoding,
+ max_length: int | None = None,
+ padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_attention_mask: bool | None = None,
+ ) -> dict:
+ """
+ Pad encoded inputs (on left/right and up to predefined length or max length in the batch)
+
+ Args:
+ encoded_inputs:
+ Dictionary of tokenized inputs (`list[int]`) or batch of tokenized inputs (`list[list[int]]`).
+ max_length: maximum length of the returned list and optionally padding length (see below).
+ Will truncate by taking into account the special tokens.
+ padding_strategy: PaddingStrategy to use for padding.
+
+ - PaddingStrategy.LONGEST Pad to the longest sequence in the batch
+ - PaddingStrategy.MAX_LENGTH: Pad to the max length (default)
+ - PaddingStrategy.DO_NOT_PAD: Do not pad
+ The tokenizer padding sides are defined in self.padding_side:
+
+ - 'left': pads on the left of the sequences
+ - 'right': pads on the right of the sequences
+ pad_to_multiple_of: (optional) Integer if set will pad the sequence to a multiple of the provided value.
+ This is especially useful to enable the use of Tensor Core on NVIDIA hardware with compute capability
+ `>= 7.5` (Volta).
+ padding_side:
+ The side on which the model should have padding applied. Should be selected between ['right', 'left'].
+ Default value is picked from the class attribute of the same name.
+ return_attention_mask:
+ (optional) Set to False to avoid returning attention mask (default: set to model specifics)
+ """
+ # Load from model defaults
+ if return_attention_mask is None:
+ return_attention_mask = "attention_mask" in self.model_input_names
+
+ if padding_strategy == PaddingStrategy.LONGEST:
+ max_length = len(encoded_inputs["input_ids"])
+
+ if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
+ max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of
+
+ needs_to_be_padded = (
+ padding_strategy != PaddingStrategy.DO_NOT_PAD and len(encoded_inputs["input_ids"]) != max_length
+ )
+
+ # Initialize attention mask if not present.
+ if return_attention_mask and "attention_mask" not in encoded_inputs:
+ encoded_inputs["attention_mask"] = [1] * len(encoded_inputs["input_ids"])
+
+ if needs_to_be_padded:
+ difference = max_length - len(encoded_inputs["input_ids"])
+ padding_side = padding_side if padding_side is not None else self.padding_side
+ if padding_side == "right":
+ if return_attention_mask:
+ encoded_inputs["attention_mask"] = encoded_inputs["attention_mask"] + [0] * difference
+ if "token_type_ids" in encoded_inputs:
+ encoded_inputs["token_type_ids"] = (
+ encoded_inputs["token_type_ids"] + [[self.pad_token_type_id] * 7] * difference
+ )
+ if "labels" in encoded_inputs:
+ encoded_inputs["labels"] = encoded_inputs["labels"] + [0] * difference
+ if "numeric_values" in encoded_inputs:
+ encoded_inputs["numeric_values"] = encoded_inputs["numeric_values"] + [float("nan")] * difference
+ if "numeric_values_scale" in encoded_inputs:
+ encoded_inputs["numeric_values_scale"] = (
+ encoded_inputs["numeric_values_scale"] + [1.0] * difference
+ )
+ if "special_tokens_mask" in encoded_inputs:
+ encoded_inputs["special_tokens_mask"] = encoded_inputs["special_tokens_mask"] + [1] * difference
+ encoded_inputs["input_ids"] = encoded_inputs["input_ids"] + [self.pad_token_id] * difference
+ elif padding_side == "left":
+ if return_attention_mask:
+ encoded_inputs["attention_mask"] = [0] * difference + encoded_inputs["attention_mask"]
+ if "token_type_ids" in encoded_inputs:
+ encoded_inputs["token_type_ids"] = [[self.pad_token_type_id] * 7] * difference + encoded_inputs[
+ "token_type_ids"
+ ]
+ if "labels" in encoded_inputs:
+ encoded_inputs["labels"] = [0] * difference + encoded_inputs["labels"]
+ if "numeric_values" in encoded_inputs:
+ encoded_inputs["numeric_values"] = [float("nan")] * difference + encoded_inputs["numeric_values"]
+ if "numeric_values_scale" in encoded_inputs:
+ encoded_inputs["numeric_values_scale"] = [1.0] * difference + encoded_inputs[
+ "numeric_values_scale"
+ ]
+ if "special_tokens_mask" in encoded_inputs:
+ encoded_inputs["special_tokens_mask"] = [1] * difference + encoded_inputs["special_tokens_mask"]
+ encoded_inputs["input_ids"] = [self.pad_token_id] * difference + encoded_inputs["input_ids"]
+ else:
+ raise ValueError("Invalid padding strategy:" + str(padding_side))
+
+ return encoded_inputs
+
+ # Everything related to converting logits to predictions
+
+ def _get_cell_token_probs(self, probabilities, segment_ids, row_ids, column_ids):
+ for i, p in enumerate(probabilities):
+ segment_id = segment_ids[i]
+ col = column_ids[i] - 1
+ row = row_ids[i] - 1
+ if col >= 0 and row >= 0 and segment_id == 1:
+ yield i, p
+
+ def _get_mean_cell_probs(self, probabilities, segment_ids, row_ids, column_ids):
+ """Computes average probability per cell, aggregating over tokens."""
+ coords_to_probs = collections.defaultdict(list)
+ for i, prob in self._get_cell_token_probs(probabilities, segment_ids, row_ids, column_ids):
+ col = column_ids[i] - 1
+ row = row_ids[i] - 1
+ coords_to_probs[(col, row)].append(prob)
+ return {coords: np.array(cell_probs).mean() for coords, cell_probs in coords_to_probs.items()}
+
+ def convert_logits_to_predictions(self, data, logits, logits_agg=None, cell_classification_threshold=0.5):
+ """
+ Converts logits of [`TapasForQuestionAnswering`] to actual predicted answer coordinates and optional
+ aggregation indices.
+
+ The original implementation, on which this function is based, can be found
+ [here](https://github.com/google-research/tapas/blob/4908213eb4df7aa988573350278b44c4dbe3f71b/tapas/experiments/prediction_utils.py#L288).
+
+ Args:
+ data (`dict`):
+ Dictionary mapping features to actual values. Should be created using [`TapasTokenizer`].
+ logits (`torch.Tensor` of shape `(batch_size, sequence_length)`):
+ Tensor containing the logits at the token level.
+ logits_agg (`torch.Tensor` of shape `(batch_size, num_aggregation_labels)`, *optional*):
+ Tensor containing the aggregation logits.
+ cell_classification_threshold (`float`, *optional*, defaults to 0.5):
+ Threshold to be used for cell selection. All table cells for which their probability is larger than
+ this threshold will be selected.
+
+ Returns:
+ `tuple` comprising various elements depending on the inputs:
+
+ - predicted_answer_coordinates (`list[list[[tuple]]` of length `batch_size`): Predicted answer coordinates
+ as a list of lists of tuples. Each element in the list contains the predicted answer coordinates of a
+ single example in the batch, as a list of tuples. Each tuple is a cell, i.e. (row index, column index).
+ - predicted_aggregation_indices (`list[int]`of length `batch_size`, *optional*, returned when
+ `logits_aggregation` is provided): Predicted aggregation operator indices of the aggregation head.
+ """
+ logits = logits.numpy()
+ if logits_agg is not None:
+ logits_agg = logits_agg.numpy()
+ data = {key: value.numpy() for key, value in data.items() if key != "training"}
+ # input data is of type float32
+ # np.log(np.finfo(np.float32).max) = 88.72284
+ # Any value over 88.72284 will overflow when passed through the exponential, sending a warning
+ # We disable this warning by truncating the logits.
+ logits[logits < -88.7] = -88.7
+
+ # Compute probabilities from token logits
+ probabilities = 1 / (1 + np.exp(-logits)) * data["attention_mask"]
+ token_types = [
+ "segment_ids",
+ "column_ids",
+ "row_ids",
+ "prev_labels",
+ "column_ranks",
+ "inv_column_ranks",
+ "numeric_relations",
+ ]
+
+ # collect input_ids, segment ids, row ids and column ids of batch. Shape (batch_size, seq_len)
+ input_ids = data["input_ids"]
+ segment_ids = data["token_type_ids"][:, :, token_types.index("segment_ids")]
+ row_ids = data["token_type_ids"][:, :, token_types.index("row_ids")]
+ column_ids = data["token_type_ids"][:, :, token_types.index("column_ids")]
+
+ # next, get answer coordinates for every example in the batch
+ num_batch = input_ids.shape[0]
+ predicted_answer_coordinates = []
+ for i in range(num_batch):
+ probabilities_example = probabilities[i].tolist()
+ segment_ids_example = segment_ids[i]
+ row_ids_example = row_ids[i]
+ column_ids_example = column_ids[i]
+
+ max_width = column_ids_example.max()
+ max_height = row_ids_example.max()
+
+ if max_width == 0 and max_height == 0:
+ continue
+
+ cell_coords_to_prob = self._get_mean_cell_probs(
+ probabilities_example,
+ segment_ids_example.tolist(),
+ row_ids_example.tolist(),
+ column_ids_example.tolist(),
+ )
+
+ # Select the answers above the classification threshold.
+ answer_coordinates = []
+ for col in range(max_width):
+ for row in range(max_height):
+ cell_prob = cell_coords_to_prob.get((col, row), None)
+ if cell_prob is not None:
+ if cell_prob > cell_classification_threshold:
+ answer_coordinates.append((row, col))
+ answer_coordinates = sorted(answer_coordinates)
+ predicted_answer_coordinates.append(answer_coordinates)
+
+ output = (predicted_answer_coordinates,)
+
+ if logits_agg is not None:
+ predicted_aggregation_indices = logits_agg.argmax(axis=-1)
+ output = (predicted_answer_coordinates, predicted_aggregation_indices.tolist())
+
+ return output
+
+ # End of everything related to converting logits to predictions
+
+
+class BasicTokenizer:
+ """
+ Constructs a BasicTokenizer that will run basic tokenization (punctuation splitting, lower casing, etc.).
+
+ Args:
+ do_lower_case (`bool`, *optional*, defaults to `True`):
+ Whether or not to lowercase the input when tokenizing.
+ never_split (`Iterable`, *optional*):
+ Collection of tokens which will never be split during tokenization. Only has an effect when
+ `do_basic_tokenize=True`
+ tokenize_chinese_chars (`bool`, *optional*, defaults to `True`):
+ Whether or not to tokenize Chinese characters.
+
+ This should likely be deactivated for Japanese (see this
+ [issue](https://github.com/huggingface/transformers/issues/328)).
+ strip_accents (`bool`, *optional*):
+ Whether or not to strip all accents. If this option is not specified, then it will be determined by the
+ value for `lowercase` (as in the original BERT).
+ do_split_on_punc (`bool`, *optional*, defaults to `True`):
+ In some instances we want to skip the basic punctuation splitting so that later tokenization can capture
+ the full context of the words, such as contractions.
+ """
+
+ def __init__(
+ self,
+ do_lower_case=True,
+ never_split=None,
+ tokenize_chinese_chars=True,
+ strip_accents=None,
+ do_split_on_punc=True,
+ ):
+ if never_split is None:
+ never_split = []
+ self.do_lower_case = do_lower_case
+ self.never_split = set(never_split)
+ self.tokenize_chinese_chars = tokenize_chinese_chars
+ self.strip_accents = strip_accents
+ self.do_split_on_punc = do_split_on_punc
+
+ def tokenize(self, text, never_split=None):
+ """
+ Basic Tokenization of a piece of text. For sub-word tokenization, see WordPieceTokenizer.
+
+ Args:
+ never_split (`List[str]`, *optional*)
+ Kept for backward compatibility purposes. Now implemented directly at the base class level (see
+ [`PreTrainedTokenizer.tokenize`]) List of token not to split.
+ """
+ # union() returns a new set by concatenating the two sets.
+ never_split = self.never_split.union(set(never_split)) if never_split else self.never_split
+ text = self._clean_text(text)
+
+ # This was added on November 1st, 2018 for the multilingual and Chinese
+ # models. This is also applied to the English models now, but it doesn't
+ # matter since the English models were not trained on any Chinese data
+ # and generally don't have any Chinese data in them (there are Chinese
+ # characters in the vocabulary because Wikipedia does have some Chinese
+ # words in the English Wikipedia.).
+ if self.tokenize_chinese_chars:
+ text = self._tokenize_chinese_chars(text)
+ # prevents treating the same character with different unicode codepoints as different characters
+ unicode_normalized_text = unicodedata.normalize("NFC", text)
+ orig_tokens = whitespace_tokenize(unicode_normalized_text)
+ split_tokens = []
+ for token in orig_tokens:
+ if token not in never_split:
+ if self.do_lower_case:
+ token = token.lower()
+ if self.strip_accents is not False:
+ token = self._run_strip_accents(token)
+ elif self.strip_accents:
+ token = self._run_strip_accents(token)
+ split_tokens.extend(self._run_split_on_punc(token, never_split))
+
+ output_tokens = whitespace_tokenize(" ".join(split_tokens))
+ return output_tokens
+
+ def _run_strip_accents(self, text):
+ """Strips accents from a piece of text."""
+ text = unicodedata.normalize("NFD", text)
+ output = []
+ for char in text:
+ cat = unicodedata.category(char)
+ if cat == "Mn":
+ continue
+ output.append(char)
+ return "".join(output)
+
+ def _run_split_on_punc(self, text, never_split=None):
+ """Splits punctuation on a piece of text."""
+ if not self.do_split_on_punc or (never_split is not None and text in never_split):
+ return [text]
+ chars = list(text)
+ i = 0
+ start_new_word = True
+ output = []
+ while i < len(chars):
+ char = chars[i]
+ if _is_punctuation(char):
+ output.append([char])
+ start_new_word = True
+ else:
+ if start_new_word:
+ output.append([])
+ start_new_word = False
+ output[-1].append(char)
+ i += 1
+
+ return ["".join(x) for x in output]
+
+ def _tokenize_chinese_chars(self, text):
+ """Adds whitespace around any CJK character."""
+ output = []
+ for char in text:
+ cp = ord(char)
+ if self._is_chinese_char(cp):
+ output.append(" ")
+ output.append(char)
+ output.append(" ")
+ else:
+ output.append(char)
+ return "".join(output)
+
+ def _is_chinese_char(self, cp):
+ """Checks whether CP is the codepoint of a CJK character."""
+ # This defines a "chinese character" as anything in the CJK Unicode block:
+ # https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
+ #
+ # Note that the CJK Unicode block is NOT all Japanese and Korean characters,
+ # despite its name. The modern Korean Hangul alphabet is a different block,
+ # as is Japanese Hiragana and Katakana. Those alphabets are used to write
+ # space-separated words, so they are not treated specially and handled
+ # like the all of the other languages.
+ if (
+ (cp >= 0x4E00 and cp <= 0x9FFF)
+ or (cp >= 0x3400 and cp <= 0x4DBF)
+ or (cp >= 0x20000 and cp <= 0x2A6DF)
+ or (cp >= 0x2A700 and cp <= 0x2B73F)
+ or (cp >= 0x2B740 and cp <= 0x2B81F)
+ or (cp >= 0x2B820 and cp <= 0x2CEAF)
+ or (cp >= 0xF900 and cp <= 0xFAFF)
+ or (cp >= 0x2F800 and cp <= 0x2FA1F)
+ ):
+ return True
+
+ return False
+
+ def _clean_text(self, text):
+ """Performs invalid character removal and whitespace cleanup on text."""
+ output = []
+ for char in text:
+ cp = ord(char)
+ if cp == 0 or cp == 0xFFFD or _is_control(char):
+ continue
+ if _is_whitespace(char):
+ output.append(" ")
+ else:
+ output.append(char)
+ return "".join(output)
+
+
+class WordpieceTokenizer:
+ """Runs WordPiece tokenization."""
+
+ def __init__(self, vocab, unk_token, max_input_chars_per_word=100):
+ self.vocab = vocab
+ self.unk_token = unk_token
+ self.max_input_chars_per_word = max_input_chars_per_word
+
+ def tokenize(self, text):
+ """
+ Tokenizes a piece of text into its word pieces. This uses a greedy longest-match-first algorithm to perform
+ tokenization using the given vocabulary.
+
+ For example, `input = "unaffable"` will return as output `["un", "##aff", "##able"]`.
+
+ Args:
+ text: A single token or whitespace separated tokens. This should have
+ already been passed through *BasicTokenizer*.
+
+ Returns:
+ A list of wordpiece tokens.
+ """
+
+ output_tokens = []
+ for token in whitespace_tokenize(text):
+ chars = list(token)
+ if len(chars) > self.max_input_chars_per_word:
+ output_tokens.append(self.unk_token)
+ continue
+
+ is_bad = False
+ start = 0
+ sub_tokens = []
+ while start < len(chars):
+ end = len(chars)
+ cur_substr = None
+ while start < end:
+ substr = "".join(chars[start:end])
+ if start > 0:
+ substr = "##" + substr
+ if substr in self.vocab:
+ cur_substr = substr
+ break
+ end -= 1
+ if cur_substr is None:
+ is_bad = True
+ break
+ sub_tokens.append(cur_substr)
+ start = end
+
+ if is_bad:
+ output_tokens.append(self.unk_token)
+ else:
+ output_tokens.extend(sub_tokens)
+ return output_tokens
+
+
+# Below: utilities for TAPAS tokenizer
+# This includes functions to parse numeric values (dates and numbers) from both the table and questions in order
+# to create the column_ranks, inv_column_ranks, numeric_values, numeric values_scale and numeric_relations in
+# prepare_for_model of TapasTokenizer.
+# These are meant to be used in an academic setup, for production use cases Gold mine or Aqua should be used.
+
+
+# taken from constants.py of the original implementation
+# URL: https://github.com/google-research/tapas/blob/master/tapas/utils/constants.py
+class Relation(enum.Enum):
+ HEADER_TO_CELL = 1 # Connects header to cell.
+ CELL_TO_HEADER = 2 # Connects cell to header.
+ QUERY_TO_HEADER = 3 # Connects query to headers.
+ QUERY_TO_CELL = 4 # Connects query to cells.
+ ROW_TO_CELL = 5 # Connects row to cells.
+ CELL_TO_ROW = 6 # Connects cells to row.
+ EQ = 7 # Annotation value is same as cell value
+ LT = 8 # Annotation value is less than cell value
+ GT = 9 # Annotation value is greater than cell value
+
+
+@dataclass
+class Date:
+ year: int | None = None
+ month: int | None = None
+ day: int | None = None
+
+
+@dataclass
+class NumericValue:
+ float_value: float | None = None
+ date: Date | None = None
+
+
+@dataclass
+class NumericValueSpan:
+ begin_index: int | None = None
+ end_index: int | None = None
+ values: list[NumericValue] = None
+
+
+@dataclass
+class Cell:
+ text: str
+ numeric_value: NumericValue | None = None
+
+
+@dataclass
+class Question:
+ original_text: str # The original raw question string.
+ text: str # The question string after normalization.
+ numeric_spans: list[NumericValueSpan] | None = None
+
+
+# Below: all functions from number_utils.py as well as 2 functions (namely get_all_spans and normalize_for_match)
+# from text_utils.py of the original implementation. URL's:
+# - https://github.com/google-research/tapas/blob/master/tapas/utils/number_utils.py
+# - https://github.com/google-research/tapas/blob/master/tapas/utils/text_utils.py
+
+
+# Constants for parsing date expressions.
+# Masks that specify (by a bool) which of (year, month, day) will be populated.
+_DateMask = collections.namedtuple("_DateMask", ["year", "month", "day"])
+
+_YEAR = _DateMask(True, False, False)
+_YEAR_MONTH = _DateMask(True, True, False)
+_YEAR_MONTH_DAY = _DateMask(True, True, True)
+_MONTH = _DateMask(False, True, False)
+_MONTH_DAY = _DateMask(False, True, True)
+
+# Pairs of patterns to pass to 'datetime.strptime' and masks specifying which
+# fields will be set by the corresponding pattern.
+_DATE_PATTERNS = (
+ ("%B", _MONTH),
+ ("%Y", _YEAR),
+ ("%Ys", _YEAR),
+ ("%b %Y", _YEAR_MONTH),
+ ("%B %Y", _YEAR_MONTH),
+ ("%B %d", _MONTH_DAY),
+ ("%b %d", _MONTH_DAY),
+ ("%d %b", _MONTH_DAY),
+ ("%d %B", _MONTH_DAY),
+ ("%B %d, %Y", _YEAR_MONTH_DAY),
+ ("%d %B %Y", _YEAR_MONTH_DAY),
+ ("%m-%d-%Y", _YEAR_MONTH_DAY),
+ ("%Y-%m-%d", _YEAR_MONTH_DAY),
+ ("%Y-%m", _YEAR_MONTH),
+ ("%B %Y", _YEAR_MONTH),
+ ("%d %b %Y", _YEAR_MONTH_DAY),
+ ("%Y-%m-%d", _YEAR_MONTH_DAY),
+ ("%b %d, %Y", _YEAR_MONTH_DAY),
+ ("%d.%m.%Y", _YEAR_MONTH_DAY),
+ ("%A, %b %d", _MONTH_DAY),
+ ("%A, %B %d", _MONTH_DAY),
+)
+
+# This mapping is used to convert date patterns to regex patterns.
+_FIELD_TO_REGEX = (
+ ("%A", r"\w+"), # Weekday as locale’s full name.
+ ("%B", r"\w+"), # Month as locale’s full name.
+ ("%Y", r"\d{4}"), # Year with century as a decimal number.
+ ("%b", r"\w{3}"), # Month as locale’s abbreviated name.
+ ("%d", r"\d{1,2}"), # Day of the month as a zero-padded decimal number.
+ ("%m", r"\d{1,2}"), # Month as a zero-padded decimal number.
+)
+
+
+def _process_date_pattern(dp):
+ """Compute a regex for each date pattern to use as a prefilter."""
+ pattern, mask = dp
+ regex = pattern
+ regex = regex.replace(".", re.escape("."))
+ regex = regex.replace("-", re.escape("-"))
+ regex = regex.replace(" ", r"\s+")
+ for field, field_regex in _FIELD_TO_REGEX:
+ regex = regex.replace(field, field_regex)
+ # Make sure we didn't miss any of the fields.
+ assert "%" not in regex, regex
+ return pattern, mask, re.compile("^" + regex + "$")
+
+
+def _process_date_patterns():
+ return tuple(_process_date_pattern(dp) for dp in _DATE_PATTERNS)
+
+
+_PROCESSED_DATE_PATTERNS = _process_date_patterns()
+
+_MAX_DATE_NGRAM_SIZE = 5
+
+# Following DynSp:
+# https://github.com/Microsoft/DynSP/blob/master/util.py#L414.
+_NUMBER_WORDS = [
+ "zero",
+ "one",
+ "two",
+ "three",
+ "four",
+ "five",
+ "six",
+ "seven",
+ "eight",
+ "nine",
+ "ten",
+ "eleven",
+ "twelve",
+]
+
+_ORDINAL_WORDS = [
+ "zeroth",
+ "first",
+ "second",
+ "third",
+ "fourth",
+ "fifth",
+ "sixth",
+ "seventh",
+ "eighth",
+ "ninth",
+ "tenth",
+ "eleventh",
+ "twelfth",
+]
+
+_ORDINAL_SUFFIXES = ["st", "nd", "rd", "th"]
+
+_NUMBER_PATTERN = re.compile(r"((^|\s)[+-])?((\.\d+)|(\d+(,\d\d\d)*(\.\d*)?))")
+
+# Following DynSp:
+# https://github.com/Microsoft/DynSP/blob/master/util.py#L293.
+_MIN_YEAR = 1700
+_MAX_YEAR = 2016
+
+_INF = float("INF")
+
+
+def _get_numeric_value_from_date(date, mask):
+ """Converts date (datetime Python object) to a NumericValue object with a Date object value."""
+ if date.year < _MIN_YEAR or date.year > _MAX_YEAR:
+ raise ValueError(f"Invalid year: {date.year}")
+
+ new_date = Date()
+ if mask.year:
+ new_date.year = date.year
+ if mask.month:
+ new_date.month = date.month
+ if mask.day:
+ new_date.day = date.day
+ return NumericValue(date=new_date)
+
+
+def _get_span_length_key(span):
+ """Sorts span by decreasing length first and increasing first index second."""
+ return span[1] - span[0], -span[0]
+
+
+def _get_numeric_value_from_float(value):
+ """Converts float (Python) to a NumericValue object with a float value."""
+ return NumericValue(float_value=value)
+
+
+# Doesn't parse ordinal expressions such as '18th of february 1655'.
+def _parse_date(text):
+ """Attempts to format a text as a standard date string (yyyy-mm-dd)."""
+ text = re.sub(r"Sept\b", "Sep", text)
+ for in_pattern, mask, regex in _PROCESSED_DATE_PATTERNS:
+ if not regex.match(text):
+ continue
+ try:
+ date = datetime.datetime.strptime(text, in_pattern).date()
+ except ValueError:
+ continue
+ try:
+ return _get_numeric_value_from_date(date, mask)
+ except ValueError:
+ continue
+ return None
+
+
+def _parse_number(text):
+ """Parses simple cardinal and ordinals numbers."""
+ for suffix in _ORDINAL_SUFFIXES:
+ if text.endswith(suffix):
+ text = text[: -len(suffix)]
+ break
+ text = text.replace(",", "")
+ try:
+ value = float(text)
+ except ValueError:
+ return None
+ if math.isnan(value):
+ return None
+ if value == _INF:
+ return None
+ return value
+
+
+def get_all_spans(text, max_ngram_length):
+ """
+ Split a text into all possible ngrams up to 'max_ngram_length'. Split points are white space and punctuation.
+
+ Args:
+ text: Text to split.
+ max_ngram_length: maximal ngram length.
+ Yields:
+ Spans, tuples of begin-end index.
+ """
+ start_indexes = []
+ for index, char in enumerate(text):
+ if not char.isalnum():
+ continue
+ if index == 0 or not text[index - 1].isalnum():
+ start_indexes.append(index)
+ if index + 1 == len(text) or not text[index + 1].isalnum():
+ for start_index in start_indexes[-max_ngram_length:]:
+ yield start_index, index + 1
+
+
+def normalize_for_match(text):
+ return " ".join(text.lower().split())
+
+
+def format_text(text):
+ """Lowercases and strips punctuation."""
+ text = text.lower().strip()
+ if text == "n/a" or text == "?" or text == "nan":
+ text = EMPTY_TEXT
+
+ text = re.sub(r"[^\w\d]+", " ", text).replace("_", " ")
+ text = " ".join(text.split())
+ text = text.strip()
+ if text:
+ return text
+ return EMPTY_TEXT
+
+
+def parse_text(text):
+ """
+ Extracts longest number and date spans.
+
+ Args:
+ text: text to annotate
+
+ Returns:
+ List of longest numeric value spans.
+ """
+ span_dict = collections.defaultdict(list)
+ for match in _NUMBER_PATTERN.finditer(text):
+ span_text = text[match.start() : match.end()]
+ number = _parse_number(span_text)
+ if number is not None:
+ span_dict[match.span()].append(_get_numeric_value_from_float(number))
+
+ for begin_index, end_index in get_all_spans(text, max_ngram_length=1):
+ if (begin_index, end_index) in span_dict:
+ continue
+ span_text = text[begin_index:end_index]
+
+ number = _parse_number(span_text)
+ if number is not None:
+ span_dict[begin_index, end_index].append(_get_numeric_value_from_float(number))
+ for number, word in enumerate(_NUMBER_WORDS):
+ if span_text == word:
+ span_dict[begin_index, end_index].append(_get_numeric_value_from_float(float(number)))
+ break
+ for number, word in enumerate(_ORDINAL_WORDS):
+ if span_text == word:
+ span_dict[begin_index, end_index].append(_get_numeric_value_from_float(float(number)))
+ break
+
+ for begin_index, end_index in get_all_spans(text, max_ngram_length=_MAX_DATE_NGRAM_SIZE):
+ span_text = text[begin_index:end_index]
+ date = _parse_date(span_text)
+ if date is not None:
+ span_dict[begin_index, end_index].append(date)
+
+ spans = sorted(span_dict.items(), key=lambda span_value: _get_span_length_key(span_value[0]), reverse=True)
+ selected_spans = []
+ for span, value in spans:
+ for selected_span, _ in selected_spans:
+ if selected_span[0] <= span[0] and span[1] <= selected_span[1]:
+ break
+ else:
+ selected_spans.append((span, value))
+
+ selected_spans.sort(key=lambda span_value: span_value[0][0])
+
+ numeric_value_spans = []
+ for span, values in selected_spans:
+ numeric_value_spans.append(NumericValueSpan(begin_index=span[0], end_index=span[1], values=values))
+ return numeric_value_spans
+
+
+# Below: all functions from number_annotation_utils.py and 2 functions (namely filter_invalid_unicode
+# and filter_invalid_unicode_from_table) from text_utils.py of the original implementation. URL's:
+# - https://github.com/google-research/tapas/blob/master/tapas/utils/number_annotation_utils.py
+# - https://github.com/google-research/tapas/blob/master/tapas/utils/text_utils.py
+
+
+_PrimitiveNumericValue = float | tuple[float | None]
+_SortKeyFn = Callable[[NumericValue], tuple[float, Ellipsis]]
+
+_DATE_TUPLE_SIZE = 3
+
+EMPTY_TEXT = "EMPTY"
+
+NUMBER_TYPE = "number"
+DATE_TYPE = "date"
+
+
+def _get_value_type(numeric_value):
+ if numeric_value.float_value is not None:
+ return NUMBER_TYPE
+ elif numeric_value.date is not None:
+ return DATE_TYPE
+ raise ValueError(f"Unknown type: {numeric_value}")
+
+
+def _get_value_as_primitive_value(numeric_value):
+ """Maps a NumericValue proto to a float or tuple of float."""
+ if numeric_value.float_value is not None:
+ return numeric_value.float_value
+ if numeric_value.date is not None:
+ date = numeric_value.date
+ value_tuple = [None, None, None]
+ # All dates fields are cased to float to produce a simple primitive value.
+ if date.year is not None:
+ value_tuple[0] = float(date.year)
+ if date.month is not None:
+ value_tuple[1] = float(date.month)
+ if date.day is not None:
+ value_tuple[2] = float(date.day)
+ return tuple(value_tuple)
+ raise ValueError(f"Unknown type: {numeric_value}")
+
+
+def _get_all_types(numeric_values):
+ return {_get_value_type(value) for value in numeric_values}
+
+
+def get_numeric_sort_key_fn(numeric_values):
+ """
+ Creates a function that can be used as a sort key or to compare the values. Maps to primitive types and finds the
+ biggest common subset. Consider the values "05/05/2010" and "August 2007". With the corresponding primitive values
+ (2010.,5.,5.) and (2007.,8., None). These values can be compared by year and date so we map to the sequence (2010.,
+ 5.), (2007., 8.). If we added a third value "2006" with primitive value (2006., None, None), we could only compare
+ by the year so we would map to (2010.,), (2007.,) and (2006.,).
+
+ Args:
+ numeric_values: Values to compare
+
+ Returns:
+ A function that can be used as a sort key function (mapping numeric values to a comparable tuple)
+
+ Raises:
+ ValueError if values don't have a common type or are not comparable.
+ """
+ value_types = _get_all_types(numeric_values)
+ if len(value_types) != 1:
+ raise ValueError(f"No common value type in {numeric_values}")
+
+ value_type = next(iter(value_types))
+ if value_type == NUMBER_TYPE:
+ # Primitive values are simple floats, nothing to do here.
+ return _get_value_as_primitive_value
+
+ # The type can only be Date at this point which means the primitive type
+ # is a float triple.
+ valid_indexes = set(range(_DATE_TUPLE_SIZE))
+
+ for numeric_value in numeric_values:
+ value = _get_value_as_primitive_value(numeric_value)
+ assert isinstance(value, tuple)
+ for tuple_index, inner_value in enumerate(value):
+ if inner_value is None:
+ valid_indexes.discard(tuple_index)
+
+ if not valid_indexes:
+ raise ValueError(f"No common value in {numeric_values}")
+
+ def _sort_key_fn(numeric_value):
+ value = _get_value_as_primitive_value(numeric_value)
+ return tuple(value[index] for index in valid_indexes)
+
+ return _sort_key_fn
+
+
+def _consolidate_numeric_values(row_index_to_values, min_consolidation_fraction, debug_info):
+ """
+ Finds the most common numeric values in a column and returns them
+
+ Args:
+ row_index_to_values:
+ For each row index all the values in that cell.
+ min_consolidation_fraction:
+ Fraction of cells that need to have consolidated value.
+ debug_info:
+ Additional information only used for logging
+
+ Returns:
+ For each row index the first value that matches the most common value. Rows that don't have a matching value
+ are dropped. Empty list if values can't be consolidated.
+ """
+ type_counts = collections.Counter()
+ for numeric_values in row_index_to_values.values():
+ type_counts.update(_get_all_types(numeric_values))
+ if not type_counts:
+ return {}
+ max_count = max(type_counts.values())
+ if max_count < len(row_index_to_values) * min_consolidation_fraction:
+ # logging.log_every_n(logging.INFO, f'Can\'t consolidate types: {debug_info} {row_index_to_values} {max_count}', 100)
+ return {}
+
+ valid_types = set()
+ for value_type, count in type_counts.items():
+ if count == max_count:
+ valid_types.add(value_type)
+ if len(valid_types) > 1:
+ assert DATE_TYPE in valid_types
+ max_type = DATE_TYPE
+ else:
+ max_type = next(iter(valid_types))
+
+ new_row_index_to_value = {}
+ for index, values in row_index_to_values.items():
+ # Extract the first matching value.
+ for value in values:
+ if _get_value_type(value) == max_type:
+ new_row_index_to_value[index] = value
+ break
+
+ return new_row_index_to_value
+
+
+def _get_numeric_values(text):
+ """Parses text and returns numeric values."""
+ numeric_spans = parse_text(text)
+ return itertools.chain(*(span.values for span in numeric_spans))
+
+
+def _get_column_values(table, col_index):
+ """
+ Parses text in column and returns a dict mapping row_index to values. This is the _get_column_values function from
+ number_annotation_utils.py of the original implementation
+
+ Args:
+ table: Pandas dataframe
+ col_index: integer, indicating the index of the column to get the numeric values of
+ """
+ index_to_values = {}
+ for row_index, row in table.iterrows():
+ text = normalize_for_match(row[col_index].text)
+ index_to_values[row_index] = list(_get_numeric_values(text))
+ return index_to_values
+
+
+def get_numeric_relation(value, other_value, sort_key_fn):
+ """Compares two values and returns their relation or None."""
+ value = sort_key_fn(value)
+ other_value = sort_key_fn(other_value)
+ if value == other_value:
+ return Relation.EQ
+ if value < other_value:
+ return Relation.LT
+ if value > other_value:
+ return Relation.GT
+ return None
+
+
+def add_numeric_values_to_question(question):
+ """Adds numeric value spans to a question."""
+ original_text = question
+ question = normalize_for_match(question)
+ numeric_spans = parse_text(question)
+ return Question(original_text=original_text, text=question, numeric_spans=numeric_spans)
+
+
+def filter_invalid_unicode(text):
+ """Return an empty string and True if 'text' is in invalid unicode."""
+ return ("", True) if isinstance(text, bytes) else (text, False)
+
+
+def filter_invalid_unicode_from_table(table):
+ """
+ Removes invalid unicode from table. Checks whether a table cell text contains an invalid unicode encoding. If yes,
+ reset the table cell text to an empty str and log a warning for each invalid cell
+
+ Args:
+ table: table to clean.
+ """
+ # to do: add table id support
+ if not hasattr(table, "table_id"):
+ table.table_id = 0
+
+ for row_index, row in table.iterrows():
+ for col_index, cell in enumerate(row):
+ cell, is_invalid = filter_invalid_unicode(cell)
+ if is_invalid:
+ logging.warning(
+ f"Scrub an invalid table body @ table_id: {table.table_id}, row_index: {row_index}, "
+ f"col_index: {col_index}",
+ )
+ for col_index, column in enumerate(table.columns):
+ column, is_invalid = filter_invalid_unicode(column)
+ if is_invalid:
+ logging.warning(f"Scrub an invalid table header @ table_id: {table.table_id}, col_index: {col_index}")
+
+
+def add_numeric_table_values(table, min_consolidation_fraction=0.7, debug_info=None):
+ """
+ Parses text in table column-wise and adds the consolidated values. Consolidation refers to finding values with a
+ common types (date or number)
+
+ Args:
+ table:
+ Table to annotate.
+ min_consolidation_fraction:
+ Fraction of cells in a column that need to have consolidated value.
+ debug_info:
+ Additional information used for logging.
+ """
+ table = table.copy()
+ # First, filter table on invalid unicode
+ filter_invalid_unicode_from_table(table)
+
+ # Second, replace cell values by Cell objects
+ for row_index, row in table.iterrows():
+ for col_index, cell in enumerate(row):
+ table.iloc[row_index, col_index] = Cell(text=cell)
+
+ # Third, add numeric_value attributes to these Cell objects
+ for col_index, column in enumerate(table.columns):
+ column_values = _consolidate_numeric_values(
+ _get_column_values(table, col_index),
+ min_consolidation_fraction=min_consolidation_fraction,
+ debug_info=(debug_info, column),
+ )
+
+ for row_index, numeric_value in column_values.items():
+ table.iloc[row_index, col_index].numeric_value = numeric_value
+
+ return table
+
+
+__all__ = ["TapasTokenizer"]
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/__init__.py b/lib/python3.11/site-packages/transformers/models/textnet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..50f579a53e7c35a0eab03bfb9f5a0f291b85df70
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/textnet/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2024 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_textnet import *
+ from .image_processing_pil_textnet import *
+ from .image_processing_textnet import *
+ from .modeling_textnet import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fbbb7c8a483785d90330e67bb797d1d910d24fb2
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/configuration_textnet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/configuration_textnet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7291c45168cdecec652c6f68aaa16e064219425d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/configuration_textnet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/image_processing_pil_textnet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/image_processing_pil_textnet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e54032fc5e92b04c266b212c8ab96dabc718477
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/image_processing_pil_textnet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/image_processing_textnet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/image_processing_textnet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bfe25c1ad2bcd778c137ae18a61ab94192e6b591
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/image_processing_textnet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/modeling_textnet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/modeling_textnet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c929f03114eaba43dab377faef43e187b2ffea11
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/textnet/__pycache__/modeling_textnet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/configuration_textnet.py b/lib/python3.11/site-packages/transformers/models/textnet/configuration_textnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..0dec21407f658fc6db7691e98adda62000a87695
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/textnet/configuration_textnet.py
@@ -0,0 +1,94 @@
+# Copyright 2024 the Fast authors and HuggingFace Inc. 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.
+"""TextNet model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import BackboneConfigMixin
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="czczup/textnet-base")
+@strict
+class TextNetConfig(BackboneConfigMixin, PreTrainedConfig):
+ r"""
+ stem_kernel_size (`int`, *optional*, defaults to 3):
+ The kernel size for the initial convolution layer.
+ stem_stride (`int`, *optional*, defaults to 2):
+ The stride for the initial convolution layer.
+ stem_num_channels (`int`, *optional*, defaults to 3):
+ The num of channels in input for the initial convolution layer.
+ stem_out_channels (`int`, *optional*, defaults to 64):
+ The num of channels in out for the initial convolution layer.
+ stem_act_func (`str`, *optional*, defaults to `"relu"`):
+ The activation function for the initial convolution layer.
+ conv_layer_kernel_sizes (`list[list[list[int]]]`, *optional*):
+ A list of stage-wise kernel sizes. If `None`, defaults to:
+ `[[[3, 3], [3, 3], [3, 3]], [[3, 3], [1, 3], [3, 3], [3, 1]], [[3, 3], [3, 3], [3, 1], [1, 3]], [[3, 3], [3, 1], [1, 3], [3, 3]]]`.
+ conv_layer_strides (`list[list[int]]`, *optional*):
+ A list of stage-wise strides. If `None`, defaults to:
+ `[[1, 2, 1], [2, 1, 1, 1], [2, 1, 1, 1], [2, 1, 1, 1]]`.
+
+ Examples:
+
+ ```python
+ >>> from transformers import TextNetConfig, TextNetBackbone
+
+ >>> # Initializing a TextNetConfig
+ >>> configuration = TextNetConfig()
+
+ >>> # Initializing a model (with random weights)
+ >>> model = TextNetBackbone(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "textnet"
+
+ stem_kernel_size: int = 3
+ stem_stride: int = 2
+ stem_num_channels: int = 3
+ stem_out_channels: int = 64
+ stem_act_func: str = "relu"
+ image_size: list[int] | tuple[int, int] | int = (640, 640)
+ conv_layer_kernel_sizes: list | None = None
+ conv_layer_strides: list | None = None
+ hidden_sizes: list[int] | tuple[int, ...] = (64, 64, 128, 256, 512)
+ batch_norm_eps: float = 1e-5
+ initializer_range: float = 0.02
+ _out_features: list[str] | None = None
+ _out_indices: list[int] | None = None
+
+ def __post_init__(self, **kwargs):
+ if self.conv_layer_kernel_sizes is None:
+ self.conv_layer_kernel_sizes = [
+ [[3, 3], [3, 3], [3, 3]],
+ [[3, 3], [1, 3], [3, 3], [3, 1]],
+ [[3, 3], [3, 3], [3, 1], [1, 3]],
+ [[3, 3], [3, 1], [1, 3], [3, 3]],
+ ]
+ if self.conv_layer_strides is None:
+ self.conv_layer_strides = [[1, 2, 1], [2, 1, 1, 1], [2, 1, 1, 1], [2, 1, 1, 1]]
+
+ self.depths = [len(layer) for layer in self.conv_layer_kernel_sizes]
+ self.stage_names = ["stem"] + [f"stage{idx}" for idx in range(1, 5)]
+ self.set_output_features_output_indices(
+ out_indices=kwargs.pop("out_indices", None), out_features=kwargs.pop("out_features", None)
+ )
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["TextNetConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/image_processing_pil_textnet.py b/lib/python3.11/site-packages/transformers/models/textnet/image_processing_pil_textnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..5efeeb4d6eb14a2aa298a5964fcc6b87a311deb1
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/textnet/image_processing_pil_textnet.py
@@ -0,0 +1,134 @@
+# Copyright 2024 the Fast authors and The HuggingFace Inc. 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.
+"""Image processor class for TextNet."""
+
+import numpy as np
+
+from ...image_processing_backends import PilBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import get_resize_output_image_size
+from ...image_transforms import resize as np_resize
+from ...image_utils import (
+ IMAGENET_DEFAULT_MEAN,
+ IMAGENET_DEFAULT_STD,
+ ChannelDimension,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+# Adapted from transformers.models.textnet.image_processing_textnet.TextNetImageProcessorKwargs
+class TextNetImageProcessorKwargs(ImagesKwargs, total=False):
+ """
+ size_divisor (`int`, *optional*, defaults to `self.size_divisor`):
+ Ensures height and width are rounded to a multiple of this value after resizing.
+ """
+
+ size_divisor: int
+
+
+@auto_docstring
+class TextNetImageProcessorPil(PilBackend):
+ """PIL backend for TextNet with size_divisor resize."""
+
+ valid_kwargs = TextNetImageProcessorKwargs
+
+ resample = PILImageResampling.BILINEAR
+ image_mean = IMAGENET_DEFAULT_MEAN
+ image_std = IMAGENET_DEFAULT_STD
+ size = {"shortest_edge": 640}
+ default_to_square = False
+ crop_size = {"height": 224, "width": 224}
+ do_resize = True
+ do_center_crop = False
+ do_rescale = True
+ do_normalize = True
+ do_convert_rgb = True
+ size_divisor = 32
+
+ def __init__(self, **kwargs: Unpack[TextNetImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(self, images: ImageInput, **kwargs: Unpack[TextNetImageProcessorKwargs]) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def resize(
+ self,
+ image: np.ndarray,
+ size: SizeDict,
+ resample: "PILImageResampling | None",
+ size_divisor: int = 32,
+ **kwargs,
+ ) -> np.ndarray:
+ """Resize to shortest_edge then round up to be divisible by size_divisor."""
+ if not size.shortest_edge:
+ raise ValueError(f"Size must contain 'shortest_edge' key. Got {size.keys()}")
+ height, width = get_resize_output_image_size(
+ image,
+ size=size.shortest_edge,
+ default_to_square=False,
+ input_data_format=ChannelDimension.FIRST,
+ )
+ # Round up to be divisible by size_divisor
+ if height % size_divisor != 0:
+ height += size_divisor - (height % size_divisor)
+ if width % size_divisor != 0:
+ width += size_divisor - (width % size_divisor)
+ return np_resize(
+ image,
+ size=(height, width),
+ resample=resample,
+ data_format=ChannelDimension.FIRST,
+ input_data_format=ChannelDimension.FIRST,
+ )
+
+ def _preprocess(
+ self,
+ images: list[np.ndarray],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | None",
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_pad: bool | None,
+ pad_size: SizeDict | None,
+ return_tensors: str | TensorType | None,
+ size_divisor: int = 32,
+ **kwargs,
+ ) -> BatchFeature:
+ """Custom preprocessing for TextNet."""
+ processed_images = []
+ for image in images:
+ if do_resize:
+ image = self.resize(image, size, resample, size_divisor=size_divisor)
+ if do_center_crop:
+ image = self.center_crop(image, crop_size)
+ if do_rescale:
+ image = self.rescale(image, rescale_factor)
+ if do_normalize:
+ image = self.normalize(image, image_mean, image_std)
+ processed_images.append(image)
+ return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+
+__all__ = ["TextNetImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/image_processing_textnet.py b/lib/python3.11/site-packages/transformers/models/textnet/image_processing_textnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..df82faf0a265ac1fdc9909813427db1c4c20fc6a
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/textnet/image_processing_textnet.py
@@ -0,0 +1,141 @@
+# Copyright 2024 the Fast authors and The HuggingFace Inc. 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.
+"""Image processor class for TextNet."""
+
+import torch
+from torchvision.transforms.v2 import functional as tvF
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import get_resize_output_image_size, group_images_by_shape, reorder_images
+from ...image_utils import (
+ IMAGENET_DEFAULT_MEAN,
+ IMAGENET_DEFAULT_STD,
+ ChannelDimension,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+class TextNetImageProcessorKwargs(ImagesKwargs, total=False):
+ """
+ size_divisor (`int`, *optional*, defaults to `self.size_divisor`):
+ Ensures height and width are rounded to a multiple of this value after resizing.
+ """
+
+ size_divisor: int
+
+
+@auto_docstring
+class TextNetImageProcessor(TorchvisionBackend):
+ """Torchvision backend for TextNet with size_divisor resize."""
+
+ valid_kwargs = TextNetImageProcessorKwargs
+
+ resample = PILImageResampling.BILINEAR
+ image_mean = IMAGENET_DEFAULT_MEAN
+ image_std = IMAGENET_DEFAULT_STD
+ size = {"shortest_edge": 640}
+ default_to_square = False
+ crop_size = {"height": 224, "width": 224}
+ do_resize = True
+ do_center_crop = False
+ do_rescale = True
+ do_normalize = True
+ do_convert_rgb = True
+ size_divisor = 32
+
+ def __init__(self, **kwargs: Unpack[TextNetImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(self, images: ImageInput, **kwargs: Unpack[TextNetImageProcessorKwargs]) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def resize(
+ self,
+ image: "torch.Tensor",
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+ size_divisor: int = 32,
+ **kwargs,
+ ) -> "torch.Tensor":
+ """Resize to shortest_edge then round up to be divisible by size_divisor."""
+ if not size.shortest_edge:
+ raise ValueError(f"Size must contain 'shortest_edge' key. Got {size.keys()}")
+ new_size = get_resize_output_image_size(
+ image,
+ size=size.shortest_edge,
+ default_to_square=False,
+ input_data_format=ChannelDimension.FIRST,
+ )
+ height, width = new_size
+ # Round up to be divisible by size_divisor
+ if height % size_divisor != 0:
+ height += size_divisor - (height % size_divisor)
+ if width % size_divisor != 0:
+ width += size_divisor - (width % size_divisor)
+ return super().resize(
+ image,
+ SizeDict(height=height, width=width),
+ resample=resample,
+ **kwargs,
+ )
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_pad: bool | None,
+ pad_size: SizeDict | None,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ size_divisor: int = 32,
+ **kwargs,
+ ) -> BatchFeature:
+ """Custom preprocessing for TextNet."""
+ grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+ resized_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_resize:
+ stacked_images = self.resize(stacked_images, size, resample, size_divisor=size_divisor)
+ resized_images_grouped[shape] = stacked_images
+ resized_images = reorder_images(resized_images_grouped, grouped_images_index)
+
+ grouped_images, grouped_images_index = group_images_by_shape(resized_images, disable_grouping=disable_grouping)
+ processed_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_center_crop:
+ stacked_images = self.center_crop(stacked_images, crop_size)
+ stacked_images = self.rescale_and_normalize(
+ stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ processed_images_grouped[shape] = stacked_images
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index)
+ return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+
+__all__ = ["TextNetImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/textnet/modeling_textnet.py b/lib/python3.11/site-packages/transformers/models/textnet/modeling_textnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..e18619dd7953905a9e272445ee01b0134b4932d4
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/textnet/modeling_textnet.py
@@ -0,0 +1,417 @@
+# Copyright 2024 the Fast authors and The HuggingFace Inc. 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.
+"""PyTorch TextNet model."""
+
+from typing import Any
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from ...activations import ACT2CLS
+from ...backbone_utils import BackboneMixin, filter_output_hidden_states
+from ...modeling_outputs import (
+ BackboneOutput,
+ BaseModelOutputWithNoAttention,
+ BaseModelOutputWithPoolingAndNoAttention,
+ ImageClassifierOutputWithNoAttention,
+)
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring, logging
+from ...utils.generic import can_return_tuple
+from .configuration_textnet import TextNetConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+class TextNetConvLayer(nn.Module):
+ def __init__(self, config: TextNetConfig):
+ super().__init__()
+
+ self.kernel_size = config.stem_kernel_size
+ self.stride = config.stem_stride
+ self.activation_function = config.stem_act_func
+
+ padding = (
+ (config.kernel_size[0] // 2, config.kernel_size[1] // 2)
+ if isinstance(config.stem_kernel_size, tuple)
+ else config.stem_kernel_size // 2
+ )
+
+ self.conv = nn.Conv2d(
+ config.stem_num_channels,
+ config.stem_out_channels,
+ kernel_size=config.stem_kernel_size,
+ stride=config.stem_stride,
+ padding=padding,
+ bias=False,
+ )
+ self.batch_norm = nn.BatchNorm2d(config.stem_out_channels, config.batch_norm_eps)
+
+ self.activation = nn.Identity()
+ if self.activation_function is not None:
+ self.activation = ACT2CLS[self.activation_function]()
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.batch_norm(hidden_states)
+ return self.activation(hidden_states)
+
+
+class TextNetRepConvLayer(nn.Module):
+ r"""
+ This layer supports re-parameterization by combining multiple convolutional branches
+ (e.g., main convolution, vertical, horizontal, and identity branches) during training.
+ At inference time, these branches can be collapsed into a single convolution for
+ efficiency, as per the re-parameterization paradigm.
+
+ The "Rep" in the name stands for "re-parameterization" (introduced by RepVGG).
+ """
+
+ def __init__(self, config: TextNetConfig, in_channels: int, out_channels: int, kernel_size: int, stride: int):
+ super().__init__()
+
+ self.num_channels = in_channels
+ self.out_channels = out_channels
+ self.kernel_size = kernel_size
+ self.stride = stride
+
+ padding = ((kernel_size[0] - 1) // 2, (kernel_size[1] - 1) // 2)
+
+ self.activation_function = nn.ReLU()
+
+ self.main_conv = nn.Conv2d(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=padding,
+ bias=False,
+ )
+ self.main_batch_norm = nn.BatchNorm2d(num_features=out_channels, eps=config.batch_norm_eps)
+
+ vertical_padding = ((kernel_size[0] - 1) // 2, 0)
+ horizontal_padding = (0, (kernel_size[1] - 1) // 2)
+
+ if kernel_size[1] != 1:
+ self.vertical_conv = nn.Conv2d(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=(kernel_size[0], 1),
+ stride=stride,
+ padding=vertical_padding,
+ bias=False,
+ )
+ self.vertical_batch_norm = nn.BatchNorm2d(num_features=out_channels, eps=config.batch_norm_eps)
+ else:
+ self.vertical_conv, self.vertical_batch_norm = None, None
+
+ if kernel_size[0] != 1:
+ self.horizontal_conv = nn.Conv2d(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=(1, kernel_size[1]),
+ stride=stride,
+ padding=horizontal_padding,
+ bias=False,
+ )
+ self.horizontal_batch_norm = nn.BatchNorm2d(num_features=out_channels, eps=config.batch_norm_eps)
+ else:
+ self.horizontal_conv, self.horizontal_batch_norm = None, None
+
+ self.rbr_identity = (
+ nn.BatchNorm2d(num_features=in_channels, eps=config.batch_norm_eps)
+ if out_channels == in_channels and stride == 1
+ else None
+ )
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ main_outputs = self.main_conv(hidden_states)
+ main_outputs = self.main_batch_norm(main_outputs)
+
+ # applies a convolution with a vertical kernel
+ if self.vertical_conv is not None:
+ vertical_outputs = self.vertical_conv(hidden_states)
+ vertical_outputs = self.vertical_batch_norm(vertical_outputs)
+ main_outputs = main_outputs + vertical_outputs
+
+ # applies a convolution with a horizontal kernel
+ if self.horizontal_conv is not None:
+ horizontal_outputs = self.horizontal_conv(hidden_states)
+ horizontal_outputs = self.horizontal_batch_norm(horizontal_outputs)
+ main_outputs = main_outputs + horizontal_outputs
+
+ if self.rbr_identity is not None:
+ id_out = self.rbr_identity(hidden_states)
+ main_outputs = main_outputs + id_out
+
+ return self.activation_function(main_outputs)
+
+
+class TextNetStage(nn.Module):
+ def __init__(self, config: TextNetConfig, depth: int):
+ super().__init__()
+ kernel_size = config.conv_layer_kernel_sizes[depth]
+ stride = config.conv_layer_strides[depth]
+
+ num_layers = len(kernel_size)
+ stage_in_channel_size = config.hidden_sizes[depth]
+ stage_out_channel_size = config.hidden_sizes[depth + 1]
+
+ in_channels = [stage_in_channel_size] + [stage_out_channel_size] * (num_layers - 1)
+ out_channels = [stage_out_channel_size] * num_layers
+
+ stage = []
+ for stage_config in zip(in_channels, out_channels, kernel_size, stride):
+ stage.append(TextNetRepConvLayer(config, *stage_config))
+ self.stage = nn.ModuleList(stage)
+
+ def forward(self, hidden_state):
+ for block in self.stage:
+ hidden_state = block(hidden_state)
+ return hidden_state
+
+
+class TextNetEncoder(nn.Module):
+ def __init__(self, config: TextNetConfig):
+ super().__init__()
+
+ stages = []
+ num_stages = len(config.conv_layer_kernel_sizes)
+ for stage_ix in range(num_stages):
+ stages.append(TextNetStage(config, stage_ix))
+
+ self.stages = nn.ModuleList(stages)
+
+ def forward(
+ self,
+ hidden_state: torch.Tensor,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ ) -> BaseModelOutputWithNoAttention:
+ hidden_states = [hidden_state]
+ for stage in self.stages:
+ hidden_state = stage(hidden_state)
+ hidden_states.append(hidden_state)
+
+ if not return_dict:
+ output = (hidden_state,)
+ return output + (hidden_states,) if output_hidden_states else output
+
+ return BaseModelOutputWithNoAttention(last_hidden_state=hidden_state, hidden_states=hidden_states)
+
+
+@auto_docstring
+class TextNetPreTrainedModel(PreTrainedModel):
+ config: TextNetConfig
+ base_model_prefix = "textnet"
+ main_input_name = "pixel_values"
+
+
+@auto_docstring
+class TextNetModel(TextNetPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.stem = TextNetConvLayer(config)
+ self.encoder = TextNetEncoder(config)
+ self.pooler = nn.AdaptiveAvgPool2d((2, 2))
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: Tensor,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[Any, list[Any]] | tuple[Any] | BaseModelOutputWithPoolingAndNoAttention:
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+
+ hidden_state = self.stem(pixel_values)
+
+ encoder_outputs = self.encoder(
+ hidden_state, output_hidden_states=output_hidden_states, return_dict=return_dict
+ )
+
+ last_hidden_state = encoder_outputs[0]
+ pooled_output = self.pooler(last_hidden_state)
+
+ if not return_dict:
+ output = (last_hidden_state, pooled_output)
+ return output + (encoder_outputs[1],) if output_hidden_states else output
+
+ return BaseModelOutputWithPoolingAndNoAttention(
+ last_hidden_state=last_hidden_state,
+ pooler_output=pooled_output,
+ hidden_states=encoder_outputs[1] if output_hidden_states else None,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ TextNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
+ ImageNet.
+ """
+)
+class TextNetForImageClassification(TextNetPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+ self.textnet = TextNetModel(config)
+ self.avg_pool = nn.AdaptiveAvgPool2d((1, 1))
+ self.flatten = nn.Flatten()
+ self.fc = nn.Linear(config.hidden_sizes[-1], config.num_labels) if config.num_labels > 0 else nn.Identity()
+
+ # classification head
+ self.classifier = nn.ModuleList([self.avg_pool, self.flatten])
+
+ # initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> ImageClassifierOutputWithNoAttention:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+
+ Examples:
+ ```python
+ >>> import torch
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> from transformers import TextNetForImageClassification, TextNetImageProcessor
+ >>> from PIL import Image
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> processor = TextNetImageProcessor.from_pretrained("czczup/textnet-base")
+ >>> model = TextNetForImageClassification.from_pretrained("czczup/textnet-base")
+
+ >>> inputs = processor(images=image, return_tensors="pt")
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+ >>> outputs.logits.shape
+ torch.Size([1, 2])
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.textnet(pixel_values, output_hidden_states=output_hidden_states, return_dict=return_dict)
+ last_hidden_state = outputs[0]
+ for layer in self.classifier:
+ last_hidden_state = layer(last_hidden_state)
+ logits = self.fc(last_hidden_state)
+ loss = None
+
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config)
+
+ if not return_dict:
+ output = (logits,) + outputs[2:]
+ return (loss,) + output if loss is not None else output
+
+ return ImageClassifierOutputWithNoAttention(loss=loss, logits=logits, hidden_states=outputs.hidden_states)
+
+
+@auto_docstring(
+ custom_intro="""
+ TextNet backbone, to be used with frameworks like DETR and MaskFormer.
+ """
+)
+class TextNetBackbone(BackboneMixin, TextNetPreTrainedModel):
+ has_attentions = False
+
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.textnet = TextNetModel(config)
+ self.num_features = config.hidden_sizes
+
+ # initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @filter_output_hidden_states
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: Tensor,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[tuple] | BackboneOutput:
+ r"""
+ Examples:
+
+ ```python
+ >>> import torch
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> from PIL import Image
+ >>> from transformers import AutoImageProcessor, AutoBackbone
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+
+ >>> processor = AutoImageProcessor.from_pretrained("czczup/textnet-base")
+ >>> model = AutoBackbone.from_pretrained("czczup/textnet-base")
+
+ >>> inputs = processor(image, return_tensors="pt")
+ >>> with torch.no_grad():
+ >>> outputs = model(**inputs)
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+
+ outputs = self.textnet(pixel_values, output_hidden_states=True, return_dict=return_dict)
+
+ hidden_states = outputs.hidden_states if return_dict else outputs[2]
+
+ feature_maps = ()
+ for idx, stage in enumerate(self.stage_names):
+ if stage in self.out_features:
+ feature_maps += (hidden_states[idx],)
+
+ if not return_dict:
+ output = (feature_maps,)
+ if output_hidden_states:
+ hidden_states = outputs.hidden_states if return_dict else outputs[2]
+ output += (hidden_states,)
+ return output
+
+ return BackboneOutput(
+ feature_maps=feature_maps,
+ hidden_states=outputs.hidden_states if output_hidden_states else None,
+ attentions=None,
+ )
+
+
+__all__ = ["TextNetBackbone", "TextNetModel", "TextNetPreTrainedModel", "TextNetForImageClassification"]
diff --git a/lib/python3.11/site-packages/transformers/models/time_series_transformer/__init__.py b/lib/python3.11/site-packages/transformers/models/time_series_transformer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e36c36bcfccb32d5299b30ab6c48283f93e35e7a
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/time_series_transformer/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_time_series_transformer import *
+ from .modeling_time_series_transformer import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/time_series_transformer/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/time_series_transformer/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8d6fc07fb5f154e03e5d7ed00e6a2e58b881356b
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/time_series_transformer/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/time_series_transformer/__pycache__/configuration_time_series_transformer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/time_series_transformer/__pycache__/configuration_time_series_transformer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c8f5935b768eb6650f08ef5a36468c2f736297b
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/time_series_transformer/__pycache__/configuration_time_series_transformer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/time_series_transformer/__pycache__/modeling_time_series_transformer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/time_series_transformer/__pycache__/modeling_time_series_transformer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..91fd97d7be70789ab98e408a3c5cfc6ba464c218
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/time_series_transformer/__pycache__/modeling_time_series_transformer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/time_series_transformer/configuration_time_series_transformer.py b/lib/python3.11/site-packages/transformers/models/time_series_transformer/configuration_time_series_transformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..be0fe7142e2a8b1802a51cc735cac74a83946855
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/time_series_transformer/configuration_time_series_transformer.py
@@ -0,0 +1,150 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""Time Series Transformer model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="huggingface/time-series-transformer-tourism-monthly")
+@strict
+class TimeSeriesTransformerConfig(PreTrainedConfig):
+ r"""
+ prediction_length (`int`):
+ The prediction length for the decoder. In other words, the prediction horizon of the model. This value is
+ typically dictated by the dataset and we recommend to set it appropriately.
+ context_length (`int`, *optional*, defaults to `prediction_length`):
+ The context length for the encoder. If `None`, the context length will be the same as the
+ `prediction_length`.
+ distribution_output (`string`, *optional*, defaults to `"student_t"`):
+ The distribution emission head for the model. Could be either "student_t", "normal" or "negative_binomial".
+ loss (`string`, *optional*, defaults to `"nll"`):
+ The loss function for the model corresponding to the `distribution_output` head. For parametric
+ distributions it is the negative log likelihood (nll) - which currently is the only supported one.
+ input_size (`int`, *optional*, defaults to 1):
+ The size of the target variable which by default is 1 for univariate targets. Would be > 1 in case of
+ multivariate targets.
+ lags_sequence (`list[int]`, *optional*, defaults to `[1, 2, 3, 4, 5, 6, 7]`):
+ The lags of the input time series as covariates often dictated by the frequency of the data. Default is
+ `[1, 2, 3, 4, 5, 6, 7]` but we recommend to change it based on the dataset appropriately.
+ scaling (`string` or `bool`, *optional* defaults to `"mean"`):
+ Whether to scale the input targets via "mean" scaler, "std" scaler or no scaler if `None`. If `True`, the
+ scaler is set to "mean".
+ num_dynamic_real_features (`int`, *optional*, defaults to 0):
+ The number of dynamic real valued features.
+ num_static_categorical_features (`int`, *optional*, defaults to 0):
+ The number of static categorical features.
+ num_static_real_features (`int`, *optional*, defaults to 0):
+ The number of static real valued features.
+ num_time_features (`int`, *optional*, defaults to 0):
+ The number of time features in the input time series.
+ cardinality (`list[int]`, *optional*):
+ The cardinality (number of different values) for each of the static categorical features. Should be a list
+ of integers, having the same length as `num_static_categorical_features`. Cannot be `None` if
+ `num_static_categorical_features` is > 0.
+ num_parallel_samples (`int`, *optional*, defaults to 100):
+ The number of samples to generate in parallel for each time step of inference.
+
+ Example:
+
+ ```python
+ >>> from transformers import TimeSeriesTransformerConfig, TimeSeriesTransformerModel
+
+ >>> # Initializing a Time Series Transformer configuration with 12 time steps for prediction
+ >>> configuration = TimeSeriesTransformerConfig(prediction_length=12)
+
+ >>> # Randomly initializing a model (with random weights) from the configuration
+ >>> model = TimeSeriesTransformerModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "time_series_transformer"
+ attribute_map = {
+ "hidden_size": "d_model",
+ "num_attention_heads": "encoder_attention_heads",
+ "num_hidden_layers": "encoder_layers",
+ }
+
+ prediction_length: int | None = None
+ context_length: int | None = None
+ distribution_output: str = "student_t"
+ loss: str = "nll"
+ input_size: int = 1
+ lags_sequence: list[int] | tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7)
+ scaling: str | bool | None = "mean"
+ num_dynamic_real_features: int = 0
+ num_static_categorical_features: int = 0
+ num_static_real_features: int = 0
+ num_time_features: int = 0
+ cardinality: list[int] | None = None
+ embedding_dimension: list[int] | None = None
+ encoder_ffn_dim: int = 32
+ decoder_ffn_dim: int = 32
+ encoder_attention_heads: int = 2
+ decoder_attention_heads: int = 2
+ encoder_layers: int = 2
+ decoder_layers: int = 2
+ is_encoder_decoder: bool = True
+ activation_function: str = "gelu"
+ d_model: int = 64
+ dropout: float | int = 0.1
+ encoder_layerdrop: float | int = 0.1
+ decoder_layerdrop: float | int = 0.1
+ attention_dropout: float | int = 0.1
+ activation_dropout: float | int = 0.1
+ num_parallel_samples: int = 100
+ init_std: float = 0.02
+ use_cache: bool = True
+
+ def __post_init__(self, **kwargs):
+ if not (self.cardinality and self.num_static_categorical_features > 0):
+ self.cardinality = [0]
+
+ if not (self.embedding_dimension and self.num_static_categorical_features > 0):
+ self.embedding_dimension = [min(50, (cat + 1) // 2) for cat in self.cardinality]
+
+ self.context_length = self.context_length or self.prediction_length
+ self.feature_size = self.input_size * len(self.lags_sequence) + self._number_of_features
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if self.cardinality and self.num_static_categorical_features > 0:
+ if len(self.cardinality) != self.num_static_categorical_features:
+ raise ValueError(
+ "The cardinality should be a list of the same length as `num_static_categorical_features`"
+ )
+
+ if self.embedding_dimension and self.num_static_categorical_features > 0:
+ if len(self.embedding_dimension) != self.num_static_categorical_features:
+ raise ValueError(
+ "The embedding dimension should be a list of the same length as `num_static_categorical_features`"
+ )
+
+ @property
+ def _number_of_features(self) -> int:
+ return (
+ sum(self.embedding_dimension)
+ + self.num_dynamic_real_features
+ + self.num_time_features
+ + self.num_static_real_features
+ + self.input_size * 2 # the log1p(abs(loc)) and log(scale) features
+ )
+
+
+__all__ = ["TimeSeriesTransformerConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py b/lib/python3.11/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad4a09f919cc44ee5e96fbe0d16d24dc5fb3cc0a
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py
@@ -0,0 +1,1529 @@
+# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
+# Copyright 2018 Amazon.com, Inc. or its affiliates. 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.
+"""PyTorch Time Series Transformer model."""
+
+from collections.abc import Callable
+
+import numpy as np
+import torch
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ BaseModelOutputWithPastAndCrossAttentions,
+ SampleTSPredictionOutput,
+ Seq2SeqTSModelOutput,
+ Seq2SeqTSPredictionOutput,
+)
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...time_series_utils import NegativeBinomialOutput, NormalOutput, StudentTOutput
+from ...utils import TransformersKwargs, auto_docstring, logging
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from .configuration_time_series_transformer import TimeSeriesTransformerConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+class TimeSeriesFeatureEmbedder(nn.Module):
+ """
+ Embed a sequence of categorical features.
+
+ Args:
+ cardinalities (`list[int]`):
+ List of cardinalities of the categorical features.
+ embedding_dims (`list[int]`):
+ List of embedding dimensions of the categorical features.
+ """
+
+ def __init__(self, cardinalities: list[int], embedding_dims: list[int]) -> None:
+ super().__init__()
+
+ self.num_features = len(cardinalities)
+ self.embedders = nn.ModuleList([nn.Embedding(c, d) for c, d in zip(cardinalities, embedding_dims)])
+
+ def forward(self, features: torch.Tensor) -> torch.Tensor:
+ if self.num_features > 1:
+ # we slice the last dimension, giving an array of length
+ # self.num_features with shape (N,T) or (N)
+ cat_feature_slices = torch.chunk(features, self.num_features, dim=-1)
+ else:
+ cat_feature_slices = [features]
+
+ return torch.cat(
+ [
+ embed(cat_feature_slice.squeeze(-1))
+ for embed, cat_feature_slice in zip(self.embedders, cat_feature_slices)
+ ],
+ dim=-1,
+ )
+
+
+class TimeSeriesStdScaler(nn.Module):
+ """
+ Standardize features by calculating the mean and scaling along the first dimension, and then normalizes it by
+ subtracting from the mean and dividing by the standard deviation.
+ """
+
+ def __init__(self, config: TimeSeriesTransformerConfig):
+ super().__init__()
+ self.dim = config.scaling_dim if hasattr(config, "scaling_dim") else 1
+ self.keepdim = config.keepdim if hasattr(config, "keepdim") else True
+ self.minimum_scale = config.minimum_scale if hasattr(config, "minimum_scale") else 1e-5
+
+ def forward(
+ self, data: torch.Tensor, observed_indicator: torch.Tensor
+ ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """
+ Parameters:
+ data (`torch.Tensor` of shape `(batch_size, sequence_length, num_input_channels)`):
+ input for Batch norm calculation
+ observed_indicator (`torch.BoolTensor` of shape `(batch_size, sequence_length, num_input_channels)`):
+ Calculating the scale on the observed indicator.
+ Returns:
+ tuple of `torch.Tensor` of shapes
+ (`(batch_size, sequence_length, num_input_channels)`,`(batch_size, 1, num_input_channels)`,
+ `(batch_size, 1, num_input_channels)`)
+ """
+ denominator = observed_indicator.sum(self.dim, keepdim=self.keepdim)
+ denominator = denominator.clamp_min(1.0)
+ loc = (data * observed_indicator).sum(self.dim, keepdim=self.keepdim) / denominator
+
+ variance = (((data - loc) * observed_indicator) ** 2).sum(self.dim, keepdim=self.keepdim) / denominator
+ scale = torch.sqrt(variance + self.minimum_scale)
+ return (data - loc) / scale, loc, scale
+
+
+class TimeSeriesMeanScaler(nn.Module):
+ """
+ Computes a scaling factor as the weighted average absolute value along the first dimension, and scales the data
+ accordingly.
+ """
+
+ def __init__(self, config: TimeSeriesTransformerConfig):
+ super().__init__()
+ self.dim = config.scaling_dim if hasattr(config, "scaling_dim") else 1
+ self.keepdim = config.keepdim if hasattr(config, "keepdim") else True
+ self.minimum_scale = config.minimum_scale if hasattr(config, "minimum_scale") else 1e-10
+ self.default_scale = config.default_scale if hasattr(config, "default_scale") else None
+
+ def forward(
+ self, data: torch.Tensor, observed_indicator: torch.Tensor
+ ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """
+ Parameters:
+ data (`torch.Tensor` of shape `(batch_size, sequence_length, num_input_channels)`):
+ input for Batch norm calculation
+ observed_indicator (`torch.BoolTensor` of shape `(batch_size, sequence_length, num_input_channels)`):
+ Calculating the scale on the observed indicator.
+ Returns:
+ tuple of `torch.Tensor` of shapes
+ (`(batch_size, sequence_length, num_input_channels)`,`(batch_size, 1, num_input_channels)`,
+ `(batch_size, 1, num_input_channels)`)
+ """
+ ts_sum = (data * observed_indicator).abs().sum(self.dim, keepdim=True)
+ num_observed = observed_indicator.sum(self.dim, keepdim=True)
+
+ scale = ts_sum / torch.clamp(num_observed, min=1)
+
+ # If `default_scale` is provided, we use it, otherwise we use the scale
+ # of the batch.
+ if self.default_scale is None:
+ batch_sum = ts_sum.sum(dim=0)
+ batch_observations = torch.clamp(num_observed.sum(0), min=1)
+ default_scale = torch.squeeze(batch_sum / batch_observations)
+ else:
+ default_scale = self.default_scale * torch.ones_like(scale)
+
+ # apply default scale where there are no observations
+ scale = torch.where(num_observed > 0, scale, default_scale)
+
+ # ensure the scale is at least `self.minimum_scale`
+ scale = torch.clamp(scale, min=self.minimum_scale)
+ scaled_data = data / scale
+
+ if not self.keepdim:
+ scale = scale.squeeze(dim=self.dim)
+
+ return scaled_data, torch.zeros_like(scale), scale
+
+
+class TimeSeriesNOPScaler(nn.Module):
+ """
+ Assigns a scaling factor equal to 1 along the first dimension, and therefore applies no scaling to the input data.
+ """
+
+ def __init__(self, config: TimeSeriesTransformerConfig):
+ super().__init__()
+ self.dim = config.scaling_dim if hasattr(config, "scaling_dim") else 1
+ self.keepdim = config.keepdim if hasattr(config, "keepdim") else True
+
+ def forward(
+ self, data: torch.Tensor, observed_indicator: torch.Tensor | None = None
+ ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """
+ Parameters:
+ data (`torch.Tensor` of shape `(batch_size, sequence_length, num_input_channels)`):
+ input for Batch norm calculation
+ Returns:
+ tuple of `torch.Tensor` of shapes
+ (`(batch_size, sequence_length, num_input_channels)`,`(batch_size, 1, num_input_channels)`,
+ `(batch_size, 1, num_input_channels)`)
+ """
+ scale = torch.ones_like(data, requires_grad=False).mean(dim=self.dim, keepdim=self.keepdim)
+ loc = torch.zeros_like(data, requires_grad=False).mean(dim=self.dim, keepdim=self.keepdim)
+ return data, loc, scale
+
+
+def nll(input: torch.distributions.Distribution, target: torch.Tensor) -> torch.Tensor:
+ """
+ Computes the negative log likelihood loss from input distribution with respect to target.
+ """
+ return -input.log_prob(target)
+
+
+def weighted_average(input_tensor: torch.Tensor, weights: torch.Tensor | None = None, dim=None) -> torch.Tensor:
+ """
+ Computes the weighted average of a given tensor across a given `dim`, masking values associated with weight zero,
+ meaning instead of `nan * 0 = nan` you will get `0 * 0 = 0`.
+
+ Args:
+ input_tensor (`torch.FloatTensor`):
+ Input tensor, of which the average must be computed.
+ weights (`torch.FloatTensor`, *optional*):
+ Weights tensor, of the same shape as `input_tensor`.
+ dim (`int`, *optional*):
+ The dim along which to average `input_tensor`.
+
+ Returns:
+ `torch.FloatTensor`: The tensor with values averaged along the specified `dim`.
+ """
+ if weights is not None:
+ weighted_tensor = torch.where(weights != 0, input_tensor * weights, torch.zeros_like(input_tensor))
+ sum_weights = torch.clamp(weights.sum(dim=dim) if dim else weights.sum(), min=1.0)
+ return (weighted_tensor.sum(dim=dim) if dim else weighted_tensor.sum()) / sum_weights
+ else:
+ return input_tensor.mean(dim=dim)
+
+
+# Copied from transformers.models.marian.modeling_marian.MarianSinusoidalPositionalEmbedding with Marian->TimeSeries
+class TimeSeriesSinusoidalPositionalEmbedding(nn.Embedding):
+ """This module produces sinusoidal positional embeddings of any length."""
+
+ def __init__(self, num_positions: int, embedding_dim: int, padding_idx: int | None = None) -> None:
+ super().__init__(num_positions, embedding_dim, _freeze=True)
+
+ def create_weight(self):
+ """
+ Identical to the XLM create_sinusoidal_embeddings except features are not interleaved. The cos features are in
+ the 2nd half of the vector. [dim // 2:]
+ """
+ n_pos, dim = self.weight.shape
+ position_enc = np.array(
+ [[pos / np.power(10000, 2 * (j // 2) / dim) for j in range(dim)] for pos in range(n_pos)]
+ )
+ out = torch.empty(n_pos, dim, dtype=self.weight.dtype, requires_grad=False)
+ sentinel = dim // 2 if dim % 2 == 0 else (dim // 2) + 1
+ out[:, 0:sentinel] = torch.FloatTensor(np.sin(position_enc[:, 0::2]))
+ out[:, sentinel:] = torch.FloatTensor(np.cos(position_enc[:, 1::2]))
+ return out
+
+ @torch.no_grad()
+ def forward(
+ self, input_ids_shape: torch.Size, past_key_values_length: int = 0, position_ids: torch.Tensor | None = None
+ ) -> torch.Tensor:
+ """`input_ids_shape` is expected to be [bsz x seqlen]."""
+ if position_ids is None:
+ bsz, seq_len = input_ids_shape[:2]
+ position_ids = torch.arange(
+ past_key_values_length, past_key_values_length + seq_len, dtype=torch.long, device=self.weight.device
+ )
+ return super().forward(position_ids)
+
+
+class TimeSeriesValueEmbedding(nn.Module):
+ def __init__(self, feature_size, d_model):
+ super().__init__()
+ self.value_projection = nn.Linear(in_features=feature_size, out_features=d_model, bias=False)
+
+ def forward(self, x):
+ return self.value_projection(x)
+
+
+# Copied from transformers.models.bert.modeling_bert.eager_attention_forward
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float | None = None,
+ dropout: float = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ if scaling is None:
+ scaling = query.size(-1) ** -0.5
+
+ # Take the dot product between "query" and "key" to get the raw attention scores.
+ attn_weights = torch.matmul(query, key.transpose(2, 3)) * scaling
+
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+# Copied from transformers.models.bart.modeling_bart.BartAttention with Bart->TimeSeriesTransformer
+class TimeSeriesTransformerAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(
+ self,
+ embed_dim: int,
+ num_heads: int,
+ dropout: float = 0.0,
+ is_decoder: bool = False,
+ bias: bool = True,
+ is_causal: bool = False,
+ config: TimeSeriesTransformerConfig | None = None,
+ layer_idx: int | None = None,
+ ):
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.num_heads = num_heads
+ self.dropout = dropout
+ self.head_dim = embed_dim // num_heads
+ self.config = config
+
+ if (self.head_dim * num_heads) != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}"
+ f" and `num_heads`: {num_heads})."
+ )
+ self.scaling = self.head_dim**-0.5
+ self.is_decoder = is_decoder
+ self.is_causal = is_causal
+ self.layer_idx = layer_idx
+ if layer_idx is None and self.is_decoder:
+ logger.warning_once(
+ f"Instantiating a decoder {self.__class__.__name__} without passing `layer_idx` is not recommended and "
+ "will lead to errors during the forward call, if caching is used. Please make sure to provide a `layer_idx` "
+ "when creating this class."
+ )
+
+ self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ key_value_states: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ attention_mask: torch.Tensor | None = None,
+ # TODO: we need a refactor so that the different attention modules can get their specific kwargs
+ # ATM, we have mixed things encoder, decoder, and encoder-decoder attn
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ """Input shape: Batch x Time x Channel"""
+
+ # if key_value_states are provided this layer is used as a cross-attention layer
+ # for the decoder
+ is_cross_attention = key_value_states is not None
+
+ # determine input shapes
+ input_shape = hidden_states.shape[:-1]
+
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ # get query proj
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ is_updated = False
+ if past_key_values is not None:
+ if isinstance(past_key_values, EncoderDecoderCache):
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ if is_cross_attention:
+ # after the first generated id, we can subsequently re-use all key/value_states from cache
+ curr_past_key_values = past_key_values.cross_attention_cache
+ else:
+ curr_past_key_values = past_key_values.self_attention_cache
+ else:
+ curr_past_key_values = past_key_values
+
+ current_states = key_value_states if is_cross_attention else hidden_states
+ if is_cross_attention and past_key_values is not None and is_updated:
+ # reuse k,v, cross_attentions
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+ else:
+ key_states = self.k_proj(current_states)
+ value_states = self.v_proj(current_states)
+ kv_shape = (*current_states.shape[:-1], -1, self.head_dim)
+ key_states = key_states.view(kv_shape).transpose(1, 2)
+ value_states = value_states.view(kv_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+ if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+ past_key_values.is_updated[self.layer_idx] = True
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=0.0 if not self.training else self.dropout,
+ scaling=self.scaling,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+# Copied from transformers.models.bart.modeling_bart.BartEncoderLayer with Bart->TimeSeriesTransformer, BART->TIME_SERIES_TRANSFORMER
+class TimeSeriesTransformerEncoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: TimeSeriesTransformerConfig, layer_idx: int | None = None):
+ super().__init__()
+ self.embed_dim = config.d_model
+
+ self.self_attn = TimeSeriesTransformerAttention(
+ embed_dim=self.embed_dim,
+ num_heads=config.encoder_attention_heads,
+ dropout=config.attention_dropout,
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.dropout = config.dropout
+ self.activation_fn = ACT2FN[config.activation_function]
+ self.activation_dropout = config.activation_dropout
+ self.fc1 = nn.Linear(self.embed_dim, config.encoder_ffn_dim)
+ self.fc2 = nn.Linear(config.encoder_ffn_dim, self.embed_dim)
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.FloatTensor,
+ attention_mask: torch.FloatTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ residual = hidden_states
+ hidden_states, _ = self.self_attn(
+ hidden_states,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+
+ residual = hidden_states
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ if hidden_states.dtype == torch.float16 and not torch.isfinite(hidden_states).all():
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ return hidden_states
+
+
+# Copied from transformers.models.bart.modeling_bart.BartDecoderLayer with Bart->TimeSeriesTransformer, with BART->TIME_SERIES_TRANSFORMER
+class TimeSeriesTransformerDecoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: TimeSeriesTransformerConfig, layer_idx: int | None = None):
+ super().__init__()
+ self.embed_dim = config.d_model
+
+ self.self_attn = TimeSeriesTransformerAttention(
+ embed_dim=self.embed_dim,
+ num_heads=config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=True,
+ is_causal=True,
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.dropout = config.dropout
+ self.activation_fn = ACT2FN[config.activation_function]
+ self.activation_dropout = config.activation_dropout
+
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.encoder_attn = TimeSeriesTransformerAttention(
+ self.embed_dim,
+ config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=True,
+ config=config,
+ layer_idx=layer_idx,
+ )
+ self.encoder_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+ self.fc1 = nn.Linear(self.embed_dim, config.decoder_ffn_dim)
+ self.fc2 = nn.Linear(config.decoder_ffn_dim, self.embed_dim)
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = True,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ residual = hidden_states
+
+ # Self Attention
+ hidden_states, _ = self.self_attn(
+ hidden_states,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ **kwargs,
+ )
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+
+ # Cross-Attention Block
+ if encoder_hidden_states is not None:
+ residual = hidden_states
+
+ hidden_states, _ = self.encoder_attn(
+ hidden_states,
+ key_value_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ **kwargs,
+ )
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.encoder_attn_layer_norm(hidden_states)
+
+ # Fully Connected
+ residual = hidden_states
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+ hidden_states = self.fc2(hidden_states)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ return hidden_states
+
+
+@auto_docstring
+class TimeSeriesTransformerPreTrainedModel(PreTrainedModel):
+ config: TimeSeriesTransformerConfig
+ base_model_prefix = "model"
+ main_input_name = "past_values"
+ input_modalities = ("time",)
+ supports_gradient_checkpointing = True
+ # TODO: tests would need a rewrite to check for correct implementation
+ # Current tests always assume certain inputs to be passed
+ _supports_flash_attn = False
+ _supports_sdpa = False
+ _supports_flex_attn = False
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, TimeSeriesSinusoidalPositionalEmbedding):
+ init.copy_(module.weight, module.create_weight())
+
+
+class TimeSeriesTransformerEncoder(TimeSeriesTransformerPreTrainedModel):
+ """
+ Transformer encoder consisting of *config.encoder_layers* self attention layers. Each layer is a
+ [`TimeSeriesTransformerEncoderLayer`].
+
+ Args:
+ config: TimeSeriesTransformerConfig
+ """
+
+ _can_record_outputs = {
+ "hidden_states": TimeSeriesTransformerEncoderLayer,
+ "attentions": TimeSeriesTransformerAttention,
+ }
+
+ def __init__(self, config: TimeSeriesTransformerConfig):
+ super().__init__(config)
+
+ self.dropout = config.dropout
+ self.layerdrop = config.encoder_layerdrop
+ if config.prediction_length is None:
+ raise ValueError("The `prediction_length` config needs to be specified.")
+
+ self.value_embedding = TimeSeriesValueEmbedding(feature_size=config.feature_size, d_model=config.d_model)
+ self.embed_positions = TimeSeriesSinusoidalPositionalEmbedding(
+ config.context_length + config.prediction_length, config.d_model
+ )
+ self.layers = nn.ModuleList([TimeSeriesTransformerEncoderLayer(config) for _ in range(config.encoder_layers)])
+ self.layernorm_embedding = nn.LayerNorm(config.d_model)
+
+ self.gradient_checkpointing = False
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ attention_mask: torch.Tensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ hidden_states = self.value_embedding(inputs_embeds)
+ embed_pos = self.embed_positions(inputs_embeds.size())
+
+ hidden_states = self.layernorm_embedding(hidden_states + embed_pos)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ )
+
+ for idx, encoder_layer in enumerate(self.layers):
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ to_drop = False
+ if self.training:
+ dropout_probability = torch.rand([])
+ if dropout_probability < self.layerdrop: # skip the layer
+ to_drop = True
+
+ if not to_drop:
+ hidden_states = encoder_layer(
+ hidden_states,
+ attention_mask,
+ **kwargs,
+ )
+
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ )
+
+
+class TimeSeriesTransformerDecoder(TimeSeriesTransformerPreTrainedModel):
+ """
+ Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a
+ [`TimeSeriesTransformerDecoderLayer`]
+
+ Args:
+ config: TimeSeriesTransformerConfig
+ """
+
+ _can_record_outputs = {
+ "hidden_states": TimeSeriesTransformerDecoderLayer,
+ "attentions": OutputRecorder(TimeSeriesTransformerAttention, index=1, layer_name="self_attn"),
+ "cross_attentions": OutputRecorder(TimeSeriesTransformerAttention, index=1, layer_name="encoder_attn"),
+ }
+
+ def __init__(self, config: TimeSeriesTransformerConfig):
+ super().__init__(config)
+ self.dropout = config.dropout
+ self.layerdrop = config.decoder_layerdrop
+ if config.prediction_length is None:
+ raise ValueError("The `prediction_length` config needs to be specified.")
+
+ self.value_embedding = TimeSeriesValueEmbedding(feature_size=config.feature_size, d_model=config.d_model)
+ self.embed_positions = TimeSeriesSinusoidalPositionalEmbedding(
+ config.context_length + config.prediction_length, config.d_model
+ )
+ self.layers = nn.ModuleList(
+ [TimeSeriesTransformerDecoderLayer(config, layer_idx=i) for i in range(config.decoder_layers)]
+ )
+ self.layernorm_embedding = nn.LayerNorm(config.d_model)
+
+ self.gradient_checkpointing = False
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ def forward(
+ self,
+ attention_mask: torch.Tensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPastAndCrossAttentions:
+ r"""
+ Args:
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*):
+ Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
+ of the decoder.
+ encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, encoder_sequence_length)`, *optional*):
+ Mask to avoid performing cross-attention on padding tokens indices of encoder input_ids. Mask values
+ selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and in the
+ cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
+
+ If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those
+ that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of
+ all `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation.
+ This is useful if you want more control over how to convert `input_ids` indices into associated vectors
+ than the model's internal embedding lookup matrix.
+ """
+
+ # initialize `past_key_values`
+ if use_cache and past_key_values is None:
+ past_key_values = EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache(config=self.config))
+
+ self_attn_cache = (
+ past_key_values.self_attention_cache
+ if isinstance(past_key_values, EncoderDecoderCache)
+ else past_key_values
+ )
+
+ attention_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=self_attn_cache,
+ )
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+
+ hidden_states = self.value_embedding(inputs_embeds)
+ embed_pos = self.embed_positions(inputs_embeds.size(), past_key_values_length=self.config.context_length)
+ hidden_states = self.layernorm_embedding(hidden_states + embed_pos)
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+ for idx, decoder_layer in enumerate(self.layers):
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ if self.training:
+ dropout_probability = torch.rand([])
+ if dropout_probability < self.layerdrop:
+ continue
+
+ hidden_states = decoder_layer(
+ hidden_states,
+ attention_mask,
+ encoder_hidden_states, # as a positional argument for gradient checkpointing
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class TimeSeriesTransformerModel(TimeSeriesTransformerPreTrainedModel):
+ def __init__(self, config: TimeSeriesTransformerConfig):
+ super().__init__(config)
+
+ if config.scaling == "mean" or config.scaling is True:
+ self.scaler = TimeSeriesMeanScaler(config)
+ elif config.scaling == "std":
+ self.scaler = TimeSeriesStdScaler(config)
+ else:
+ self.scaler = TimeSeriesNOPScaler(config)
+
+ if config.num_static_categorical_features > 0:
+ self.embedder = TimeSeriesFeatureEmbedder(
+ cardinalities=config.cardinality,
+ embedding_dims=config.embedding_dimension,
+ )
+
+ # transformer encoder-decoder and mask initializer
+ self.encoder = TimeSeriesTransformerEncoder(config)
+ self.decoder = TimeSeriesTransformerDecoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @property
+ def _past_length(self) -> int:
+ return self.config.context_length + max(self.config.lags_sequence)
+
+ def get_lagged_subsequences(
+ self, sequence: torch.Tensor, subsequences_length: int, shift: int = 0
+ ) -> torch.Tensor:
+ """
+ Returns lagged subsequences of a given sequence. Returns a tensor of shape (N, S, C, I),
+ where S = subsequences_length and I = len(indices), containing lagged subsequences. Specifically, lagged[i,
+ j, :, k] = sequence[i, -indices[k]-S+j, :].
+
+ Args:
+ sequence: Tensor
+ The sequence from which lagged subsequences should be extracted. Shape: (N, T, C).
+ subsequences_length : int
+ Length of the subsequences to be extracted.
+ shift: int
+ Shift the lags by this amount back.
+ """
+ sequence_length = sequence.shape[1]
+ indices = [lag - shift for lag in self.config.lags_sequence]
+
+ if max(indices) + subsequences_length > sequence_length:
+ raise ValueError(
+ f"lags cannot go further than history length, found lag {max(indices)} "
+ f"while history length is only {sequence_length}"
+ )
+
+ lagged_values = []
+ for lag_index in indices:
+ begin_index = -lag_index - subsequences_length
+ end_index = -lag_index if lag_index > 0 else None
+ lagged_values.append(sequence[:, begin_index:end_index, ...])
+ return torch.stack(lagged_values, dim=-1)
+
+ def create_network_inputs(
+ self,
+ past_values: torch.Tensor,
+ past_time_features: torch.Tensor,
+ static_categorical_features: torch.Tensor | None = None,
+ static_real_features: torch.Tensor | None = None,
+ past_observed_mask: torch.Tensor | None = None,
+ future_values: torch.Tensor | None = None,
+ future_time_features: torch.Tensor | None = None,
+ ):
+ # time feature
+ time_feat = (
+ torch.cat(
+ (
+ past_time_features[:, self._past_length - self.config.context_length :, ...],
+ future_time_features,
+ ),
+ dim=1,
+ )
+ if future_values is not None
+ else past_time_features[:, self._past_length - self.config.context_length :, ...]
+ )
+
+ # target
+ if past_observed_mask is None:
+ past_observed_mask = torch.ones_like(past_values)
+
+ context = past_values[:, -self.config.context_length :]
+ observed_context = past_observed_mask[:, -self.config.context_length :]
+ _, loc, scale = self.scaler(context, observed_context)
+
+ inputs = (
+ (torch.cat((past_values, future_values), dim=1) - loc) / scale
+ if future_values is not None
+ else (past_values - loc) / scale
+ )
+
+ # static features
+ if loc.ndim == 3:
+ squeezed_loc = loc.squeeze(1)
+ squeezed_scale = scale.squeeze(1)
+ else:
+ squeezed_loc = loc
+ squeezed_scale = scale
+ log_abs_loc = squeezed_loc.abs().log1p()
+ log_scale = squeezed_scale.log()
+ static_feat = torch.cat((log_abs_loc, log_scale), dim=1)
+
+ if static_real_features is not None:
+ static_feat = torch.cat((static_real_features, static_feat), dim=1)
+ if static_categorical_features is not None:
+ embedded_cat = self.embedder(static_categorical_features)
+ static_feat = torch.cat((embedded_cat, static_feat), dim=1)
+ expanded_static_feat = static_feat.unsqueeze(1).expand(-1, time_feat.shape[1], -1)
+
+ # all features
+ features = torch.cat((expanded_static_feat, time_feat), dim=-1)
+
+ # lagged features
+ subsequences_length = (
+ self.config.context_length + self.config.prediction_length
+ if future_values is not None
+ else self.config.context_length
+ )
+ lagged_sequence = self.get_lagged_subsequences(sequence=inputs, subsequences_length=subsequences_length)
+ lags_shape = lagged_sequence.shape
+ reshaped_lagged_sequence = lagged_sequence.reshape(lags_shape[0], lags_shape[1], -1)
+
+ if reshaped_lagged_sequence.shape[1] != time_feat.shape[1]:
+ raise ValueError(
+ f"input length {reshaped_lagged_sequence.shape[1]} and time feature lengths {time_feat.shape[1]} does not match"
+ )
+
+ # transformer inputs
+ transformer_inputs = torch.cat((reshaped_lagged_sequence, features), dim=-1)
+
+ return transformer_inputs, loc, scale, static_feat
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ past_values: torch.Tensor,
+ past_time_features: torch.Tensor,
+ past_observed_mask: torch.Tensor,
+ static_categorical_features: torch.Tensor | None = None,
+ static_real_features: torch.Tensor | None = None,
+ future_values: torch.Tensor | None = None,
+ future_time_features: torch.Tensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: list[torch.FloatTensor] | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> Seq2SeqTSModelOutput | tuple:
+ r"""
+ past_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)` or `(batch_size, sequence_length, input_size)`):
+ Past values of the time series, that serve as context in order to predict the future. The sequence size of
+ this tensor must be larger than the `context_length` of the model, since the model will use the larger size
+ to construct lag features, i.e. additional values from the past which are added in order to serve as "extra
+ context".
+
+ The `sequence_length` here is equal to `config.context_length` + `max(config.lags_sequence)`, which if no
+ `lags_sequence` is configured, is equal to `config.context_length` + 7 (as by default, the largest
+ look-back index in `config.lags_sequence` is 7). The property `_past_length` returns the actual length of
+ the past.
+
+ The `past_values` is what the Transformer encoder gets as input (with optional additional features, such as
+ `static_categorical_features`, `static_real_features`, `past_time_features` and lags).
+
+ Optionally, missing values need to be replaced with zeros and indicated via the `past_observed_mask`.
+
+ For multivariate time series, the `input_size` > 1 dimension is required and corresponds to the number of
+ variates in the time series per time step.
+ past_time_features (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_features)`):
+ Required time features, which the model internally will add to `past_values`. These could be things like
+ "month of year", "day of the month", etc. encoded as vectors (for instance as Fourier features). These
+ could also be so-called "age" features, which basically help the model know "at which point in life" a
+ time-series is. Age features have small values for distant past time steps and increase monotonically the
+ more we approach the current time step. Holiday features are also a good example of time features.
+
+ These features serve as the "positional encodings" of the inputs. So contrary to a model like BERT, where
+ the position encodings are learned from scratch internally as parameters of the model, the Time Series
+ Transformer requires to provide additional time features. The Time Series Transformer only learns
+ additional embeddings for `static_categorical_features`.
+
+ Additional dynamic real covariates can be concatenated to this tensor, with the caveat that these features
+ must but known at prediction time.
+
+ The `num_features` here is equal to `config.`num_time_features` + `config.num_dynamic_real_features`.
+ past_observed_mask (`torch.BoolTensor` of shape `(batch_size, sequence_length)` or `(batch_size, sequence_length, input_size)`, *optional*):
+ Boolean mask to indicate which `past_values` were observed and which were missing. Mask values selected in
+ `[0, 1]`:
+
+ - 1 for values that are **observed**,
+ - 0 for values that are **missing** (i.e. NaNs that were replaced by zeros).
+ static_categorical_features (`torch.LongTensor` of shape `(batch_size, number of static categorical features)`, *optional*):
+ Optional static categorical features for which the model will learn an embedding, which it will add to the
+ values of the time series.
+
+ Static categorical features are features which have the same value for all time steps (static over time).
+
+ A typical example of a static categorical feature is a time series ID.
+ static_real_features (`torch.FloatTensor` of shape `(batch_size, number of static real features)`, *optional*):
+ Optional static real features which the model will add to the values of the time series.
+
+ Static real features are features which have the same value for all time steps (static over time).
+
+ A typical example of a static real feature is promotion information.
+ future_values (`torch.FloatTensor` of shape `(batch_size, prediction_length)` or `(batch_size, prediction_length, input_size)`, *optional*):
+ Future values of the time series, that serve as labels for the model. The `future_values` is what the
+ Transformer needs during training to learn to output, given the `past_values`.
+
+ The sequence length here is equal to `prediction_length`.
+
+ See the demo notebook and code snippets for details.
+
+ Optionally, during training any missing values need to be replaced with zeros and indicated via the
+ `future_observed_mask`.
+
+ For multivariate time series, the `input_size` > 1 dimension is required and corresponds to the number of
+ variates in the time series per time step.
+ future_time_features (`torch.FloatTensor` of shape `(batch_size, prediction_length, num_features)`):
+ Required time features for the prediction window, which the model internally will add to `future_values`.
+ These could be things like "month of year", "day of the month", etc. encoded as vectors (for instance as
+ Fourier features). These could also be so-called "age" features, which basically help the model know "at
+ which point in life" a time-series is. Age features have small values for distant past time steps and
+ increase monotonically the more we approach the current time step. Holiday features are also a good example
+ of time features.
+
+ These features serve as the "positional encodings" of the inputs. So contrary to a model like BERT, where
+ the position encodings are learned from scratch internally as parameters of the model, the Time Series
+ Transformer requires to provide additional time features. The Time Series Transformer only learns
+ additional embeddings for `static_categorical_features`.
+
+ Additional dynamic real covariates can be concatenated to this tensor, with the caveat that these features
+ must but known at prediction time.
+
+ The `num_features` here is equal to `config.`num_time_features` + `config.num_dynamic_real_features`.
+ encoder_outputs (`tuple(tuple(torch.FloatTensor)`, *optional*):
+ Tuple consists of `last_hidden_state`, `hidden_states` (*optional*) and `attentions` (*optional*)
+ `last_hidden_state` of shape `(batch_size, sequence_length, hidden_size)` (*optional*) is a sequence of
+ hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.
+
+ Examples:
+
+ ```python
+ >>> from huggingface_hub import hf_hub_download
+ >>> import torch
+ >>> from transformers import TimeSeriesTransformerModel
+
+ >>> file = hf_hub_download(
+ ... repo_id="hf-internal-testing/tourism-monthly-batch", filename="train-batch.pt", repo_type="dataset"
+ ... )
+ >>> batch = torch.load(file)
+
+ >>> model = TimeSeriesTransformerModel.from_pretrained("huggingface/time-series-transformer-tourism-monthly")
+
+ >>> # during training, one provides both past and future values
+ >>> # as well as possible additional features
+ >>> outputs = model(
+ ... past_values=batch["past_values"],
+ ... past_time_features=batch["past_time_features"],
+ ... past_observed_mask=batch["past_observed_mask"],
+ ... static_categorical_features=batch["static_categorical_features"],
+ ... static_real_features=batch["static_real_features"],
+ ... future_values=batch["future_values"],
+ ... future_time_features=batch["future_time_features"],
+ ... )
+
+ >>> last_hidden_state = outputs.last_hidden_state
+ ```"""
+ transformer_inputs, loc, scale, static_feat = self.create_network_inputs(
+ past_values=past_values,
+ past_time_features=past_time_features,
+ past_observed_mask=past_observed_mask,
+ static_categorical_features=static_categorical_features,
+ static_real_features=static_real_features,
+ future_values=future_values,
+ future_time_features=future_time_features,
+ )
+
+ if encoder_outputs is None:
+ enc_input = transformer_inputs[:, : self.config.context_length, ...]
+ encoder_outputs = self.encoder(
+ inputs_embeds=enc_input,
+ **kwargs,
+ )
+ # If the user passed a tuple for encoder_outputs, we wrap it in a BaseModelOutput when return_dict=True
+ elif not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ # Avoid empty tensors and instead create a zeroes tensor which
+ # will be treated the same in torch, i.e. matmul with empty == all 0s
+ if self.config.context_length >= transformer_inputs.shape[1]:
+ bsz, _, dim = transformer_inputs.shape
+ dec_input = torch.zeros(
+ size=(bsz, 1, dim), device=transformer_inputs.device, dtype=transformer_inputs.dtype
+ )
+ else:
+ dec_input = transformer_inputs[:, self.config.context_length :, ...]
+
+ decoder_outputs = self.decoder(
+ inputs_embeds=dec_input,
+ attention_mask=decoder_attention_mask,
+ encoder_hidden_states=encoder_outputs[0],
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return Seq2SeqTSModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ loc=loc,
+ scale=scale,
+ static_features=static_feat,
+ )
+
+
+@auto_docstring
+class TimeSeriesTransformerForPrediction(TimeSeriesTransformerPreTrainedModel):
+ def __init__(self, config: TimeSeriesTransformerConfig):
+ super().__init__(config)
+ self.model = TimeSeriesTransformerModel(config)
+ if config.distribution_output == "student_t":
+ self.distribution_output = StudentTOutput(dim=config.input_size)
+ elif config.distribution_output == "normal":
+ self.distribution_output = NormalOutput(dim=config.input_size)
+ elif config.distribution_output == "negative_binomial":
+ self.distribution_output = NegativeBinomialOutput(dim=config.input_size)
+ else:
+ raise ValueError(f"Unknown distribution output {config.distribution_output}")
+
+ self.parameter_projection = self.distribution_output.get_parameter_projection(self.model.config.d_model)
+ self.target_shape = self.distribution_output.event_shape
+
+ if config.loss == "nll":
+ self.loss = nll
+ else:
+ raise ValueError(f"Unknown loss function {config.loss}")
+
+ # Initialize weights of distribution_output and apply final processing
+ self.post_init()
+
+ def output_params(self, dec_output):
+ return self.parameter_projection(dec_output)
+
+ @torch.jit.ignore
+ def output_distribution(self, params, loc=None, scale=None, trailing_n=None) -> torch.distributions.Distribution:
+ sliced_params = params
+ if trailing_n is not None:
+ sliced_params = [p[:, -trailing_n:] for p in params]
+ return self.distribution_output.distribution(sliced_params, loc=loc, scale=scale)
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ past_values: torch.Tensor,
+ past_time_features: torch.Tensor,
+ past_observed_mask: torch.Tensor,
+ static_categorical_features: torch.Tensor | None = None,
+ static_real_features: torch.Tensor | None = None,
+ future_values: torch.Tensor | None = None,
+ future_time_features: torch.Tensor | None = None,
+ future_observed_mask: torch.Tensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: list[torch.FloatTensor] | None = None,
+ past_key_values: Cache | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> Seq2SeqTSModelOutput | tuple:
+ r"""
+ past_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)` or `(batch_size, sequence_length, input_size)`):
+ Past values of the time series, that serve as context in order to predict the future. The sequence size of
+ this tensor must be larger than the `context_length` of the model, since the model will use the larger size
+ to construct lag features, i.e. additional values from the past which are added in order to serve as "extra
+ context".
+
+ The `sequence_length` here is equal to `config.context_length` + `max(config.lags_sequence)`, which if no
+ `lags_sequence` is configured, is equal to `config.context_length` + 7 (as by default, the largest
+ look-back index in `config.lags_sequence` is 7). The property `_past_length` returns the actual length of
+ the past.
+
+ The `past_values` is what the Transformer encoder gets as input (with optional additional features, such as
+ `static_categorical_features`, `static_real_features`, `past_time_features` and lags).
+
+ Optionally, missing values need to be replaced with zeros and indicated via the `past_observed_mask`.
+
+ For multivariate time series, the `input_size` > 1 dimension is required and corresponds to the number of
+ variates in the time series per time step.
+ past_time_features (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_features)`):
+ Required time features, which the model internally will add to `past_values`. These could be things like
+ "month of year", "day of the month", etc. encoded as vectors (for instance as Fourier features). These
+ could also be so-called "age" features, which basically help the model know "at which point in life" a
+ time-series is. Age features have small values for distant past time steps and increase monotonically the
+ more we approach the current time step. Holiday features are also a good example of time features.
+
+ These features serve as the "positional encodings" of the inputs. So contrary to a model like BERT, where
+ the position encodings are learned from scratch internally as parameters of the model, the Time Series
+ Transformer requires to provide additional time features. The Time Series Transformer only learns
+ additional embeddings for `static_categorical_features`.
+
+ Additional dynamic real covariates can be concatenated to this tensor, with the caveat that these features
+ must but known at prediction time.
+
+ The `num_features` here is equal to `config.`num_time_features` + `config.num_dynamic_real_features`.
+ past_observed_mask (`torch.BoolTensor` of shape `(batch_size, sequence_length)` or `(batch_size, sequence_length, input_size)`, *optional*):
+ Boolean mask to indicate which `past_values` were observed and which were missing. Mask values selected in
+ `[0, 1]`:
+
+ - 1 for values that are **observed**,
+ - 0 for values that are **missing** (i.e. NaNs that were replaced by zeros).
+ static_categorical_features (`torch.LongTensor` of shape `(batch_size, number of static categorical features)`, *optional*):
+ Optional static categorical features for which the model will learn an embedding, which it will add to the
+ values of the time series.
+
+ Static categorical features are features which have the same value for all time steps (static over time).
+
+ A typical example of a static categorical feature is a time series ID.
+ static_real_features (`torch.FloatTensor` of shape `(batch_size, number of static real features)`, *optional*):
+ Optional static real features which the model will add to the values of the time series.
+
+ Static real features are features which have the same value for all time steps (static over time).
+
+ A typical example of a static real feature is promotion information.
+ future_values (`torch.FloatTensor` of shape `(batch_size, prediction_length)` or `(batch_size, prediction_length, input_size)`, *optional*):
+ Future values of the time series, that serve as labels for the model. The `future_values` is what the
+ Transformer needs during training to learn to output, given the `past_values`.
+
+ The sequence length here is equal to `prediction_length`.
+
+ See the demo notebook and code snippets for details.
+
+ Optionally, during training any missing values need to be replaced with zeros and indicated via the
+ `future_observed_mask`.
+
+ For multivariate time series, the `input_size` > 1 dimension is required and corresponds to the number of
+ variates in the time series per time step.
+ future_time_features (`torch.FloatTensor` of shape `(batch_size, prediction_length, num_features)`):
+ Required time features for the prediction window, which the model internally will add to `future_values`.
+ These could be things like "month of year", "day of the month", etc. encoded as vectors (for instance as
+ Fourier features). These could also be so-called "age" features, which basically help the model know "at
+ which point in life" a time-series is. Age features have small values for distant past time steps and
+ increase monotonically the more we approach the current time step. Holiday features are also a good example
+ of time features.
+
+ These features serve as the "positional encodings" of the inputs. So contrary to a model like BERT, where
+ the position encodings are learned from scratch internally as parameters of the model, the Time Series
+ Transformer requires to provide additional time features. The Time Series Transformer only learns
+ additional embeddings for `static_categorical_features`.
+
+ Additional dynamic real covariates can be concatenated to this tensor, with the caveat that these features
+ must but known at prediction time.
+
+ The `num_features` here is equal to `config.`num_time_features` + `config.num_dynamic_real_features`.
+ future_observed_mask (`torch.BoolTensor` of shape `(batch_size, sequence_length)` or `(batch_size, sequence_length, input_size)`, *optional*):
+ Boolean mask to indicate which `future_values` were observed and which were missing. Mask values selected
+ in `[0, 1]`:
+
+ - 1 for values that are **observed**,
+ - 0 for values that are **missing** (i.e. NaNs that were replaced by zeros).
+
+ This mask is used to filter out missing values for the final loss calculation.
+ encoder_outputs (`tuple(tuple(torch.FloatTensor)`, *optional*):
+ Tuple consists of `last_hidden_state`, `hidden_states` (*optional*) and `attentions` (*optional*)
+ `last_hidden_state` of shape `(batch_size, sequence_length, hidden_size)` (*optional*) is a sequence of
+ hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.
+
+ Examples:
+
+ ```python
+ >>> from huggingface_hub import hf_hub_download
+ >>> import torch
+ >>> from transformers import TimeSeriesTransformerForPrediction
+
+ >>> file = hf_hub_download(
+ ... repo_id="hf-internal-testing/tourism-monthly-batch", filename="train-batch.pt", repo_type="dataset"
+ ... )
+ >>> batch = torch.load(file)
+
+ >>> model = TimeSeriesTransformerForPrediction.from_pretrained(
+ ... "huggingface/time-series-transformer-tourism-monthly"
+ ... )
+
+ >>> # during training, one provides both past and future values
+ >>> # as well as possible additional features
+ >>> outputs = model(
+ ... past_values=batch["past_values"],
+ ... past_time_features=batch["past_time_features"],
+ ... past_observed_mask=batch["past_observed_mask"],
+ ... static_categorical_features=batch["static_categorical_features"],
+ ... static_real_features=batch["static_real_features"],
+ ... future_values=batch["future_values"],
+ ... future_time_features=batch["future_time_features"],
+ ... )
+
+ >>> loss = outputs.loss
+ >>> loss.backward()
+
+ >>> # during inference, one only provides past values
+ >>> # as well as possible additional features
+ >>> # the model autoregressively generates future values
+ >>> outputs = model.generate(
+ ... past_values=batch["past_values"],
+ ... past_time_features=batch["past_time_features"],
+ ... past_observed_mask=batch["past_observed_mask"],
+ ... static_categorical_features=batch["static_categorical_features"],
+ ... static_real_features=batch["static_real_features"],
+ ... future_time_features=batch["future_time_features"],
+ ... )
+
+ >>> mean_prediction = outputs.sequences.mean(dim=1)
+ ```"""
+ if future_values is not None:
+ use_cache = False
+
+ outputs: Seq2SeqTSModelOutput = self.model(
+ past_values=past_values,
+ past_time_features=past_time_features,
+ past_observed_mask=past_observed_mask,
+ static_categorical_features=static_categorical_features,
+ static_real_features=static_real_features,
+ future_values=future_values,
+ future_time_features=future_time_features,
+ decoder_attention_mask=decoder_attention_mask,
+ encoder_outputs=encoder_outputs,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ prediction_loss = None
+ params = None
+ if future_values is not None:
+ params = self.output_params(outputs.last_hidden_state)
+ distribution = self.output_distribution(params, loc=outputs.loc, scale=outputs.scale)
+
+ loss = self.loss(distribution, future_values)
+
+ if future_observed_mask is None:
+ future_observed_mask = torch.ones_like(future_values)
+
+ if len(self.target_shape) == 0:
+ loss_weights = future_observed_mask
+ else:
+ loss_weights, _ = future_observed_mask.min(dim=-1, keepdim=False)
+
+ prediction_loss = weighted_average(loss, weights=loss_weights)
+
+ return Seq2SeqTSPredictionOutput(
+ loss=prediction_loss,
+ params=params,
+ past_key_values=outputs.past_key_values,
+ decoder_hidden_states=outputs.decoder_hidden_states,
+ decoder_attentions=outputs.decoder_attentions,
+ cross_attentions=outputs.cross_attentions,
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+ encoder_hidden_states=outputs.encoder_hidden_states,
+ encoder_attentions=outputs.encoder_attentions,
+ loc=outputs.loc,
+ scale=outputs.scale,
+ static_features=outputs.static_features,
+ )
+
+ @torch.no_grad()
+ def generate(
+ self,
+ past_values: torch.Tensor,
+ past_time_features: torch.Tensor,
+ future_time_features: torch.Tensor,
+ past_observed_mask: torch.Tensor | None = None,
+ static_categorical_features: torch.Tensor | None = None,
+ static_real_features: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ ) -> SampleTSPredictionOutput:
+ r"""
+ Greedily generate sequences of sample predictions from a model with a probability distribution head.
+
+ Parameters:
+ past_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)` or `(batch_size, sequence_length, input_size)`):
+ Past values of the time series, that serve as context in order to predict the future. The sequence size
+ of this tensor must be larger than the `context_length` of the model, since the model will use the
+ larger size to construct lag features, i.e. additional values from the past which are added in order to
+ serve as "extra context".
+
+ The `sequence_length` here is equal to `config.context_length` + `max(config.lags_sequence)`, which if
+ no `lags_sequence` is configured, is equal to `config.context_length` + 7 (as by default, the largest
+ look-back index in `config.lags_sequence` is 7). The property `_past_length` returns the actual length
+ of the past.
+
+ The `past_values` is what the Transformer encoder gets as input (with optional additional features,
+ such as `static_categorical_features`, `static_real_features`, `past_time_features` and lags).
+
+ Optionally, missing values need to be replaced with zeros and indicated via the `past_observed_mask`.
+
+ For multivariate time series, the `input_size` > 1 dimension is required and corresponds to the number
+ of variates in the time series per time step.
+ past_time_features (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_features)`):
+ Required time features, which the model internally will add to `past_values`. These could be things
+ like "month of year", "day of the month", etc. encoded as vectors (for instance as Fourier features).
+ These could also be so-called "age" features, which basically help the model know "at which point in
+ life" a time-series is. Age features have small values for distant past time steps and increase
+ monotonically the more we approach the current time step. Holiday features are also a good example of
+ time features.
+
+ These features serve as the "positional encodings" of the inputs. So contrary to a model like BERT,
+ where the position encodings are learned from scratch internally as parameters of the model, the Time
+ Series Transformer requires to provide additional time features. The Time Series Transformer only
+ learns additional embeddings for `static_categorical_features`.
+
+ Additional dynamic real covariates can be concatenated to this tensor, with the caveat that these
+ features must but known at prediction time.
+
+ The `num_features` here is equal to `config.`num_time_features` + `config.num_dynamic_real_features`.
+ future_time_features (`torch.FloatTensor` of shape `(batch_size, prediction_length, num_features)`):
+ Required time features for the prediction window, which the model internally will add to sampled
+ predictions. These could be things like "month of year", "day of the month", etc. encoded as vectors
+ (for instance as Fourier features). These could also be so-called "age" features, which basically help
+ the model know "at which point in life" a time-series is. Age features have small values for distant
+ past time steps and increase monotonically the more we approach the current time step. Holiday features
+ are also a good example of time features.
+
+ These features serve as the "positional encodings" of the inputs. So contrary to a model like BERT,
+ where the position encodings are learned from scratch internally as parameters of the model, the Time
+ Series Transformer requires to provide additional time features. The Time Series Transformer only
+ learns additional embeddings for `static_categorical_features`.
+
+ Additional dynamic real covariates can be concatenated to this tensor, with the caveat that these
+ features must but known at prediction time.
+
+ The `num_features` here is equal to `config.`num_time_features` + `config.num_dynamic_real_features`.
+ past_observed_mask (`torch.BoolTensor` of shape `(batch_size, sequence_length)` or `(batch_size, sequence_length, input_size)`, *optional*):
+ Boolean mask to indicate which `past_values` were observed and which were missing. Mask values selected
+ in `[0, 1]`:
+
+ - 1 for values that are **observed**,
+ - 0 for values that are **missing** (i.e. NaNs that were replaced by zeros).
+
+ static_categorical_features (`torch.LongTensor` of shape `(batch_size, number of static categorical features)`, *optional*):
+ Optional static categorical features for which the model will learn an embedding, which it will add to
+ the values of the time series.
+
+ Static categorical features are features which have the same value for all time steps (static over
+ time).
+
+ A typical example of a static categorical feature is a time series ID.
+ static_real_features (`torch.FloatTensor` of shape `(batch_size, number of static real features)`, *optional*):
+ Optional static real features which the model will add to the values of the time series.
+
+ Static real features are features which have the same value for all time steps (static over time).
+
+ A typical example of a static real feature is promotion information.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers.
+
+ Return:
+ [`SampleTSPredictionOutput`] where the outputs `sequences` tensor will have shape `(batch_size, number of
+ samples, prediction_length)` or `(batch_size, number of samples, prediction_length, input_size)` for
+ multivariate predictions.
+ """
+ outputs = self(
+ static_categorical_features=static_categorical_features,
+ static_real_features=static_real_features,
+ past_time_features=past_time_features,
+ past_values=past_values,
+ past_observed_mask=past_observed_mask,
+ future_time_features=future_time_features,
+ future_values=None,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=True,
+ use_cache=True,
+ )
+
+ decoder = self.model.get_decoder()
+ enc_last_hidden = outputs.encoder_last_hidden_state
+ loc = outputs.loc
+ scale = outputs.scale
+ static_feat = outputs.static_features
+
+ num_parallel_samples = self.config.num_parallel_samples
+ repeated_loc = loc.repeat_interleave(repeats=num_parallel_samples, dim=0)
+ repeated_scale = scale.repeat_interleave(repeats=num_parallel_samples, dim=0)
+
+ repeated_past_values = (
+ past_values.repeat_interleave(repeats=num_parallel_samples, dim=0) - repeated_loc
+ ) / repeated_scale
+
+ expanded_static_feat = static_feat.unsqueeze(1).expand(-1, future_time_features.shape[1], -1)
+ features = torch.cat((expanded_static_feat, future_time_features), dim=-1)
+ repeated_features = features.repeat_interleave(repeats=num_parallel_samples, dim=0)
+
+ repeated_enc_last_hidden = enc_last_hidden.repeat_interleave(repeats=num_parallel_samples, dim=0)
+
+ future_samples = []
+
+ # greedy decoding
+ for k in range(self.config.prediction_length):
+ lagged_sequence = self.model.get_lagged_subsequences(
+ sequence=repeated_past_values,
+ subsequences_length=1 + k,
+ shift=1,
+ )
+
+ lags_shape = lagged_sequence.shape
+ reshaped_lagged_sequence = lagged_sequence.reshape(lags_shape[0], lags_shape[1], -1)
+
+ decoder_input = torch.cat((reshaped_lagged_sequence, repeated_features[:, : k + 1]), dim=-1)
+
+ dec_output = decoder(inputs_embeds=decoder_input, encoder_hidden_states=repeated_enc_last_hidden)
+ dec_last_hidden = dec_output.last_hidden_state
+
+ params = self.parameter_projection(dec_last_hidden[:, -1:])
+ distr = self.output_distribution(params, loc=repeated_loc, scale=repeated_scale)
+ next_sample = distr.sample()
+
+ repeated_past_values = torch.cat(
+ (repeated_past_values, (next_sample - repeated_loc) / repeated_scale), dim=1
+ )
+ future_samples.append(next_sample)
+
+ concat_future_samples = torch.cat(future_samples, dim=1)
+
+ return SampleTSPredictionOutput(
+ sequences=concat_future_samples.reshape(
+ (-1, num_parallel_samples, self.config.prediction_length) + self.target_shape,
+ )
+ )
+
+
+__all__ = ["TimeSeriesTransformerForPrediction", "TimeSeriesTransformerModel", "TimeSeriesTransformerPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm/__init__.py b/lib/python3.11/site-packages/transformers/models/timesfm/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..12f1541b9c549256b67b3a304cc482091842e94e
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesfm/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2025 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_timesfm import *
+ from .modeling_timesfm import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd9b75c54e37a929b3f931b47a5340cce0249728
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/configuration_timesfm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/configuration_timesfm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7c570ba693ea97c062fb06346e03dd2ca9cb35d9
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/configuration_timesfm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/modeling_timesfm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/modeling_timesfm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..169f055dcd39fd0a16a0c302ffb53673d5a3e8c1
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/modeling_timesfm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/modular_timesfm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/modular_timesfm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e763d53953aebc78571f4afe6b23c3b180da2db1
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesfm/__pycache__/modular_timesfm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm/configuration_timesfm.py b/lib/python3.11/site-packages/transformers/models/timesfm/configuration_timesfm.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef12ae5eb8608514fe8a78c4655dd64f1e6828e1
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesfm/configuration_timesfm.py
@@ -0,0 +1,76 @@
+# Copyright 2025 Google LLC and 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.
+"""TimesFM model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="google/timesfm-2.0-500m-pytorch")
+@strict
+class TimesFmConfig(PreTrainedConfig):
+ r"""
+ patch_length (`int`, *optional*, defaults to 32):
+ The length of one patch in the input sequence.
+ context_length (`int`, *optional*, defaults to 512):
+ The length of the input context.
+ horizon_length (`int`, *optional*, defaults to 128):
+ The length of the prediction horizon.
+ freq_size (`int`, *optional*, defaults to 3):
+ The number of frequency embeddings.
+ tolerance (`float`, *optional*, defaults to 1e-06):
+ The tolerance for the quantile loss.
+ quantiles (`list[float]`, *optional*, defaults to `[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]`):
+ The quantiles to predict.
+ pad_val (`float`, *optional*, defaults to 1123581321.0):
+ The value used to pad the predictions.
+ attention_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout probability for the attention scores.
+ use_positional_embedding (`bool`, *optional*, defaults to `False`):
+ Whether to add positional embeddings.
+ min_timescale (`int`, *optional*, defaults to 1):
+ The start of the geometric positional index. Determines the periodicity of
+ the added signal.
+ max_timescale (`int`, *optional*, defaults to 10000):
+ The end of the geometric positional index. Determines the frequency of the
+ added signal.
+ """
+
+ model_type = "timesfm"
+ keys_to_ignore_at_inference = []
+ is_encoder_decoder = False
+
+ patch_length: int = 32
+ context_length: int = 512
+ horizon_length: int = 128
+ freq_size: int = 3
+ num_hidden_layers: int = 50
+ hidden_size: int = 1280
+ intermediate_size: int = 1280
+ head_dim: int = 80
+ num_attention_heads: int = 16
+ tolerance: float = 1e-6
+ rms_norm_eps: float = 1e-6
+ quantiles: list[float] | tuple[float, ...] = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9)
+ pad_val: float = 1123581321.0
+ attention_dropout: float | int = 0.0
+ use_positional_embedding: bool = False
+ initializer_range: float = 0.02
+ min_timescale: int = 1
+ max_timescale: int = 10_000
+
+
+__all__ = ["TimesFmConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm/modeling_timesfm.py b/lib/python3.11/site-packages/transformers/models/timesfm/modeling_timesfm.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab0e706a493e0124d20d6251315c722edf4ac05f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesfm/modeling_timesfm.py
@@ -0,0 +1,808 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/timesfm/modular_timesfm.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_timesfm.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 Google LLC and 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.
+
+import math
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ... import initialization as init
+from ...integrations import use_kernel_forward_from_hub
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_outputs import BaseModelOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, logging
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_timesfm import TimesFmConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring
+@dataclass
+class TimesFmOutput(BaseModelOutput):
+ r"""
+ loc (`torch.Tensor` of shape `(batch_size, )`):
+ The mean of the time series inputs.
+ scale (`torch.Tensor` of shape `(batch_size,)`):
+ The scale of the time series inputs.
+ """
+
+ loc: torch.Tensor | None = None
+ scale: torch.Tensor | None = None
+
+
+@auto_docstring
+@dataclass
+class TimesFmOutputForPrediction(BaseModelOutput):
+ r"""
+ mean_predictions (`torch.Tensor` of shape `(batch_size, sequence_length)`):
+ The mean predictions of the time series.
+ full_predictions (`torch.Tensor` of shape `(batch_size, sequence_length)`):
+ The full predictions of the time series including the mean and the quantiles.
+ loss (`torch.Tensor` of shape `(1,)`, *optional*, returned when `future_values` is provided):
+ The loss of the TimesFM model.
+ """
+
+ mean_predictions: torch.Tensor | None = None
+ full_predictions: torch.Tensor | None = None
+ loss: torch.Tensor | float | None = None
+
+
+class TimesFmMLP(nn.Module):
+ """Pax MLP in pytorch."""
+
+ def __init__(self, config: TimesFmConfig):
+ super().__init__()
+ hidden_size = config.hidden_size
+ intermediate_size = config.intermediate_size
+
+ self.gate_proj = nn.Linear(hidden_size, intermediate_size)
+ self.down_proj = nn.Linear(intermediate_size, hidden_size)
+ self.layer_norm = nn.LayerNorm(normalized_shape=hidden_size, eps=1e-6)
+
+ def forward(self, x, paddings=None):
+ gate_inp = self.layer_norm(x)
+ gate = self.gate_proj(gate_inp)
+ gate = F.relu(gate)
+ outputs = self.down_proj(gate)
+ if paddings is not None:
+ outputs = outputs * (1.0 - paddings[:, :, None])
+ return outputs + x
+
+
+class TimesFmResidualBlock(nn.Module):
+ """TimesFM residual block."""
+
+ def __init__(self, input_dims, hidden_dims, output_dims):
+ super().__init__()
+ self.input_dims = input_dims
+ self.hidden_dims = hidden_dims
+ self.output_dims = output_dims
+
+ self.input_layer = nn.Linear(input_dims, hidden_dims)
+ self.activation = nn.SiLU()
+ self.output_layer = nn.Linear(hidden_dims, output_dims)
+ self.residual_layer = nn.Linear(input_dims, output_dims)
+
+ def forward(self, x):
+ hidden = self.input_layer(x)
+ hidden = self.activation(hidden)
+ output = self.output_layer(hidden)
+ residual = self.residual_layer(x)
+ return output + residual
+
+
+@use_kernel_forward_from_hub("RMSNorm")
+class TimesFmRMSNorm(nn.Module):
+ def __init__(self, hidden_size, eps: float = 1e-6) -> None:
+ """
+ TimesFmRMSNorm is equivalent to T5LayerNorm
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ input_dtype = hidden_states.dtype
+ hidden_states = hidden_states.to(torch.float32)
+ variance = hidden_states.pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+ return self.weight * hidden_states.to(input_dtype)
+
+ def extra_repr(self):
+ return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"
+
+
+class TimesFmPositionalEmbedding(nn.Module):
+ """Generates position embedding for a given 1-d sequence."""
+
+ def __init__(self, config: TimesFmConfig):
+ super().__init__()
+ min_timescale = config.min_timescale
+ max_timescale = config.max_timescale
+ self.min_timescale, self.max_timescale = min_timescale, max_timescale
+ self.embedding_dims = config.hidden_size
+
+ num_timescales = self.embedding_dims // 2
+ log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / max(num_timescales - 1, 1)
+ self.register_buffer(
+ "inv_timescales",
+ min_timescale * torch.exp(torch.arange(num_timescales, dtype=torch.float32) * -log_timescale_increment),
+ )
+
+ def forward(self, seq_length=None, position=None):
+ """Generates a Tensor of sinusoids with different frequencies.
+
+ Args:
+ seq_length: an optional Python int defining the output sequence length.
+ if the `position` argument is specified.
+ position: [B, seq_length], optional position for each token in the
+ sequence, only required when the sequence is packed.
+
+ Returns:
+ [B, seqlen, D] if `position` is specified, else [1, seqlen, D]
+ """
+ if position is None and seq_length is None:
+ raise ValueError("Either position or seq_length must be provided")
+
+ if position is None:
+ # [1, seqlen]
+ position = torch.arange(seq_length, dtype=torch.float32, device=self.inv_timescales.device).unsqueeze(0)
+ elif position.ndim != 2:
+ raise ValueError(f"position must be 2-dimensional, got shape {position.shape}")
+
+ scaled_time = position.view(*position.shape, 1) * self.inv_timescales.view(1, 1, -1)
+ signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], dim=2)
+
+ # Padding to ensure correct embedding dimension
+ signal = F.pad(signal, (0, 0, 0, self.embedding_dims % 2))
+ return signal
+
+
+def simple_eager_attention_forward(
+ module: nn.Module,
+ query_states: torch.Tensor,
+ key_states: torch.Tensor,
+ value_states: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float,
+ dropout: float | int = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) * scaling
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value_states)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+class TimesFmAttention(nn.Module):
+ """Implements the attention used in TimesFM. One key difference is that there is _per_dim_scaling of the query."""
+
+ def __init__(self, config: TimesFmConfig, layer_idx: int):
+ super().__init__()
+ self.config = config
+ self.is_causal = True
+ self.attention_dropout = config.attention_dropout
+ self.layer_idx = layer_idx
+
+ self.num_heads = config.num_attention_heads
+ self.hidden_size = config.hidden_size
+ self.head_dim = config.head_dim
+
+ self.q_size = self.num_heads * self.head_dim
+ self.kv_size = self.num_heads * self.head_dim
+ self.scaling = nn.Parameter(torch.empty((self.head_dim,)))
+
+ self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim)
+ self.k_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim)
+ self.v_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim)
+ self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size)
+
+ def _scale_query(self, query: torch.Tensor) -> torch.Tensor:
+ scale = F.softplus(self.scaling).mul(1.442695041 / math.sqrt(self.head_dim))
+ return query * scale[None, None, None, :]
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ query_states = self._scale_query(query_states)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, simple_eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ scaling=1.0,
+ **kwargs,
+ )
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+class TimesFmDecoderLayer(nn.Module):
+ """Transformer layer."""
+
+ def __init__(self, config: TimesFmConfig, layer_idx: int):
+ super().__init__()
+
+ self.self_attn = TimesFmAttention(config, layer_idx=layer_idx)
+ self.mlp = TimesFmMLP(config)
+ self.input_layernorm = TimesFmRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ paddings: torch.Tensor,
+ **kwargs,
+ ) -> torch.Tensor:
+ # Self Attention
+ residual = hidden_states
+ hidden_states = self.input_layernorm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ )
+ hidden_states = residual + hidden_states
+
+ # MLP
+ hidden_states = self.mlp(hidden_states, paddings=paddings)
+
+ return hidden_states
+
+
+@auto_docstring
+class TimesFmPreTrainedModel(PreTrainedModel):
+ config: TimesFmConfig
+ base_model_prefix = "timesfm"
+ _no_split_modules = ["TimesFmDecoderLayer"]
+ main_input_name = "past_values"
+ input_modalities = ("time",)
+ _supports_sdpa = True
+ _can_record_outputs = {
+ "hidden_states": TimesFmDecoderLayer,
+ "attentions": TimesFmAttention,
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, TimesFmAttention):
+ # Initialize scaling parameter
+ init.ones_(module.scaling)
+ elif isinstance(module, TimesFmPositionalEmbedding):
+ num_timescales = module.embedding_dims // 2
+ max_timescale, min_timescale = module.max_timescale, module.min_timescale
+ log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / max(
+ num_timescales - 1, 1
+ )
+ init.copy_(
+ module.inv_timescales,
+ min_timescale
+ * torch.exp(torch.arange(num_timescales, dtype=torch.float32) * -log_timescale_increment),
+ )
+
+
+@auto_docstring
+class TimesFmModel(TimesFmPreTrainedModel):
+ def __init__(self, config: TimesFmConfig):
+ super().__init__(config)
+
+ self.config = config
+ self.input_ff_layer = TimesFmResidualBlock(
+ input_dims=2 * config.patch_length,
+ output_dims=config.hidden_size,
+ hidden_dims=config.intermediate_size,
+ )
+ self.freq_emb = nn.Embedding(num_embeddings=config.freq_size, embedding_dim=config.hidden_size)
+ self.layers = nn.ModuleList(
+ [TimesFmDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ if self.config.use_positional_embedding:
+ self.position_emb = TimesFmPositionalEmbedding(config=config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _forward_transform(
+ self, inputs: torch.Tensor, patched_pads: torch.Tensor
+ ) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
+ """Input is of shape [B, N, P]."""
+ mu, sigma = self._timesfm_masked_mean_std(inputs, patched_pads)
+ sigma = torch.clamp(sigma, min=self.config.tolerance)
+
+ # Normalize each patch
+ outputs = (inputs - mu[:, None, None]) / sigma[:, None, None]
+ outputs = torch.where(
+ torch.abs(inputs - self.config.pad_val) < self.config.tolerance,
+ torch.tensor(self.config.pad_val, dtype=outputs.dtype, device=outputs.device),
+ outputs,
+ )
+ return outputs, (mu, sigma)
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ past_values: torch.Tensor,
+ past_values_padding: torch.LongTensor,
+ freq: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TimesFmOutput:
+ r"""
+ past_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Past values of the time series that serves as input to the model.
+ past_values_padding (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ The padding indicator of the time series.
+ freq (`torch.LongTensor` of shape `(batch_size,)`):
+ Frequency indices for the time series data.
+ """
+ # Reshape into patches (using view for efficiency)
+ bsize = past_values.shape[0]
+ patched_inputs = past_values.view(bsize, -1, self.config.patch_length)
+ patched_pads = past_values_padding.view(bsize, -1, self.config.patch_length)
+
+ patched_inputs = torch.where(
+ torch.abs(patched_pads - 1.0) < self.config.tolerance,
+ torch.tensor(0.0, dtype=patched_inputs.dtype, device=patched_inputs.device),
+ patched_inputs,
+ )
+ patched_pads = torch.where(
+ torch.abs(patched_inputs - self.config.pad_val) < self.config.tolerance,
+ torch.tensor(1.0, dtype=patched_pads.dtype, device=patched_pads.device),
+ patched_pads,
+ )
+ patched_inputs, stats = self._forward_transform(patched_inputs, patched_pads)
+
+ # B x N x D
+ patched_inputs = patched_inputs * (1.0 - patched_pads)
+ concat_inputs = torch.cat([patched_inputs, patched_pads], dim=-1)
+ model_input = self.input_ff_layer(concat_inputs)
+
+ # A patch should not be padded even if there is at least one zero.
+ patched_padding = torch.min(patched_pads, dim=-1)[0] # Get the values from the min result
+ if self.config.use_positional_embedding:
+ pos_emb = self.position_emb(model_input.shape[1])
+ pos_emb = torch.concat([pos_emb] * model_input.shape[0], dim=0)
+ pos_emb = self._timesfm_shift_padded_seq(patched_padding, pos_emb)
+ model_input += pos_emb
+
+ f_emb = self.freq_emb(freq) # B x 1 x D
+ model_input += f_emb
+
+ # Convert paddings to attention mask and combine with causal mask
+ hidden_states = model_input
+ attention_mask = self._prepare_4d_attention_mask(
+ attention_mask=patched_padding,
+ sequence_length=hidden_states.shape[1],
+ dtype=hidden_states.dtype,
+ device=hidden_states.device,
+ is_causal=True,
+ )
+
+ for layer in self.layers[: self.config.num_hidden_layers]:
+ hidden_states = layer(
+ hidden_states,
+ attention_mask=attention_mask,
+ paddings=patched_padding,
+ **kwargs,
+ )
+
+ return TimesFmOutput(
+ last_hidden_state=hidden_states,
+ loc=stats[0],
+ scale=stats[1],
+ )
+
+ @staticmethod
+ def _prepare_4d_attention_mask(
+ attention_mask: torch.Tensor | None,
+ sequence_length: int,
+ dtype: torch.dtype,
+ device: torch.device,
+ is_causal: bool = True,
+ ) -> torch.Tensor | None:
+ """
+ Creates 4D attention mask and combines causal and padding masks if needed.
+
+ Args:
+ attention_mask: Optional tensor of shape (batch_size, seq_length) containing padding mask
+ sequence_length: Length of the sequence
+ dtype: Data type of the mask
+ device: Device of the mask
+ is_causal: Whether to apply causal masking
+
+ Returns:
+ 4D attention mask of shape (batch_size, 1, seq_length, seq_length)
+ """
+ # Get minimum value for the dtype
+ min_value = torch.finfo(dtype).min if dtype.is_floating_point else torch.iinfo(dtype).min
+
+ # Handle padding mask
+ if attention_mask is not None:
+ # Convert 2D padding mask to 4D attention mask
+ attention_mask = attention_mask.view(attention_mask.shape[0], 1, 1, -1)
+ attention_mask = attention_mask * min_value
+
+ # Create causal mask if needed
+ if is_causal:
+ causal_mask = torch.triu(
+ torch.ones((sequence_length, sequence_length), dtype=dtype, device=device) * min_value,
+ diagonal=1,
+ )
+ causal_mask = causal_mask.view(1, 1, sequence_length, sequence_length)
+
+ # Combine with padding mask if it exists
+ if attention_mask is not None:
+ attention_mask = torch.minimum(attention_mask, causal_mask)
+ else:
+ attention_mask = causal_mask
+
+ return attention_mask
+
+ @staticmethod
+ def _timesfm_masked_mean_std(inputs: torch.Tensor, padding: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+ """Calculates mean and standard deviation of `inputs` across axis 1.
+
+ It excludes values where `padding` is 1.
+
+ Args:
+ inputs: A PyTorch tensor of shape [b, n, p].
+ padding: A PyTorch tensor of shape [b, n, p] with values 0 or 1.
+
+ Returns:
+ A tuple containing the mean and standard deviation.
+ We return the statistics of the first patch with more than three non-padded values.
+ """
+
+ # Selecting the first patch with more than 3 unpadded values.
+ def _get_patch_index(arr: torch.Tensor):
+ indices = torch.argmax((arr >= 3).to(torch.int32), dim=1)
+ row_sum = (arr >= 3).to(torch.int32).sum(dim=1)
+ return torch.where(row_sum == 0, arr.shape[1] - 1, indices)
+
+ pad_sum = torch.sum(1 - padding, dim=2)
+ patch_indices = _get_patch_index(pad_sum)
+ bidxs = torch.arange(inputs.shape[0])
+
+ arr = inputs[bidxs, patch_indices, :]
+ pad = padding[bidxs, patch_indices, :]
+
+ # Create a mask where padding is 0
+ mask = 1 - pad
+
+ # Calculate the number of valid elements
+ num_valid_elements = torch.sum(mask, dim=1)
+ num_valid_elements = torch.clamp(num_valid_elements, min=1.0)
+
+ # Calculate the masked sum and mean
+ masked_sum = torch.sum(arr * mask, dim=1)
+ masked_mean = masked_sum / num_valid_elements # [b]
+
+ # Calculate the masked variance using centered values
+ masked_centered_arr = (arr - masked_mean.unsqueeze(-1)) * mask
+ masked_var = torch.sum(masked_centered_arr**2, dim=1) / num_valid_elements
+ masked_var = torch.clamp(masked_var, min=0.0)
+ masked_std = torch.sqrt(masked_var)
+
+ return masked_mean, masked_std
+
+ @staticmethod
+ def _timesfm_shift_padded_seq(mask: torch.Tensor, seq: torch.Tensor) -> torch.Tensor:
+ """Shifts rows of seq based on the first 0 in each row of the mask.
+
+ Args:
+ mask: mask tensor of shape [B, N]
+ seq: seq tensor of shape [B, N, P]
+
+ Returns:
+ The shifted sequence.
+ """
+ batch_size, num_seq, feature_dim = seq.shape
+
+ new_mask: torch.BoolTensor = mask == 0
+
+ # Use argmax to find the first True value in each row
+ indices = new_mask.to(torch.int32).argmax(dim=1)
+
+ # Handle rows with all zeros
+ indices[~new_mask.any(dim=1)] = -1
+
+ # Create index ranges for each sequence in the batch
+ idx_range = torch.arange(num_seq, device=seq.device).view(1, -1, 1).expand(batch_size, -1, feature_dim)
+
+ # Calculate shifted indices for each element in each sequence
+ shifted_idx = (idx_range - indices[:, None, None]) % num_seq
+
+ # Gather values from seq using shifted indices
+ shifted_seq = seq.gather(1, shifted_idx)
+
+ return shifted_seq
+
+
+class TimesFmModelForPrediction(TimesFmPreTrainedModel):
+ """TimesFM model for quantile and mean prediction."""
+
+ def __init__(self, config: TimesFmConfig):
+ super().__init__(config)
+
+ self.config = config
+ self.context_len = config.context_length
+ self.horizon_len = config.horizon_length
+
+ self.decoder = TimesFmModel(config)
+
+ # quantile and mean output
+ self.horizon_ff_layer = TimesFmResidualBlock(
+ input_dims=config.hidden_size,
+ output_dims=config.horizon_length * (1 + len(config.quantiles)),
+ hidden_dims=config.intermediate_size,
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _preprocess(
+ self, inputs: Sequence[torch.Tensor], freq: Sequence[int] | None = None, context_len: int | None = None
+ ) -> tuple[torch.Tensor, ...]:
+ """Pad/truncate input time series to `context_len` and build a padding mask.
+
+ Args:
+ inputs: A list of 1d Tensors. Each Tensor is the context time series of a single forecast task.
+ freq: Optional list of frequencies (returned as a tensor when provided).
+ context_len: Optional context length override (defaults to `self.context_len`).
+
+ Returns:
+ Tuple of (padded_inputs, padding_mask) and optionally a freq tensor.
+ """
+ if context_len is None:
+ context_len = self.context_len
+
+ input_ts, input_padding = [], []
+
+ for ts in inputs:
+ input_len = ts.shape[0]
+ padding = torch.zeros(input_len + self.horizon_len, dtype=ts.dtype, device=ts.device)
+ if input_len < context_len:
+ num_front_pad = context_len - input_len
+ ts = torch.cat([torch.zeros(num_front_pad, dtype=ts.dtype, device=ts.device), ts], dim=0)
+ padding = torch.cat([torch.ones(num_front_pad, dtype=ts.dtype, device=padding.device), padding], dim=0)
+ elif input_len > context_len:
+ ts = ts[-context_len:]
+ padding = padding[-(context_len + self.horizon_len) :]
+
+ input_ts.append(ts)
+ input_padding.append(padding)
+
+ result = (torch.stack(input_ts, dim=0), torch.stack(input_padding, dim=0))
+ if freq is not None:
+ result = result + (torch.tensor(freq[: len(inputs)], dtype=torch.int32).reshape(-1, 1),)
+ return result
+
+ def _postprocess_output(
+ self, model_output: torch.Tensor, stats: tuple[torch.Tensor, torch.Tensor]
+ ) -> torch.Tensor:
+ """Postprocess output of stacked transformer."""
+
+ # B x N x (H.Q)
+ output_ts = self.horizon_ff_layer(model_output)
+
+ # Reshape using view
+ b, n, _ = output_ts.shape
+ output_ts = output_ts.view(b, n, self.config.horizon_length, len(self.config.quantiles) + 1)
+
+ mu, sigma = stats
+ return output_ts * sigma[:, None, None, None] + mu[:, None, None, None]
+
+ def _quantile_loss(self, predictions: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
+ losses = []
+ for i, q in enumerate(self.config.quantiles):
+ errors = targets - predictions[..., i]
+ loss = torch.max((q - 1) * errors, q * errors)
+ losses.append(loss.mean())
+ return torch.stack(losses).mean()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ past_values: Sequence[torch.Tensor],
+ freq: Sequence[torch.Tensor | int] | None = None,
+ window_size: int | None = None,
+ future_values: torch.Tensor | None = None,
+ forecast_context_len: int | None = None,
+ return_forecast_on_context: bool = False,
+ truncate_negative: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TimesFmOutputForPrediction:
+ r"""
+ past_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Past values of the time series that serves as input to the model.
+ freq (`torch.LongTensor` of shape `(batch_size,)`):
+ Frequency indices for the time series data.
+ window_size (`int`, *optional*):
+ Window size of trend + residual decomposition. If None then we do not do decomposition.
+ future_values (`torch.Tensor`, *optional*):
+ Optional future time series values to be used for loss computation.
+ forecast_context_len (`int`, *optional*):
+ Optional max context length.
+ return_forecast_on_context (`bool`, *optional*):
+ True to return the forecast on the context when available, i.e. after the first input patch.
+ truncate_negative (`bool`, *optional*):
+ Truncate to only non-negative values if any of the contexts have non-negative values,
+ otherwise do nothing.
+
+ Example:
+
+ ```python
+ >>> from transformers import TimesFmModelForPrediction
+
+ >>> model = TimesFmModelForPrediction.from_pretrained("google/timesfm-2.0-500m-pytorch")
+
+ >>> forecast_input = [torch.linspace(0, 20, 100).sin(), torch.linspace(0, 20, 200).sin(), torch.linspace(0, 20, 400).sin()]
+ >>> frequency_input = torch.tensor([0, 1, 2], dtype=torch.long)
+
+ >>> # Generate
+ >>> with torch.no_grad():
+ >>> outputs = model(past_values=forecast_input, freq=frequency_input, return_dict=True)
+ >>> point_forecast_conv = outputs.mean_predictions
+ >>> quantile_forecast_conv = outputs.full_predictions
+ ```
+ """
+ if forecast_context_len is None:
+ fcontext_len = self.context_len
+ else:
+ fcontext_len = forecast_context_len
+
+ device = past_values[0].device
+
+ inputs = [ts[-fcontext_len:] for ts in past_values]
+ inp_min = torch.min(torch.stack([torch.min(ts) for ts in inputs]))
+
+ if window_size is not None:
+ new_inputs = []
+ new_freqs = []
+ for i, ts in enumerate(inputs):
+ new_inputs.extend(self._timesfm_moving_average(ts, window_size))
+ if freq is not None:
+ new_freqs.extend([freq[i]] * 2)
+ inputs = new_inputs
+ if freq is not None:
+ freq = new_freqs
+
+ if freq is None:
+ logger.info("No frequency provided via `freq`. Default to high (0).")
+ freq = [0] * len(inputs)
+
+ input_ts, input_padding, inp_freq = self._preprocess(inputs, freq)
+ input_ts = input_ts.to(device)
+ input_padding = input_padding.to(device)
+ inp_freq = inp_freq.to(device)
+
+ final_out = input_ts
+ context_len = final_out.shape[1]
+ full_outputs = []
+
+ if input_padding.shape[1] != final_out.shape[1] + self.horizon_len:
+ raise ValueError(
+ "Length of paddings must match length of input + horizon_len:"
+ f" {input_padding.shape[1]} != {final_out.shape[1]} + {self.horizon_len}"
+ )
+ output_patch_len = self.config.horizon_length
+
+ num_decode_patches = (self.horizon_len + output_patch_len - 1) // output_patch_len
+ for step_index in range(num_decode_patches):
+ current_padding = input_padding[:, 0 : final_out.shape[1]]
+ input_ts = final_out[:, -fcontext_len:]
+ input_padding = current_padding[:, -fcontext_len:]
+ decoder_output: TimesFmOutput = self.decoder(
+ past_values=input_ts,
+ past_values_padding=input_padding,
+ freq=inp_freq,
+ **kwargs,
+ )
+ fprop_outputs = self._postprocess_output(
+ decoder_output.last_hidden_state,
+ (decoder_output.loc, decoder_output.scale),
+ )
+
+ if return_forecast_on_context and step_index == 0:
+ new_full_ts = fprop_outputs[:, :-1, : self.config.patch_length, :]
+ new_full_ts = new_full_ts.reshape(new_full_ts.size(0), -1, new_full_ts.size(3))
+ full_outputs.append(new_full_ts)
+
+ new_ts = fprop_outputs[:, -1, :output_patch_len, 0]
+ new_full_ts = fprop_outputs[:, -1, :output_patch_len, :]
+ full_outputs.append(new_full_ts)
+ final_out = torch.concatenate([final_out, new_ts], axis=-1)
+
+ if return_forecast_on_context:
+ full_outputs = torch.concatenate(full_outputs, axis=1)[
+ :, : (context_len - self.config.patch_length + self.horizon_len), :
+ ]
+ else:
+ full_outputs = torch.concatenate(full_outputs, axis=1)[:, 0 : self.horizon_len, :]
+
+ mean_outputs = full_outputs[:, :, 0]
+ if window_size is not None:
+ mean_outputs = mean_outputs[0::2, ...] + mean_outputs[1::2, ...]
+ full_outputs = full_outputs[0::2, ...] + full_outputs[1::2, ...]
+ if inp_min >= 0 and truncate_negative:
+ mean_outputs = torch.maximum(mean_outputs, 0.0)
+ full_outputs = torch.maximum(full_outputs, 0.0)
+
+ loss = None
+ if future_values is not None:
+ mse_loss = F.mse_loss(mean_outputs, future_values)
+ quantile_loss = self._quantile_loss(full_outputs[:, :, 1:], future_values)
+ loss = mse_loss + quantile_loss
+
+ return TimesFmOutputForPrediction(
+ last_hidden_state=decoder_output.last_hidden_state,
+ attentions=decoder_output.attentions,
+ hidden_states=decoder_output.hidden_states,
+ mean_predictions=mean_outputs,
+ full_predictions=full_outputs,
+ loss=loss,
+ )
+
+ @staticmethod
+ def _timesfm_moving_average(arr: torch.Tensor, window_size: int) -> list[torch.Tensor]:
+ """Calculates the moving average using PyTorch's convolution function."""
+ # Pad with zeros to handle initial window positions
+ arr_padded = F.pad(arr, (window_size - 1, 0), "constant", 0)
+ # Create a convolution kernel
+ kernel = torch.ones(window_size, dtype=arr.dtype, device=arr.device) / window_size
+ # Apply convolution to calculate the moving average
+ smoothed_arr = F.conv1d(arr_padded.view(1, 1, -1), kernel.view(1, 1, -1)).squeeze()
+ return [smoothed_arr, arr - smoothed_arr]
+
+
+__all__ = ["TimesFmModelForPrediction", "TimesFmPreTrainedModel", "TimesFmModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm/modular_timesfm.py b/lib/python3.11/site-packages/transformers/models/timesfm/modular_timesfm.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9e2d24ccfac5cb22caee73d781ce31a50b34146
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesfm/modular_timesfm.py
@@ -0,0 +1,765 @@
+# Copyright 2025 Google LLC and 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.
+"""PyTorch TimesFM model."""
+
+import math
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ... import initialization as init
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_outputs import BaseModelOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, logging
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from ..llama.modeling_llama import LlamaRMSNorm
+from ..phi4_multimodal.modeling_phi4_multimodal import simple_eager_attention_forward
+from .configuration_timesfm import TimesFmConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring
+@dataclass
+class TimesFmOutput(BaseModelOutput):
+ r"""
+ loc (`torch.Tensor` of shape `(batch_size, )`):
+ The mean of the time series inputs.
+ scale (`torch.Tensor` of shape `(batch_size,)`):
+ The scale of the time series inputs.
+ """
+
+ loc: torch.Tensor | None = None
+ scale: torch.Tensor | None = None
+
+
+@auto_docstring
+@dataclass
+class TimesFmOutputForPrediction(BaseModelOutput):
+ r"""
+ mean_predictions (`torch.Tensor` of shape `(batch_size, sequence_length)`):
+ The mean predictions of the time series.
+ full_predictions (`torch.Tensor` of shape `(batch_size, sequence_length)`):
+ The full predictions of the time series including the mean and the quantiles.
+ loss (`torch.Tensor` of shape `(1,)`, *optional*, returned when `future_values` is provided):
+ The loss of the TimesFM model.
+ """
+
+ mean_predictions: torch.Tensor | None = None
+ full_predictions: torch.Tensor | None = None
+ loss: torch.Tensor | float | None = None
+
+
+class TimesFmMLP(nn.Module):
+ """Pax MLP in pytorch."""
+
+ def __init__(self, config: TimesFmConfig):
+ super().__init__()
+ hidden_size = config.hidden_size
+ intermediate_size = config.intermediate_size
+
+ self.gate_proj = nn.Linear(hidden_size, intermediate_size)
+ self.down_proj = nn.Linear(intermediate_size, hidden_size)
+ self.layer_norm = nn.LayerNorm(normalized_shape=hidden_size, eps=1e-6)
+
+ def forward(self, x, paddings=None):
+ gate_inp = self.layer_norm(x)
+ gate = self.gate_proj(gate_inp)
+ gate = F.relu(gate)
+ outputs = self.down_proj(gate)
+ if paddings is not None:
+ outputs = outputs * (1.0 - paddings[:, :, None])
+ return outputs + x
+
+
+class TimesFmResidualBlock(nn.Module):
+ """TimesFM residual block."""
+
+ def __init__(self, input_dims, hidden_dims, output_dims):
+ super().__init__()
+ self.input_dims = input_dims
+ self.hidden_dims = hidden_dims
+ self.output_dims = output_dims
+
+ self.input_layer = nn.Linear(input_dims, hidden_dims)
+ self.activation = nn.SiLU()
+ self.output_layer = nn.Linear(hidden_dims, output_dims)
+ self.residual_layer = nn.Linear(input_dims, output_dims)
+
+ def forward(self, x):
+ hidden = self.input_layer(x)
+ hidden = self.activation(hidden)
+ output = self.output_layer(hidden)
+ residual = self.residual_layer(x)
+ return output + residual
+
+
+class TimesFmRMSNorm(LlamaRMSNorm):
+ pass
+
+
+class TimesFmPositionalEmbedding(nn.Module):
+ """Generates position embedding for a given 1-d sequence."""
+
+ def __init__(self, config: TimesFmConfig):
+ super().__init__()
+ min_timescale = config.min_timescale
+ max_timescale = config.max_timescale
+ self.min_timescale, self.max_timescale = min_timescale, max_timescale
+ self.embedding_dims = config.hidden_size
+
+ num_timescales = self.embedding_dims // 2
+ log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / max(num_timescales - 1, 1)
+ self.register_buffer(
+ "inv_timescales",
+ min_timescale * torch.exp(torch.arange(num_timescales, dtype=torch.float32) * -log_timescale_increment),
+ )
+
+ def forward(self, seq_length=None, position=None):
+ """Generates a Tensor of sinusoids with different frequencies.
+
+ Args:
+ seq_length: an optional Python int defining the output sequence length.
+ if the `position` argument is specified.
+ position: [B, seq_length], optional position for each token in the
+ sequence, only required when the sequence is packed.
+
+ Returns:
+ [B, seqlen, D] if `position` is specified, else [1, seqlen, D]
+ """
+ if position is None and seq_length is None:
+ raise ValueError("Either position or seq_length must be provided")
+
+ if position is None:
+ # [1, seqlen]
+ position = torch.arange(seq_length, dtype=torch.float32, device=self.inv_timescales.device).unsqueeze(0)
+ elif position.ndim != 2:
+ raise ValueError(f"position must be 2-dimensional, got shape {position.shape}")
+
+ scaled_time = position.view(*position.shape, 1) * self.inv_timescales.view(1, 1, -1)
+ signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], dim=2)
+
+ # Padding to ensure correct embedding dimension
+ signal = F.pad(signal, (0, 0, 0, self.embedding_dims % 2))
+ return signal
+
+
+class TimesFmAttention(nn.Module):
+ """Implements the attention used in TimesFM. One key difference is that there is _per_dim_scaling of the query."""
+
+ def __init__(self, config: TimesFmConfig, layer_idx: int):
+ super().__init__()
+ self.config = config
+ self.is_causal = True
+ self.attention_dropout = config.attention_dropout
+ self.layer_idx = layer_idx
+
+ self.num_heads = config.num_attention_heads
+ self.hidden_size = config.hidden_size
+ self.head_dim = config.head_dim
+
+ self.q_size = self.num_heads * self.head_dim
+ self.kv_size = self.num_heads * self.head_dim
+ self.scaling = nn.Parameter(torch.empty((self.head_dim,)))
+
+ self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim)
+ self.k_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim)
+ self.v_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim)
+ self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size)
+
+ def _scale_query(self, query: torch.Tensor) -> torch.Tensor:
+ scale = F.softplus(self.scaling).mul(1.442695041 / math.sqrt(self.head_dim))
+ return query * scale[None, None, None, :]
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ query_states = self._scale_query(query_states)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, simple_eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ scaling=1.0,
+ **kwargs,
+ )
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+class TimesFmDecoderLayer(nn.Module):
+ """Transformer layer."""
+
+ def __init__(self, config: TimesFmConfig, layer_idx: int):
+ super().__init__()
+
+ self.self_attn = TimesFmAttention(config, layer_idx=layer_idx)
+ self.mlp = TimesFmMLP(config)
+ self.input_layernorm = TimesFmRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor,
+ paddings: torch.Tensor,
+ **kwargs,
+ ) -> torch.Tensor:
+ # Self Attention
+ residual = hidden_states
+ hidden_states = self.input_layernorm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ attention_mask=attention_mask,
+ )
+ hidden_states = residual + hidden_states
+
+ # MLP
+ hidden_states = self.mlp(hidden_states, paddings=paddings)
+
+ return hidden_states
+
+
+@auto_docstring
+class TimesFmPreTrainedModel(PreTrainedModel):
+ config: TimesFmConfig
+ base_model_prefix = "timesfm"
+ _no_split_modules = ["TimesFmDecoderLayer"]
+ main_input_name = "past_values"
+ input_modalities = ("time",)
+ _supports_sdpa = True
+ _can_record_outputs = {
+ "hidden_states": TimesFmDecoderLayer,
+ "attentions": TimesFmAttention,
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, TimesFmAttention):
+ # Initialize scaling parameter
+ init.ones_(module.scaling)
+ elif isinstance(module, TimesFmPositionalEmbedding):
+ num_timescales = module.embedding_dims // 2
+ max_timescale, min_timescale = module.max_timescale, module.min_timescale
+ log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / max(
+ num_timescales - 1, 1
+ )
+ init.copy_(
+ module.inv_timescales,
+ min_timescale
+ * torch.exp(torch.arange(num_timescales, dtype=torch.float32) * -log_timescale_increment),
+ )
+
+
+@auto_docstring
+class TimesFmModel(TimesFmPreTrainedModel):
+ def __init__(self, config: TimesFmConfig):
+ super().__init__(config)
+
+ self.config = config
+ self.input_ff_layer = TimesFmResidualBlock(
+ input_dims=2 * config.patch_length,
+ output_dims=config.hidden_size,
+ hidden_dims=config.intermediate_size,
+ )
+ self.freq_emb = nn.Embedding(num_embeddings=config.freq_size, embedding_dim=config.hidden_size)
+ self.layers = nn.ModuleList(
+ [TimesFmDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ if self.config.use_positional_embedding:
+ self.position_emb = TimesFmPositionalEmbedding(config=config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _forward_transform(
+ self, inputs: torch.Tensor, patched_pads: torch.Tensor
+ ) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
+ """Input is of shape [B, N, P]."""
+ mu, sigma = self._timesfm_masked_mean_std(inputs, patched_pads)
+ sigma = torch.clamp(sigma, min=self.config.tolerance)
+
+ # Normalize each patch
+ outputs = (inputs - mu[:, None, None]) / sigma[:, None, None]
+ outputs = torch.where(
+ torch.abs(inputs - self.config.pad_val) < self.config.tolerance,
+ torch.tensor(self.config.pad_val, dtype=outputs.dtype, device=outputs.device),
+ outputs,
+ )
+ return outputs, (mu, sigma)
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ past_values: torch.Tensor,
+ past_values_padding: torch.LongTensor,
+ freq: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TimesFmOutput:
+ r"""
+ past_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Past values of the time series that serves as input to the model.
+ past_values_padding (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ The padding indicator of the time series.
+ freq (`torch.LongTensor` of shape `(batch_size,)`):
+ Frequency indices for the time series data.
+ """
+ # Reshape into patches (using view for efficiency)
+ bsize = past_values.shape[0]
+ patched_inputs = past_values.view(bsize, -1, self.config.patch_length)
+ patched_pads = past_values_padding.view(bsize, -1, self.config.patch_length)
+
+ patched_inputs = torch.where(
+ torch.abs(patched_pads - 1.0) < self.config.tolerance,
+ torch.tensor(0.0, dtype=patched_inputs.dtype, device=patched_inputs.device),
+ patched_inputs,
+ )
+ patched_pads = torch.where(
+ torch.abs(patched_inputs - self.config.pad_val) < self.config.tolerance,
+ torch.tensor(1.0, dtype=patched_pads.dtype, device=patched_pads.device),
+ patched_pads,
+ )
+ patched_inputs, stats = self._forward_transform(patched_inputs, patched_pads)
+
+ # B x N x D
+ patched_inputs = patched_inputs * (1.0 - patched_pads)
+ concat_inputs = torch.cat([patched_inputs, patched_pads], dim=-1)
+ model_input = self.input_ff_layer(concat_inputs)
+
+ # A patch should not be padded even if there is at least one zero.
+ patched_padding = torch.min(patched_pads, dim=-1)[0] # Get the values from the min result
+ if self.config.use_positional_embedding:
+ pos_emb = self.position_emb(model_input.shape[1])
+ pos_emb = torch.concat([pos_emb] * model_input.shape[0], dim=0)
+ pos_emb = self._timesfm_shift_padded_seq(patched_padding, pos_emb)
+ model_input += pos_emb
+
+ f_emb = self.freq_emb(freq) # B x 1 x D
+ model_input += f_emb
+
+ # Convert paddings to attention mask and combine with causal mask
+ hidden_states = model_input
+ attention_mask = self._prepare_4d_attention_mask(
+ attention_mask=patched_padding,
+ sequence_length=hidden_states.shape[1],
+ dtype=hidden_states.dtype,
+ device=hidden_states.device,
+ is_causal=True,
+ )
+
+ for layer in self.layers[: self.config.num_hidden_layers]:
+ hidden_states = layer(
+ hidden_states,
+ attention_mask=attention_mask,
+ paddings=patched_padding,
+ **kwargs,
+ )
+
+ return TimesFmOutput(
+ last_hidden_state=hidden_states,
+ loc=stats[0],
+ scale=stats[1],
+ )
+
+ @staticmethod
+ def _prepare_4d_attention_mask(
+ attention_mask: torch.Tensor | None,
+ sequence_length: int,
+ dtype: torch.dtype,
+ device: torch.device,
+ is_causal: bool = True,
+ ) -> torch.Tensor | None:
+ """
+ Creates 4D attention mask and combines causal and padding masks if needed.
+
+ Args:
+ attention_mask: Optional tensor of shape (batch_size, seq_length) containing padding mask
+ sequence_length: Length of the sequence
+ dtype: Data type of the mask
+ device: Device of the mask
+ is_causal: Whether to apply causal masking
+
+ Returns:
+ 4D attention mask of shape (batch_size, 1, seq_length, seq_length)
+ """
+ # Get minimum value for the dtype
+ min_value = torch.finfo(dtype).min if dtype.is_floating_point else torch.iinfo(dtype).min
+
+ # Handle padding mask
+ if attention_mask is not None:
+ # Convert 2D padding mask to 4D attention mask
+ attention_mask = attention_mask.view(attention_mask.shape[0], 1, 1, -1)
+ attention_mask = attention_mask * min_value
+
+ # Create causal mask if needed
+ if is_causal:
+ causal_mask = torch.triu(
+ torch.ones((sequence_length, sequence_length), dtype=dtype, device=device) * min_value,
+ diagonal=1,
+ )
+ causal_mask = causal_mask.view(1, 1, sequence_length, sequence_length)
+
+ # Combine with padding mask if it exists
+ if attention_mask is not None:
+ attention_mask = torch.minimum(attention_mask, causal_mask)
+ else:
+ attention_mask = causal_mask
+
+ return attention_mask
+
+ @staticmethod
+ def _timesfm_masked_mean_std(inputs: torch.Tensor, padding: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+ """Calculates mean and standard deviation of `inputs` across axis 1.
+
+ It excludes values where `padding` is 1.
+
+ Args:
+ inputs: A PyTorch tensor of shape [b, n, p].
+ padding: A PyTorch tensor of shape [b, n, p] with values 0 or 1.
+
+ Returns:
+ A tuple containing the mean and standard deviation.
+ We return the statistics of the first patch with more than three non-padded values.
+ """
+
+ # Selecting the first patch with more than 3 unpadded values.
+ def _get_patch_index(arr: torch.Tensor):
+ indices = torch.argmax((arr >= 3).to(torch.int32), dim=1)
+ row_sum = (arr >= 3).to(torch.int32).sum(dim=1)
+ return torch.where(row_sum == 0, arr.shape[1] - 1, indices)
+
+ pad_sum = torch.sum(1 - padding, dim=2)
+ patch_indices = _get_patch_index(pad_sum)
+ bidxs = torch.arange(inputs.shape[0])
+
+ arr = inputs[bidxs, patch_indices, :]
+ pad = padding[bidxs, patch_indices, :]
+
+ # Create a mask where padding is 0
+ mask = 1 - pad
+
+ # Calculate the number of valid elements
+ num_valid_elements = torch.sum(mask, dim=1)
+ num_valid_elements = torch.clamp(num_valid_elements, min=1.0)
+
+ # Calculate the masked sum and mean
+ masked_sum = torch.sum(arr * mask, dim=1)
+ masked_mean = masked_sum / num_valid_elements # [b]
+
+ # Calculate the masked variance using centered values
+ masked_centered_arr = (arr - masked_mean.unsqueeze(-1)) * mask
+ masked_var = torch.sum(masked_centered_arr**2, dim=1) / num_valid_elements
+ masked_var = torch.clamp(masked_var, min=0.0)
+ masked_std = torch.sqrt(masked_var)
+
+ return masked_mean, masked_std
+
+ @staticmethod
+ def _timesfm_shift_padded_seq(mask: torch.Tensor, seq: torch.Tensor) -> torch.Tensor:
+ """Shifts rows of seq based on the first 0 in each row of the mask.
+
+ Args:
+ mask: mask tensor of shape [B, N]
+ seq: seq tensor of shape [B, N, P]
+
+ Returns:
+ The shifted sequence.
+ """
+ batch_size, num_seq, feature_dim = seq.shape
+
+ new_mask: torch.BoolTensor = mask == 0
+
+ # Use argmax to find the first True value in each row
+ indices = new_mask.to(torch.int32).argmax(dim=1)
+
+ # Handle rows with all zeros
+ indices[~new_mask.any(dim=1)] = -1
+
+ # Create index ranges for each sequence in the batch
+ idx_range = torch.arange(num_seq, device=seq.device).view(1, -1, 1).expand(batch_size, -1, feature_dim)
+
+ # Calculate shifted indices for each element in each sequence
+ shifted_idx = (idx_range - indices[:, None, None]) % num_seq
+
+ # Gather values from seq using shifted indices
+ shifted_seq = seq.gather(1, shifted_idx)
+
+ return shifted_seq
+
+
+class TimesFmModelForPrediction(TimesFmPreTrainedModel):
+ """TimesFM model for quantile and mean prediction."""
+
+ def __init__(self, config: TimesFmConfig):
+ super().__init__(config)
+
+ self.config = config
+ self.context_len = config.context_length
+ self.horizon_len = config.horizon_length
+
+ self.decoder = TimesFmModel(config)
+
+ # quantile and mean output
+ self.horizon_ff_layer = TimesFmResidualBlock(
+ input_dims=config.hidden_size,
+ output_dims=config.horizon_length * (1 + len(config.quantiles)),
+ hidden_dims=config.intermediate_size,
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _preprocess(
+ self, inputs: Sequence[torch.Tensor], freq: Sequence[int] | None = None, context_len: int | None = None
+ ) -> tuple[torch.Tensor, ...]:
+ """Pad/truncate input time series to `context_len` and build a padding mask.
+
+ Args:
+ inputs: A list of 1d Tensors. Each Tensor is the context time series of a single forecast task.
+ freq: Optional list of frequencies (returned as a tensor when provided).
+ context_len: Optional context length override (defaults to `self.context_len`).
+
+ Returns:
+ Tuple of (padded_inputs, padding_mask) and optionally a freq tensor.
+ """
+ if context_len is None:
+ context_len = self.context_len
+
+ input_ts, input_padding = [], []
+
+ for ts in inputs:
+ input_len = ts.shape[0]
+ padding = torch.zeros(input_len + self.horizon_len, dtype=ts.dtype, device=ts.device)
+ if input_len < context_len:
+ num_front_pad = context_len - input_len
+ ts = torch.cat([torch.zeros(num_front_pad, dtype=ts.dtype, device=ts.device), ts], dim=0)
+ padding = torch.cat([torch.ones(num_front_pad, dtype=ts.dtype, device=padding.device), padding], dim=0)
+ elif input_len > context_len:
+ ts = ts[-context_len:]
+ padding = padding[-(context_len + self.horizon_len) :]
+
+ input_ts.append(ts)
+ input_padding.append(padding)
+
+ result = (torch.stack(input_ts, dim=0), torch.stack(input_padding, dim=0))
+ if freq is not None:
+ result = result + (torch.tensor(freq[: len(inputs)], dtype=torch.int32).reshape(-1, 1),)
+ return result
+
+ def _postprocess_output(
+ self, model_output: torch.Tensor, stats: tuple[torch.Tensor, torch.Tensor]
+ ) -> torch.Tensor:
+ """Postprocess output of stacked transformer."""
+
+ # B x N x (H.Q)
+ output_ts = self.horizon_ff_layer(model_output)
+
+ # Reshape using view
+ b, n, _ = output_ts.shape
+ output_ts = output_ts.view(b, n, self.config.horizon_length, len(self.config.quantiles) + 1)
+
+ mu, sigma = stats
+ return output_ts * sigma[:, None, None, None] + mu[:, None, None, None]
+
+ def _quantile_loss(self, predictions: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
+ losses = []
+ for i, q in enumerate(self.config.quantiles):
+ errors = targets - predictions[..., i]
+ loss = torch.max((q - 1) * errors, q * errors)
+ losses.append(loss.mean())
+ return torch.stack(losses).mean()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ past_values: Sequence[torch.Tensor],
+ freq: Sequence[torch.Tensor | int] | None = None,
+ window_size: int | None = None,
+ future_values: torch.Tensor | None = None,
+ forecast_context_len: int | None = None,
+ return_forecast_on_context: bool = False,
+ truncate_negative: bool = False,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TimesFmOutputForPrediction:
+ r"""
+ past_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Past values of the time series that serves as input to the model.
+ freq (`torch.LongTensor` of shape `(batch_size,)`):
+ Frequency indices for the time series data.
+ window_size (`int`, *optional*):
+ Window size of trend + residual decomposition. If None then we do not do decomposition.
+ future_values (`torch.Tensor`, *optional*):
+ Optional future time series values to be used for loss computation.
+ forecast_context_len (`int`, *optional*):
+ Optional max context length.
+ return_forecast_on_context (`bool`, *optional*):
+ True to return the forecast on the context when available, i.e. after the first input patch.
+ truncate_negative (`bool`, *optional*):
+ Truncate to only non-negative values if any of the contexts have non-negative values,
+ otherwise do nothing.
+
+ Example:
+
+ ```python
+ >>> from transformers import TimesFmModelForPrediction
+
+ >>> model = TimesFmModelForPrediction.from_pretrained("google/timesfm-2.0-500m-pytorch")
+
+ >>> forecast_input = [torch.linspace(0, 20, 100).sin(), torch.linspace(0, 20, 200).sin(), torch.linspace(0, 20, 400).sin()]
+ >>> frequency_input = torch.tensor([0, 1, 2], dtype=torch.long)
+
+ >>> # Generate
+ >>> with torch.no_grad():
+ >>> outputs = model(past_values=forecast_input, freq=frequency_input, return_dict=True)
+ >>> point_forecast_conv = outputs.mean_predictions
+ >>> quantile_forecast_conv = outputs.full_predictions
+ ```
+ """
+ if forecast_context_len is None:
+ fcontext_len = self.context_len
+ else:
+ fcontext_len = forecast_context_len
+
+ device = past_values[0].device
+
+ inputs = [ts[-fcontext_len:] for ts in past_values]
+ inp_min = torch.min(torch.stack([torch.min(ts) for ts in inputs]))
+
+ if window_size is not None:
+ new_inputs = []
+ new_freqs = []
+ for i, ts in enumerate(inputs):
+ new_inputs.extend(self._timesfm_moving_average(ts, window_size))
+ if freq is not None:
+ new_freqs.extend([freq[i]] * 2)
+ inputs = new_inputs
+ if freq is not None:
+ freq = new_freqs
+
+ if freq is None:
+ logger.info("No frequency provided via `freq`. Default to high (0).")
+ freq = [0] * len(inputs)
+
+ input_ts, input_padding, inp_freq = self._preprocess(inputs, freq)
+ input_ts = input_ts.to(device)
+ input_padding = input_padding.to(device)
+ inp_freq = inp_freq.to(device)
+
+ final_out = input_ts
+ context_len = final_out.shape[1]
+ full_outputs = []
+
+ if input_padding.shape[1] != final_out.shape[1] + self.horizon_len:
+ raise ValueError(
+ "Length of paddings must match length of input + horizon_len:"
+ f" {input_padding.shape[1]} != {final_out.shape[1]} + {self.horizon_len}"
+ )
+ output_patch_len = self.config.horizon_length
+
+ num_decode_patches = (self.horizon_len + output_patch_len - 1) // output_patch_len
+ for step_index in range(num_decode_patches):
+ current_padding = input_padding[:, 0 : final_out.shape[1]]
+ input_ts = final_out[:, -fcontext_len:]
+ input_padding = current_padding[:, -fcontext_len:]
+ decoder_output: TimesFmOutput = self.decoder(
+ past_values=input_ts,
+ past_values_padding=input_padding,
+ freq=inp_freq,
+ **kwargs,
+ )
+ fprop_outputs = self._postprocess_output(
+ decoder_output.last_hidden_state,
+ (decoder_output.loc, decoder_output.scale),
+ )
+
+ if return_forecast_on_context and step_index == 0:
+ new_full_ts = fprop_outputs[:, :-1, : self.config.patch_length, :]
+ new_full_ts = new_full_ts.reshape(new_full_ts.size(0), -1, new_full_ts.size(3))
+ full_outputs.append(new_full_ts)
+
+ new_ts = fprop_outputs[:, -1, :output_patch_len, 0]
+ new_full_ts = fprop_outputs[:, -1, :output_patch_len, :]
+ full_outputs.append(new_full_ts)
+ final_out = torch.concatenate([final_out, new_ts], axis=-1)
+
+ if return_forecast_on_context:
+ full_outputs = torch.concatenate(full_outputs, axis=1)[
+ :, : (context_len - self.config.patch_length + self.horizon_len), :
+ ]
+ else:
+ full_outputs = torch.concatenate(full_outputs, axis=1)[:, 0 : self.horizon_len, :]
+
+ mean_outputs = full_outputs[:, :, 0]
+ if window_size is not None:
+ mean_outputs = mean_outputs[0::2, ...] + mean_outputs[1::2, ...]
+ full_outputs = full_outputs[0::2, ...] + full_outputs[1::2, ...]
+ if inp_min >= 0 and truncate_negative:
+ mean_outputs = torch.maximum(mean_outputs, 0.0)
+ full_outputs = torch.maximum(full_outputs, 0.0)
+
+ loss = None
+ if future_values is not None:
+ mse_loss = F.mse_loss(mean_outputs, future_values)
+ quantile_loss = self._quantile_loss(full_outputs[:, :, 1:], future_values)
+ loss = mse_loss + quantile_loss
+
+ return TimesFmOutputForPrediction(
+ last_hidden_state=decoder_output.last_hidden_state,
+ attentions=decoder_output.attentions,
+ hidden_states=decoder_output.hidden_states,
+ mean_predictions=mean_outputs,
+ full_predictions=full_outputs,
+ loss=loss,
+ )
+
+ @staticmethod
+ def _timesfm_moving_average(arr: torch.Tensor, window_size: int) -> list[torch.Tensor]:
+ """Calculates the moving average using PyTorch's convolution function."""
+ # Pad with zeros to handle initial window positions
+ arr_padded = F.pad(arr, (window_size - 1, 0), "constant", 0)
+ # Create a convolution kernel
+ kernel = torch.ones(window_size, dtype=arr.dtype, device=arr.device) / window_size
+ # Apply convolution to calculate the moving average
+ smoothed_arr = F.conv1d(arr_padded.view(1, 1, -1), kernel.view(1, 1, -1)).squeeze()
+ return [smoothed_arr, arr - smoothed_arr]
+
+
+__all__ = ["TimesFmModelForPrediction", "TimesFmPreTrainedModel", "TimesFmModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm2_5/__init__.py b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..24193c00a83ee83ab2444fc285396b00a7cbd041
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2026 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_timesfm2_5 import *
+ from .modeling_timesfm2_5 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a7fc25f900b4fd2e326f39a29cc3c24559f22e5
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/configuration_timesfm2_5.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/configuration_timesfm2_5.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6a2b77ef63f3fd15eb62a2a686f36086d8343e09
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/configuration_timesfm2_5.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/modeling_timesfm2_5.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/modeling_timesfm2_5.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ad770782a20fab0158b1e81a43dab9f16d6aa0e9
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/modeling_timesfm2_5.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/modular_timesfm2_5.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/modular_timesfm2_5.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7dc4c4488c6a80c74f1c26d7b7edee1bf63d18e5
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesfm2_5/__pycache__/modular_timesfm2_5.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm2_5/configuration_timesfm2_5.py b/lib/python3.11/site-packages/transformers/models/timesfm2_5/configuration_timesfm2_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..98ae54dc9e0fddf6e17dda1ccadb3ca9388d7e58
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesfm2_5/configuration_timesfm2_5.py
@@ -0,0 +1,94 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/timesfm2_5/modular_timesfm2_5.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_timesfm2_5.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...modeling_rope_utils import RopeParameters
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="google/timesfm-2.5-200m-transformers")
+@strict
+class TimesFm2_5Config(PreTrainedConfig):
+ r"""
+ patch_length (`int`, *optional*, defaults to 32):
+ The length of one patch in the input sequence.
+ context_length (`int`, *optional*, defaults to 16384):
+ The length of the input context.
+ horizon_length (`int`, *optional*, defaults to 128):
+ The length of the prediction horizon.
+ quantiles (`list[float]`, *optional*, defaults to `[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]`):
+ The quantiles to predict.
+ output_quantile_len (`int`, *optional*, defaults to 1024):
+ Length of the quantile output projection dimension.
+ decode_index (`int`, *optional*, defaults to 5):
+ Index into the quantile dimension used to extract the point (median) forecast.
+ use_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use bias in MLP and transformer linear layers.
+ use_continuous_quantile_head (`bool`, *optional*, defaults to `True`):
+ Whether to use the continuous quantile head for non-median quantile predictions.
+ force_flip_invariance (`bool`, *optional*, defaults to `True`):
+ Whether to apply flip-invariance averaging during forecasting.
+ infer_is_positive (`bool`, *optional*, defaults to `True`):
+ Whether to clamp forecasts to non-negative values when the input minimum is non-negative.
+
+ Example:
+
+ ```python
+ >>> from transformers import TimesFm2_5Config, TimesFm2_5ModelForPrediction
+
+ >>> configuration = TimesFm2_5Config()
+ >>> model = TimesFm2_5ModelForPrediction(configuration)
+ >>> configuration = model.config
+ ```
+ """
+
+ model_type = "timesfm2_5"
+ keys_to_ignore_at_inference = []
+ is_encoder_decoder = False
+
+ patch_length: int = 32
+
+ context_length: int = 16384
+ horizon_length: int = 128
+ num_hidden_layers: int = 20
+ hidden_size: int = 1280
+ intermediate_size: int = 1280
+ head_dim: int = 80
+ num_attention_heads: int = 16
+ rms_norm_eps: float = 1e-6
+ quantiles: list[float] | tuple[float, ...] = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9)
+ attention_dropout: float | int = 0.0
+ initializer_range: float = 0.02
+ num_key_value_heads: int = 16
+ attention_bias: bool = False
+ output_quantile_len: int = 1024
+ decode_index: int = 5
+ use_bias: bool = False
+ activation: str = "swish"
+ use_continuous_quantile_head: bool = True
+ force_flip_invariance: bool = True
+ infer_is_positive: bool = True
+ max_position_embeddings: int = 16384
+ rope_parameters: RopeParameters | dict | None = None
+
+
+__all__ = ["TimesFm2_5Config"]
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm2_5/modeling_timesfm2_5.py b/lib/python3.11/site-packages/transformers/models/timesfm2_5/modeling_timesfm2_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac244a85a5bb494def1897a9997e07d02b869955
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesfm2_5/modeling_timesfm2_5.py
@@ -0,0 +1,921 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/timesfm2_5/modular_timesfm2_5.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_timesfm2_5.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 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 math
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from typing import Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...integrations import use_kernel_forward_from_hub, use_kernel_func_from_hub, use_kernelized_func
+from ...masking_utils import create_causal_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput
+from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ...utils.generic import maybe_autocast, merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_timesfm2_5 import TimesFm2_5Config
+
+
+@auto_docstring
+@dataclass
+class TimesFm2_5Output(BaseModelOutput):
+ r"""
+ context_mu (`torch.Tensor` of shape `(batch_size, num_patches)`):
+ Running means computed per input patch during normalization.
+ context_sigma (`torch.Tensor` of shape `(batch_size, num_patches)`):
+ Running standard deviations computed per input patch during normalization.
+ """
+
+ loc: torch.Tensor | None = None
+ scale: torch.Tensor | None = None
+
+ context_mu: torch.Tensor | None = None
+ context_sigma: torch.Tensor | None = None
+
+
+@auto_docstring
+@dataclass
+class TimesFm2_5OutputForPrediction(BaseModelOutput):
+ r"""
+ mean_predictions (`torch.Tensor` of shape `(batch_size, horizon_length)`):
+ Deterministic forecasts after denormalization.
+ full_predictions (`torch.Tensor` of shape `(batch_size, horizon_length, quantiles)`):
+ Quantile forecasts including the median after denormalization.
+ loss (`torch.Tensor` of shape `(1,)`, *optional*, returned when `future_values` is provided):
+ Training loss combining MSE and quantile losses when targets are supplied.
+ """
+
+ mean_predictions: torch.Tensor | None = None
+ full_predictions: torch.Tensor | None = None
+ loss: torch.Tensor | float | None = None
+
+
+class TimesFm2_5MLP(nn.Module):
+ def __init__(self, config: TimesFm2_5Config):
+ super().__init__()
+ self.config = config
+ self.activation_fn = ACT2FN[config.activation]
+ self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size, bias=config.use_bias)
+ self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size, bias=config.use_bias)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.fc1(hidden_states)
+ hidden_states = self.activation_fn(hidden_states)
+ hidden_states = self.fc2(hidden_states)
+ return hidden_states
+
+
+class TimesFm2_5ResidualBlock(nn.Module):
+ """[`TimesFmResidualBlock`] variant with configurable `use_bias` and `activation`."""
+
+ def __init__(self, config, input_dims: int, hidden_dims: int, output_dims: int, use_bias: bool | None = None):
+ super().__init__()
+ self.input_dims = input_dims
+ self.hidden_dims = hidden_dims
+ self.output_dims = output_dims
+ self.input_layer = nn.Linear(input_dims, hidden_dims, bias=use_bias)
+ self.activation = ACT2FN[config.activation]
+ self.output_layer = nn.Linear(hidden_dims, output_dims, bias=use_bias)
+ self.residual_layer = nn.Linear(input_dims, output_dims, bias=use_bias)
+ use_bias = use_bias if use_bias is not None else config.use_bias
+
+ def forward(self, x):
+ # Align activations to block parameter dtype for mixed precision stability
+ x = x.to(self.input_layer.weight.dtype)
+ hidden = self.input_layer(x)
+ hidden = self.activation(hidden)
+ output = self.output_layer(hidden)
+ residual = self.residual_layer(x)
+ return output + residual
+
+
+@use_kernel_forward_from_hub("RMSNorm")
+class TimesFm2_5RMSNorm(nn.Module):
+ def __init__(self, hidden_size, eps: float = 1e-6) -> None:
+ """
+ TimesFm2_5RMSNorm is equivalent to T5LayerNorm
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ input_dtype = hidden_states.dtype
+ hidden_states = hidden_states.to(torch.float32)
+ variance = hidden_states.pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+ return self.weight * hidden_states.to(input_dtype)
+
+ def extra_repr(self):
+ return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"
+
+
+class TimesFm2_5RotaryEmbedding(nn.Module):
+ inv_freq: torch.Tensor # fix linting for `register_buffer`
+
+ def __init__(self, config: TimesFm2_5Config, device=None):
+ super().__init__()
+ self.max_seq_len_cached = config.max_position_embeddings
+ self.original_max_seq_len = config.max_position_embeddings
+
+ self.config = config
+
+ self.rope_type = self.config.rope_parameters["rope_type"]
+ rope_init_fn: Callable = self.compute_default_rope_parameters
+ if self.rope_type != "default":
+ rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
+ inv_freq, self.attention_scaling = rope_init_fn(self.config, device)
+
+ self.register_buffer("inv_freq", inv_freq, persistent=False)
+ self.register_buffer("original_inv_freq", inv_freq.clone(), persistent=False)
+
+ @staticmethod
+ def compute_default_rope_parameters(
+ config: TimesFm2_5Config | None = None,
+ device: Optional["torch.device"] = None,
+ seq_len: int | None = None,
+ ) -> tuple["torch.Tensor", float]:
+ """
+ Computes the inverse frequencies according to the original RoPE implementation
+ Args:
+ config ([`~transformers.PreTrainedConfig`]):
+ The model configuration.
+ device (`torch.device`):
+ The device to use for initialization of the inverse frequencies.
+ seq_len (`int`, *optional*):
+ The current sequence length. Unused for this type of RoPE.
+ Returns:
+ Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
+ post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
+ """
+ base = config.rope_parameters["rope_theta"]
+ dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
+
+ attention_factor = 1.0 # Unused in this type of RoPE
+
+ # Compute the inverse frequencies
+ inv_freq = 1.0 / (
+ base ** (torch.arange(0, dim, 2, dtype=torch.int64).to(device=device, dtype=torch.float) / dim)
+ )
+ return inv_freq, attention_factor
+
+ @torch.no_grad()
+ @dynamic_rope_update # power user: used with advanced RoPE types (e.g. dynamic rope)
+ def forward(self, x, position_ids):
+ inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)
+ position_ids_expanded = position_ids[:, None, :].float()
+
+ device_type = x.device.type if isinstance(x.device.type, str) and x.device.type != "mps" else "cpu"
+ with maybe_autocast(device_type=device_type, enabled=False): # Force float32
+ freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2)
+ emb = torch.cat((freqs, freqs), dim=-1)
+ cos = emb.cos() * self.attention_scaling
+ sin = emb.sin() * self.attention_scaling
+
+ return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+def rotate_half(x):
+ """Rotates half the hidden dims of the input."""
+ x1 = x[..., : x.shape[-1] // 2]
+ x2 = x[..., x.shape[-1] // 2 :]
+ return torch.cat((-x2, x1), dim=-1)
+
+
+@use_kernel_func_from_hub("rotary_pos_emb")
+def apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1):
+ """Applies Rotary Position Embedding to the query and key tensors.
+
+ Args:
+ q (`torch.Tensor`): The query tensor.
+ k (`torch.Tensor`): The key tensor.
+ cos (`torch.Tensor`): The cosine part of the rotary embedding.
+ sin (`torch.Tensor`): The sine part of the rotary embedding.
+ unsqueeze_dim (`int`, *optional*, defaults to 1):
+ The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+ sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+ that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+ k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+ cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+ the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+ Returns:
+ `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+ """
+ cos = cos.unsqueeze(unsqueeze_dim)
+ sin = sin.unsqueeze(unsqueeze_dim)
+ q_embed = (q * cos) + (rotate_half(q) * sin)
+ k_embed = (k * cos) + (rotate_half(k) * sin)
+ return q_embed, k_embed
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+ """
+ This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+ num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+ """
+ batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+ if n_rep == 1:
+ return hidden_states
+ hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+ return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float,
+ dropout: float = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ key_states = repeat_kv(key, module.num_key_value_groups)
+ value_states = repeat_kv(value, module.num_key_value_groups)
+
+ attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value_states)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+@use_kernelized_func(apply_rotary_pos_emb)
+class TimesFm2_5Attention(nn.Module):
+ """TimesFM 2.5 attention with learnable per-dimension query scaling."""
+
+ def __init__(self, config: TimesFm2_5Config, layer_idx: int):
+ super().__init__()
+ self.config = config
+ self.layer_idx = layer_idx
+ self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+ self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
+ self.scaling = nn.Parameter(torch.empty((self.head_dim,)))
+ self.attention_dropout = config.attention_dropout
+ self.is_causal = True
+
+ self.q_proj = nn.Linear(
+ config.hidden_size, config.num_attention_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.k_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.v_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.o_proj = nn.Linear(
+ config.num_attention_heads * self.head_dim, config.hidden_size, bias=config.attention_bias
+ )
+ self.q_norm = TimesFm2_5RMSNorm(self.head_dim, config.rms_norm_eps)
+ self.k_norm = TimesFm2_5RMSNorm(self.head_dim, config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ attention_mask: torch.Tensor | None,
+ past_key_values=None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ query_states = self.q_norm(query_states)
+ key_states = self.k_norm(key_states)
+
+ scale = F.softplus(self.scaling).mul(1.442695041 / math.sqrt(self.head_dim))
+ query_states = query_states * scale[None, None, None, :]
+
+ if past_key_values is not None:
+ key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=self.attention_dropout if self.training else 0.0,
+ # scaling=1.0 because per-dimension learnable scaling is already applied to query_states above
+ scaling=1.0,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+class TimesFm2_5DecoderLayer(GradientCheckpointingLayer):
+ """TimesFM 2.5 Transformer decoder layer with pre/post RMS normalization and no KV cache."""
+
+ def __init__(self, config: TimesFm2_5Config, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+
+ self.self_attn = TimesFm2_5Attention(config=config, layer_idx=layer_idx)
+
+ self.mlp = TimesFm2_5MLP(config)
+ self.input_layernorm = TimesFm2_5RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_attention_layernorm = TimesFm2_5RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.pre_feedforward_layernorm = TimesFm2_5RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_feedforward_layernorm = TimesFm2_5RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ residual = hidden_states
+ hidden_states = self.input_layernorm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+ hidden_states = self.post_attention_layernorm(hidden_states) + residual
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.post_feedforward_layernorm(hidden_states) + residual
+
+ return hidden_states
+
+
+class TimesFm2_5PositionalEmbedding(nn.Module):
+ """Generates position embedding for a given 1-d sequence."""
+
+ def __init__(self, config: TimesFm2_5Config):
+ super().__init__()
+ min_timescale = config.min_timescale
+ max_timescale = config.max_timescale
+ self.min_timescale, self.max_timescale = min_timescale, max_timescale
+ self.embedding_dims = config.hidden_size
+
+ num_timescales = self.embedding_dims // 2
+ log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / max(num_timescales - 1, 1)
+ self.register_buffer(
+ "inv_timescales",
+ min_timescale * torch.exp(torch.arange(num_timescales, dtype=torch.float32) * -log_timescale_increment),
+ )
+
+ def forward(self, seq_length=None, position=None):
+ """Generates a Tensor of sinusoids with different frequencies.
+
+ Args:
+ seq_length: an optional Python int defining the output sequence length.
+ if the `position` argument is specified.
+ position: [B, seq_length], optional position for each token in the
+ sequence, only required when the sequence is packed.
+
+ Returns:
+ [B, seqlen, D] if `position` is specified, else [1, seqlen, D]
+ """
+ if position is None and seq_length is None:
+ raise ValueError("Either position or seq_length must be provided")
+
+ if position is None:
+ # [1, seqlen]
+ position = torch.arange(seq_length, dtype=torch.float32, device=self.inv_timescales.device).unsqueeze(0)
+ elif position.ndim != 2:
+ raise ValueError(f"position must be 2-dimensional, got shape {position.shape}")
+
+ scaled_time = position.view(*position.shape, 1) * self.inv_timescales.view(1, 1, -1)
+ signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], dim=2)
+
+ # Padding to ensure correct embedding dimension
+ signal = F.pad(signal, (0, 0, 0, self.embedding_dims % 2))
+ return signal
+
+
+@auto_docstring
+class TimesFm2_5PreTrainedModel(PreTrainedModel):
+ config: TimesFm2_5Config
+ base_model_prefix = "model"
+ _no_split_modules = ["TimesFm2_5DecoderLayer"]
+ main_input_name = "past_values"
+ input_modalities = ("time",)
+ _supports_sdpa = True
+ _can_record_outputs = {
+ "hidden_states": TimesFm2_5DecoderLayer,
+ "attentions": TimesFm2_5Attention,
+ }
+ config_class = TimesFm2_5Config
+ _supports_flash_attn = True
+ _supports_flex_attn = True
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, TimesFm2_5Attention):
+ # Initialize scaling parameter
+ init.ones_(module.scaling)
+ elif isinstance(module, TimesFm2_5PositionalEmbedding):
+ num_timescales = module.embedding_dims // 2
+ max_timescale, min_timescale = module.max_timescale, module.min_timescale
+ log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / max(
+ num_timescales - 1, 1
+ )
+ init.copy_(
+ module.inv_timescales,
+ min_timescale
+ * torch.exp(torch.arange(num_timescales, dtype=torch.float32) * -log_timescale_increment),
+ )
+
+
+class TimesFm2_5Model(TimesFm2_5PreTrainedModel):
+ def __init__(self, config: TimesFm2_5Config):
+ super().__init__(config)
+ self.config = config
+ self.tolerance = 1e-6
+
+ self.input_ff_layer = TimesFm2_5ResidualBlock(
+ config,
+ input_dims=2 * config.patch_length,
+ hidden_dims=config.hidden_size,
+ output_dims=config.hidden_size,
+ use_bias=True,
+ )
+
+ self.layers = nn.ModuleList(
+ [TimesFm2_5DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.rotary_emb = TimesFm2_5RotaryEmbedding(config)
+ self.gradient_checkpointing = False
+
+ self.post_init()
+
+ def _revin(
+ self,
+ hidden_states: torch.Tensor,
+ loc: torch.Tensor,
+ scale: torch.Tensor,
+ reverse: bool = False,
+ mask: torch.Tensor | None = None,
+ ) -> torch.Tensor:
+ """Reversible instance normalization (RevIN).
+
+ Normalizes or denormalizes `hidden_states` using the provided location and scale statistics.
+ When `mask` is provided during normalization (reverse=False), masked positions are zeroed out.
+ """
+ if len(loc.shape) == len(hidden_states.shape) - 1:
+ loc = loc[..., None]
+ scale = scale[..., None]
+ elif len(loc.shape) == len(hidden_states.shape) - 2:
+ loc = loc[..., None, None]
+ scale = scale[..., None, None]
+
+ loc = loc.to(hidden_states.device)
+ scale = scale.to(hidden_states.device)
+ safe_scale = torch.where(scale < self.tolerance, torch.ones_like(scale), scale)
+
+ if reverse:
+ return hidden_states * scale + loc
+
+ normed = (hidden_states - loc) / safe_scale
+ if mask is not None:
+ normed = torch.where(mask, torch.zeros_like(normed), normed)
+ return normed
+
+ @staticmethod
+ def _update_running_stats(
+ count: torch.Tensor,
+ mean: torch.Tensor,
+ std: torch.Tensor,
+ new_values: torch.Tensor,
+ mask: torch.Tensor,
+ ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """Update running mean/std using Welford's online algorithm.
+
+ Combines existing statistics (`count`, `mean`, `std`) with a new batch of values,
+ respecting the boolean `mask` (True = masked/invalid).
+ """
+ is_valid = (~mask).to(new_values.dtype)
+ inc_count = is_valid.sum(dim=-1)
+
+ inc_count_safe = torch.where(inc_count == 0, torch.ones_like(inc_count), inc_count)
+ inc_mean = (new_values * is_valid).sum(dim=-1) / inc_count_safe
+ inc_mean = torch.where(inc_count == 0, torch.zeros_like(inc_mean), inc_mean)
+
+ centered = new_values - inc_mean.unsqueeze(-1)
+ inc_var = ((centered * is_valid) ** 2).sum(dim=-1) / inc_count_safe
+ inc_var = torch.where(inc_count == 0, torch.zeros_like(inc_var), inc_var)
+ inc_std = torch.sqrt(torch.clamp(inc_var, min=0.0))
+
+ new_count = count + inc_count
+ new_count_safe = torch.where(new_count == 0, torch.ones_like(new_count), new_count)
+
+ new_mean = (count * mean + inc_mean * inc_count) / new_count_safe
+ new_mean = torch.where(new_count == 0, torch.zeros_like(new_mean), new_mean)
+
+ term1 = count * std.pow(2)
+ term2 = inc_count * inc_std.pow(2)
+ term3 = count * (mean - new_mean).pow(2)
+ term4 = inc_count * (inc_mean - new_mean).pow(2)
+
+ new_var = (term1 + term2 + term3 + term4) / new_count_safe
+ new_var = torch.where(new_count == 0, torch.zeros_like(new_var), new_var)
+ new_std = torch.sqrt(torch.clamp(new_var, min=0.0))
+
+ return new_count, new_mean, new_std
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ past_values: torch.Tensor,
+ past_values_padding: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TimesFm2_5Output:
+ r"""
+ past_values (`torch.Tensor` of shape `(batch_size, sequence_length)`):
+ Past values of the time series used as input to the model.
+ past_values_padding (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Padding mask for the input. `1` indicates padded (masked) time steps, `0` indicates valid values.
+ """
+ batch_size, seq_len = past_values.shape
+ patch_len = self.config.patch_length
+
+ if past_values_padding is None:
+ past_values_padding = torch.zeros_like(past_values, dtype=torch.long)
+
+ patched_inputs = past_values.view(batch_size, -1, patch_len)
+ patched_masks = past_values_padding[:, :seq_len].view(batch_size, -1, patch_len)
+ patched_masks_bool = patched_masks >= 0.5
+
+ count = past_values.new_zeros(batch_size)
+ mean = past_values.new_zeros(batch_size)
+ std = past_values.new_zeros(batch_size)
+ mean_history: list[torch.Tensor] = []
+ std_history: list[torch.Tensor] = []
+
+ for i in range(patched_inputs.shape[1]):
+ count, mean, std = self._update_running_stats(
+ count, mean, std, patched_inputs[:, i, :], patched_masks_bool[:, i, :]
+ )
+ mean_history.append(mean)
+ std_history.append(std)
+
+ if mean_history:
+ context_mu = torch.stack(mean_history, dim=1)
+ context_sigma = torch.stack(std_history, dim=1)
+ else:
+ context_mu = mean.unsqueeze(1)
+ context_sigma = std.unsqueeze(1)
+
+ normed_inputs = self._revin(patched_inputs, context_mu, context_sigma, reverse=False, mask=patched_masks_bool)
+
+ tokenizer_inputs = torch.cat(
+ [normed_inputs, patched_masks_bool.to(dtype=normed_inputs.dtype)],
+ dim=-1,
+ )
+ input_embeddings = self.input_ff_layer(tokenizer_inputs)
+
+ patch_padding = patched_masks_bool[..., -1]
+
+ sequence_length = input_embeddings.shape[1]
+ num_masked = patch_padding.to(torch.int32).sum(dim=-1, keepdim=True)
+ position_ids = torch.arange(sequence_length, device=input_embeddings.device).unsqueeze(0) - num_masked
+
+ padding_mask = (~patch_padding).to(torch.int64)
+ attention_mask = create_causal_mask(self.config, input_embeddings, padding_mask, past_key_values=None)
+ position_embeddings = self.rotary_emb(input_embeddings, position_ids)
+
+ hidden_states = input_embeddings
+
+ for layer in self.layers:
+ hidden_states = layer(
+ hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+
+ loc = context_mu[:, -1]
+ scale = torch.clamp(context_sigma[:, -1], min=self.tolerance)
+
+ return TimesFm2_5Output(
+ last_hidden_state=hidden_states,
+ loc=loc,
+ scale=scale,
+ context_mu=context_mu,
+ context_sigma=context_sigma,
+ )
+
+
+class TimesFm2_5ModelForPrediction(TimesFm2_5PreTrainedModel):
+ """TimesFm2_5 model for quantile and mean prediction."""
+
+ def __init__(self, config: TimesFm2_5Config):
+ super().__init__(config)
+ self.config = config
+ self.context_len = config.context_length
+ self.horizon_len = config.horizon_length
+
+ self.model = TimesFm2_5Model(config)
+
+ num_quantiles = len(config.quantiles) + 1
+ self.output_projection_point = TimesFm2_5ResidualBlock(
+ config,
+ input_dims=config.hidden_size,
+ hidden_dims=config.hidden_size,
+ output_dims=config.horizon_length * num_quantiles,
+ )
+ self.output_projection_quantiles = TimesFm2_5ResidualBlock(
+ config,
+ input_dims=config.hidden_size,
+ hidden_dims=config.hidden_size,
+ output_dims=config.output_quantile_len * num_quantiles,
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _preprocess(
+ self, inputs: Sequence[torch.Tensor], freq: Sequence[int] | None = None, context_len: int | None = None
+ ) -> tuple[torch.Tensor, ...]:
+ """Pad/truncate input time series to `context_len` and build a padding mask.
+
+ Args:
+ inputs: A list of 1d Tensors. Each Tensor is the context time series of a single forecast task.
+ freq: Optional list of frequencies (returned as a tensor when provided).
+ context_len: Optional context length override (defaults to `self.context_len`).
+
+ Returns:
+ Tuple of (padded_inputs, padding_mask) and optionally a freq tensor.
+ """
+ if context_len is None:
+ context_len = self.context_len
+
+ input_ts, input_padding = [], []
+
+ for ts in inputs:
+ input_len = ts.shape[0]
+ padding = torch.zeros(input_len + self.horizon_len, dtype=ts.dtype, device=ts.device)
+ if input_len < context_len:
+ num_front_pad = context_len - input_len
+ ts = torch.cat([torch.zeros(num_front_pad, dtype=ts.dtype, device=ts.device), ts], dim=0)
+ padding = torch.cat([torch.ones(num_front_pad, dtype=ts.dtype, device=padding.device), padding], dim=0)
+ elif input_len > context_len:
+ ts = ts[-context_len:]
+ padding = padding[-(context_len + self.horizon_len) :]
+
+ input_ts.append(ts)
+ input_padding.append(padding)
+
+ result = (torch.stack(input_ts, dim=0), torch.stack(input_padding, dim=0))
+ if freq is not None:
+ result = result + (torch.tensor(freq[: len(inputs)], dtype=torch.int32).reshape(-1, 1),)
+ return result
+
+ def _postprocess_output(
+ self, model_output: torch.Tensor, stats: tuple[torch.Tensor, torch.Tensor]
+ ) -> torch.Tensor:
+ """Postprocess output of stacked transformer."""
+
+ # B x N x (H.Q)
+ output_ts = self.horizon_ff_layer(model_output)
+
+ # Reshape using view
+ b, n, _ = output_ts.shape
+ output_ts = output_ts.view(b, n, self.config.horizon_length, len(self.config.quantiles) + 1)
+
+ mu, sigma = stats
+ return output_ts * sigma[:, None, None, None] + mu[:, None, None, None]
+
+ def _quantile_loss(self, predictions: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
+ losses = []
+ for i, q in enumerate(self.config.quantiles):
+ errors = targets - predictions[..., i]
+ loss = torch.max((q - 1) * errors, q * errors)
+ losses.append(loss.mean())
+ return torch.stack(losses).mean()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ past_values: Sequence[torch.Tensor],
+ window_size: int | None = None,
+ future_values: torch.Tensor | None = None,
+ forecast_context_len: int | None = None,
+ truncate_negative: bool | None = None,
+ force_flip_invariance: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TimesFm2_5OutputForPrediction:
+ r"""
+ past_values (`Sequence[torch.Tensor]`):
+ Past values of the time series that serves as input to the model. Each tensor is a 1D time series.
+ window_size (`int`, *optional*):
+ Window size of trend + residual decomposition. If `None`, decomposition is not applied.
+ future_values (`torch.Tensor`, *optional*):
+ Optional future values used to compute the loss.
+ forecast_context_len (`int`, *optional*):
+ Optional context length override used during forecasting.
+ truncate_negative (`bool`, *optional*):
+ Whether to clamp outputs to non-negative values. If `None`, defaults to `config.infer_is_positive`.
+ force_flip_invariance (`bool`, *optional*):
+ Whether to apply the flip-invariance combination. If `None`, defaults to
+ `config.force_flip_invariance`.
+ """
+ forecast_context_len = forecast_context_len or self.context_len
+ device = past_values[0].device
+
+ inputs = [ts[-forecast_context_len:] for ts in past_values]
+ input_min = torch.min(torch.stack([torch.min(ts) for ts in inputs]))
+
+ if window_size is not None:
+ new_inputs: list[torch.Tensor] = []
+ for ts in inputs:
+ new_inputs.extend(self._timesfm_moving_average(ts, window_size))
+ inputs = new_inputs
+
+ if truncate_negative is None:
+ truncate_negative = self.config.infer_is_positive
+ if force_flip_invariance is None:
+ force_flip_invariance = self.config.force_flip_invariance
+
+ input_ts, input_padding = self._preprocess(inputs, context_len=forecast_context_len)
+ input_ts = input_ts.to(device)
+ input_padding = input_padding.to(device)
+
+ mu_global = input_ts.mean(dim=1, keepdim=True)
+ sigma_global = input_ts.std(dim=1, keepdim=True)
+
+ normalized_ts = self.model._revin(input_ts, mu_global, sigma_global, reverse=False)
+
+ pf_outputs, quantile_spreads, model_outputs = self._decode_and_project(normalized_ts, input_padding, **kwargs)
+
+ if force_flip_invariance:
+ flipped_pf, flipped_qs, _ = self._decode_and_project(-normalized_ts, input_padding, **kwargs)
+
+ def _flip_quantiles(x: torch.Tensor) -> torch.Tensor:
+ return torch.cat([x[..., :1], torch.flip(x[..., 1:], dims=(-1,))], dim=-1)
+
+ pf_outputs = (pf_outputs - _flip_quantiles(flipped_pf)) / 2
+ quantile_spreads = (quantile_spreads - _flip_quantiles(flipped_qs)) / 2
+
+ horizon = min(self.horizon_len, pf_outputs.shape[1])
+ full_forecast = pf_outputs[:, :horizon, :].clone()
+
+ median_index = min(self.config.decode_index, full_forecast.shape[-1] - 1)
+ if self.config.use_continuous_quantile_head:
+ max_quantile_horizon = min(horizon, quantile_spreads.shape[1])
+ for idx, _ in enumerate(self.config.quantiles, start=1):
+ if idx == median_index or idx >= full_forecast.shape[-1]:
+ continue
+ full_forecast[:, :max_quantile_horizon, idx] = (
+ quantile_spreads[:, :max_quantile_horizon, idx]
+ - quantile_spreads[:, :max_quantile_horizon, median_index]
+ + full_forecast[:, :max_quantile_horizon, median_index]
+ )
+
+ full_predictions = self.model._revin(full_forecast, mu_global, sigma_global, reverse=True)
+ decode_index = min(self.config.decode_index, full_predictions.shape[-1] - 1)
+ mean_predictions = full_predictions[:, :, decode_index]
+
+ if window_size is not None:
+ mean_predictions = mean_predictions[0::2, ...] + mean_predictions[1::2, ...]
+ full_predictions = full_predictions[0::2, ...] + full_predictions[1::2, ...]
+
+ if truncate_negative:
+ zero = torch.zeros(1, device=mean_predictions.device, dtype=mean_predictions.dtype)
+ clamped_mean = torch.maximum(mean_predictions, zero)
+ clamped_full = torch.maximum(full_predictions, zero)
+ should_clamp = (input_min >= 0).to(mean_predictions.device)
+ mean_predictions = torch.where(should_clamp, clamped_mean, mean_predictions)
+ full_predictions = torch.where(should_clamp, clamped_full, full_predictions)
+
+ loss = None
+ if future_values is not None:
+ target_len = future_values.shape[1]
+ # Compute loss in normalized space for scale-invariant training.
+ # full_forecast is already in normalized space (before denormalization).
+ normalized_preds = full_forecast[:, :target_len]
+ normalized_targets = self.model._revin(future_values, mu_global, sigma_global, reverse=False)
+ normalized_mean_preds = normalized_preds[:, :, decode_index]
+ mse_loss = F.mse_loss(normalized_mean_preds, normalized_targets)
+ quantile_indices = [i for i in range(normalized_preds.shape[-1]) if i != decode_index]
+ if quantile_indices:
+ index_tensor = torch.tensor(quantile_indices, device=normalized_preds.device, dtype=torch.long)
+ quantile_tensor = torch.index_select(normalized_preds, dim=-1, index=index_tensor)
+ quantile_loss = self._quantile_loss(quantile_tensor, normalized_targets)
+ loss = mse_loss + quantile_loss
+ else:
+ loss = mse_loss
+
+ return TimesFm2_5OutputForPrediction(
+ last_hidden_state=model_outputs.last_hidden_state,
+ hidden_states=model_outputs.hidden_states,
+ attentions=model_outputs.attentions,
+ mean_predictions=mean_predictions,
+ full_predictions=full_predictions,
+ loss=loss,
+ )
+
+ @staticmethod
+ def _timesfm2_5_moving_average(arr: torch.Tensor, window_size: int) -> list[torch.Tensor]:
+ """Calculates the moving average using PyTorch's convolution function."""
+ # Pad with zeros to handle initial window positions
+ arr_padded = F.pad(arr, (window_size - 1, 0), "constant", 0)
+ # Create a convolution kernel
+ kernel = torch.ones(window_size, dtype=arr.dtype, device=arr.device) / window_size
+ # Apply convolution to calculate the moving average
+ smoothed_arr = F.conv1d(arr_padded.view(1, 1, -1), kernel.view(1, 1, -1)).squeeze()
+ return [smoothed_arr, arr - smoothed_arr]
+
+ def _decode_and_project(
+ self,
+ normalized_ts: torch.Tensor,
+ input_padding: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ """Run the decoder and project to point/quantile outputs.
+
+ Returns:
+ Tuple of (point_forecast, quantile_spreads), each of shape `(batch, length, num_quantiles)`.
+ """
+ model_outputs = self.model(
+ past_values=normalized_ts,
+ past_values_padding=input_padding,
+ **kwargs,
+ )
+
+ hidden_states = model_outputs.last_hidden_state
+ context_mu = model_outputs.context_mu
+ context_sigma = model_outputs.context_sigma
+
+ point_output = self.model._revin(
+ self.output_projection_point(hidden_states), context_mu, context_sigma, reverse=True
+ )
+ quantile_output = self.model._revin(
+ self.output_projection_quantiles(hidden_states), context_mu, context_sigma, reverse=True
+ )
+
+ batch_size, num_patches = point_output.shape[:2]
+ num_quantiles = len(self.config.quantiles) + 1
+
+ point_forecast = point_output.view(batch_size, num_patches, self.config.horizon_length, num_quantiles)[
+ :, -1, :, :
+ ]
+ quantile_spreads = quantile_output.view(
+ batch_size, num_patches, self.config.output_quantile_len, num_quantiles
+ )[:, -1, :, :]
+
+ # Ensure both outputs are on the same device for model parallelism
+ quantile_spreads = quantile_spreads.to(point_forecast.device)
+
+ return point_forecast, quantile_spreads, model_outputs
+
+
+__all__ = ["TimesFm2_5ModelForPrediction", "TimesFm2_5PreTrainedModel", "TimesFm2_5Model"]
diff --git a/lib/python3.11/site-packages/transformers/models/timesfm2_5/modular_timesfm2_5.py b/lib/python3.11/site-packages/transformers/models/timesfm2_5/modular_timesfm2_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..d460a81b764d6d63c1083b66eff1b4175ada4fa1
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesfm2_5/modular_timesfm2_5.py
@@ -0,0 +1,659 @@
+# Copyright 2026 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 math
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from huggingface_hub.dataclasses import strict
+
+from ...activations import ACT2FN
+from ...masking_utils import create_causal_mask
+from ...modeling_rope_utils import RopeParameters
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, logging
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from ..apertus.modeling_apertus import ApertusAttention
+from ..clip.modeling_clip import CLIPMLP
+from ..llama.modeling_llama import (
+ LlamaDecoderLayer,
+ LlamaRMSNorm,
+ LlamaRotaryEmbedding,
+ apply_rotary_pos_emb,
+ eager_attention_forward,
+)
+from ..timesfm.configuration_timesfm import TimesFmConfig
+from ..timesfm.modeling_timesfm import (
+ TimesFmModelForPrediction,
+ TimesFmOutput,
+ TimesFmOutputForPrediction,
+ TimesFmPreTrainedModel,
+ TimesFmResidualBlock,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="google/timesfm-2.5-200m-transformers")
+@strict
+class TimesFm2_5Config(TimesFmConfig):
+ r"""
+ patch_length (`int`, *optional*, defaults to 32):
+ The length of one patch in the input sequence.
+ context_length (`int`, *optional*, defaults to 16384):
+ The length of the input context.
+ horizon_length (`int`, *optional*, defaults to 128):
+ The length of the prediction horizon.
+ quantiles (`list[float]`, *optional*, defaults to `[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]`):
+ The quantiles to predict.
+ output_quantile_len (`int`, *optional*, defaults to 1024):
+ Length of the quantile output projection dimension.
+ decode_index (`int`, *optional*, defaults to 5):
+ Index into the quantile dimension used to extract the point (median) forecast.
+ use_bias (`bool`, *optional*, defaults to `False`):
+ Whether to use bias in MLP and transformer linear layers.
+ use_continuous_quantile_head (`bool`, *optional*, defaults to `True`):
+ Whether to use the continuous quantile head for non-median quantile predictions.
+ force_flip_invariance (`bool`, *optional*, defaults to `True`):
+ Whether to apply flip-invariance averaging during forecasting.
+ infer_is_positive (`bool`, *optional*, defaults to `True`):
+ Whether to clamp forecasts to non-negative values when the input minimum is non-negative.
+
+ Example:
+
+ ```python
+ >>> from transformers import TimesFm2_5Config, TimesFm2_5ModelForPrediction
+
+ >>> configuration = TimesFm2_5Config()
+ >>> model = TimesFm2_5ModelForPrediction(configuration)
+ >>> configuration = model.config
+ ```
+ """
+
+ context_length: int = 16384
+ num_key_value_heads: int = 16
+ num_hidden_layers: int = 20
+ attention_bias: bool = False
+ output_quantile_len: int = 1024
+ decode_index: int = 5
+ use_bias: bool = False
+ activation: str = "swish"
+ use_continuous_quantile_head: bool = True
+ force_flip_invariance: bool = True
+ infer_is_positive: bool = True
+ max_position_embeddings: int = 16384
+ rope_parameters: RopeParameters | dict | None = None
+
+ freq_size = AttributeError()
+ pad_val = AttributeError()
+ tolerance = AttributeError()
+ use_positional_embedding = AttributeError()
+ min_timescale = AttributeError()
+ max_timescale = AttributeError()
+
+
+@auto_docstring
+@dataclass
+class TimesFm2_5Output(TimesFmOutput):
+ r"""
+ context_mu (`torch.Tensor` of shape `(batch_size, num_patches)`):
+ Running means computed per input patch during normalization.
+ context_sigma (`torch.Tensor` of shape `(batch_size, num_patches)`):
+ Running standard deviations computed per input patch during normalization.
+ """
+
+ context_mu: torch.Tensor | None = None
+ context_sigma: torch.Tensor | None = None
+
+
+@auto_docstring
+@dataclass
+class TimesFm2_5OutputForPrediction(TimesFmOutputForPrediction):
+ r"""
+ mean_predictions (`torch.Tensor` of shape `(batch_size, horizon_length)`):
+ Deterministic forecasts after denormalization.
+ full_predictions (`torch.Tensor` of shape `(batch_size, horizon_length, quantiles)`):
+ Quantile forecasts including the median after denormalization.
+ loss (`torch.Tensor` of shape `(1,)`, *optional*, returned when `future_values` is provided):
+ Training loss combining MSE and quantile losses when targets are supplied.
+ """
+
+ pass
+
+
+class TimesFm2_5MLP(CLIPMLP):
+ def __init__(self, config: TimesFm2_5Config):
+ super().__init__()
+ self.activation_fn = ACT2FN[config.activation]
+ self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size, bias=config.use_bias)
+ self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size, bias=config.use_bias)
+
+
+class TimesFm2_5ResidualBlock(TimesFmResidualBlock):
+ """[`TimesFmResidualBlock`] variant with configurable `use_bias` and `activation`."""
+
+ def __init__(self, config, input_dims: int, hidden_dims: int, output_dims: int, use_bias: bool | None = None):
+ super().__init__(input_dims, hidden_dims, output_dims)
+ use_bias = use_bias if use_bias is not None else config.use_bias
+ self.input_layer = nn.Linear(input_dims, hidden_dims, bias=use_bias)
+ self.output_layer = nn.Linear(hidden_dims, output_dims, bias=use_bias)
+ self.residual_layer = nn.Linear(input_dims, output_dims, bias=use_bias)
+ self.activation = ACT2FN[config.activation]
+
+ def forward(self, x):
+ # Align activations to block parameter dtype for mixed precision stability
+ x = x.to(self.input_layer.weight.dtype)
+ return super().forward(x)
+
+
+class TimesFm2_5RMSNorm(LlamaRMSNorm):
+ pass
+
+
+class TimesFm2_5RotaryEmbedding(LlamaRotaryEmbedding):
+ pass
+
+
+class TimesFm2_5Attention(ApertusAttention):
+ """TimesFM 2.5 attention with learnable per-dimension query scaling."""
+
+ def __init__(self, config: TimesFm2_5Config, layer_idx: int):
+ super().__init__(config, layer_idx)
+ self.scaling = nn.Parameter(torch.empty((self.head_dim,)))
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ attention_mask: torch.Tensor | None,
+ past_key_values=None,
+ **kwargs: Unpack[TransformersKwargs],
+ ):
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ query_states = self.q_norm(query_states)
+ key_states = self.k_norm(key_states)
+
+ scale = F.softplus(self.scaling).mul(1.442695041 / math.sqrt(self.head_dim))
+ query_states = query_states * scale[None, None, None, :]
+
+ if past_key_values is not None:
+ key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=self.attention_dropout if self.training else 0.0,
+ # scaling=1.0 because per-dimension learnable scaling is already applied to query_states above
+ scaling=1.0,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+class TimesFm2_5DecoderLayer(LlamaDecoderLayer):
+ """TimesFM 2.5 Transformer decoder layer with pre/post RMS normalization and no KV cache."""
+
+ def __init__(self, config: TimesFm2_5Config, layer_idx: int):
+ super().__init__(config, layer_idx)
+ self.pre_feedforward_layernorm = TimesFm2_5RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.post_feedforward_layernorm = TimesFm2_5RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ residual = hidden_states
+ hidden_states = self.input_layernorm(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+ hidden_states = self.post_attention_layernorm(hidden_states) + residual
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = self.post_feedforward_layernorm(hidden_states) + residual
+
+ return hidden_states
+
+
+@auto_docstring
+class TimesFm2_5PreTrainedModel(TimesFmPreTrainedModel):
+ config_class = TimesFm2_5Config
+ base_model_prefix = "model"
+ _no_split_modules = ["TimesFm2_5DecoderLayer"]
+ _supports_flash_attn = True
+ _supports_flex_attn = True
+ _can_record_outputs = {
+ "hidden_states": TimesFm2_5DecoderLayer,
+ "attentions": TimesFm2_5Attention,
+ }
+
+
+class TimesFm2_5Model(TimesFm2_5PreTrainedModel):
+ def __init__(self, config: TimesFm2_5Config):
+ super().__init__(config)
+ self.config = config
+ self.tolerance = 1e-6
+
+ self.input_ff_layer = TimesFm2_5ResidualBlock(
+ config,
+ input_dims=2 * config.patch_length,
+ hidden_dims=config.hidden_size,
+ output_dims=config.hidden_size,
+ use_bias=True,
+ )
+
+ self.layers = nn.ModuleList(
+ [TimesFm2_5DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.rotary_emb = TimesFm2_5RotaryEmbedding(config)
+ self.gradient_checkpointing = False
+
+ self.post_init()
+
+ def _revin(
+ self,
+ hidden_states: torch.Tensor,
+ loc: torch.Tensor,
+ scale: torch.Tensor,
+ reverse: bool = False,
+ mask: torch.Tensor | None = None,
+ ) -> torch.Tensor:
+ """Reversible instance normalization (RevIN).
+
+ Normalizes or denormalizes `hidden_states` using the provided location and scale statistics.
+ When `mask` is provided during normalization (reverse=False), masked positions are zeroed out.
+ """
+ if len(loc.shape) == len(hidden_states.shape) - 1:
+ loc = loc[..., None]
+ scale = scale[..., None]
+ elif len(loc.shape) == len(hidden_states.shape) - 2:
+ loc = loc[..., None, None]
+ scale = scale[..., None, None]
+
+ loc = loc.to(hidden_states.device)
+ scale = scale.to(hidden_states.device)
+ safe_scale = torch.where(scale < self.tolerance, torch.ones_like(scale), scale)
+
+ if reverse:
+ return hidden_states * scale + loc
+
+ normed = (hidden_states - loc) / safe_scale
+ if mask is not None:
+ normed = torch.where(mask, torch.zeros_like(normed), normed)
+ return normed
+
+ @staticmethod
+ def _update_running_stats(
+ count: torch.Tensor,
+ mean: torch.Tensor,
+ std: torch.Tensor,
+ new_values: torch.Tensor,
+ mask: torch.Tensor,
+ ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """Update running mean/std using Welford's online algorithm.
+
+ Combines existing statistics (`count`, `mean`, `std`) with a new batch of values,
+ respecting the boolean `mask` (True = masked/invalid).
+ """
+ is_valid = (~mask).to(new_values.dtype)
+ inc_count = is_valid.sum(dim=-1)
+
+ inc_count_safe = torch.where(inc_count == 0, torch.ones_like(inc_count), inc_count)
+ inc_mean = (new_values * is_valid).sum(dim=-1) / inc_count_safe
+ inc_mean = torch.where(inc_count == 0, torch.zeros_like(inc_mean), inc_mean)
+
+ centered = new_values - inc_mean.unsqueeze(-1)
+ inc_var = ((centered * is_valid) ** 2).sum(dim=-1) / inc_count_safe
+ inc_var = torch.where(inc_count == 0, torch.zeros_like(inc_var), inc_var)
+ inc_std = torch.sqrt(torch.clamp(inc_var, min=0.0))
+
+ new_count = count + inc_count
+ new_count_safe = torch.where(new_count == 0, torch.ones_like(new_count), new_count)
+
+ new_mean = (count * mean + inc_mean * inc_count) / new_count_safe
+ new_mean = torch.where(new_count == 0, torch.zeros_like(new_mean), new_mean)
+
+ term1 = count * std.pow(2)
+ term2 = inc_count * inc_std.pow(2)
+ term3 = count * (mean - new_mean).pow(2)
+ term4 = inc_count * (inc_mean - new_mean).pow(2)
+
+ new_var = (term1 + term2 + term3 + term4) / new_count_safe
+ new_var = torch.where(new_count == 0, torch.zeros_like(new_var), new_var)
+ new_std = torch.sqrt(torch.clamp(new_var, min=0.0))
+
+ return new_count, new_mean, new_std
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ past_values: torch.Tensor,
+ past_values_padding: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TimesFm2_5Output:
+ r"""
+ past_values (`torch.Tensor` of shape `(batch_size, sequence_length)`):
+ Past values of the time series used as input to the model.
+ past_values_padding (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Padding mask for the input. `1` indicates padded (masked) time steps, `0` indicates valid values.
+ """
+ batch_size, seq_len = past_values.shape
+ patch_len = self.config.patch_length
+
+ if past_values_padding is None:
+ past_values_padding = torch.zeros_like(past_values, dtype=torch.long)
+
+ patched_inputs = past_values.view(batch_size, -1, patch_len)
+ patched_masks = past_values_padding[:, :seq_len].view(batch_size, -1, patch_len)
+ patched_masks_bool = patched_masks >= 0.5
+
+ count = past_values.new_zeros(batch_size)
+ mean = past_values.new_zeros(batch_size)
+ std = past_values.new_zeros(batch_size)
+ mean_history: list[torch.Tensor] = []
+ std_history: list[torch.Tensor] = []
+
+ for i in range(patched_inputs.shape[1]):
+ count, mean, std = self._update_running_stats(
+ count, mean, std, patched_inputs[:, i, :], patched_masks_bool[:, i, :]
+ )
+ mean_history.append(mean)
+ std_history.append(std)
+
+ if mean_history:
+ context_mu = torch.stack(mean_history, dim=1)
+ context_sigma = torch.stack(std_history, dim=1)
+ else:
+ context_mu = mean.unsqueeze(1)
+ context_sigma = std.unsqueeze(1)
+
+ normed_inputs = self._revin(patched_inputs, context_mu, context_sigma, reverse=False, mask=patched_masks_bool)
+
+ tokenizer_inputs = torch.cat(
+ [normed_inputs, patched_masks_bool.to(dtype=normed_inputs.dtype)],
+ dim=-1,
+ )
+ input_embeddings = self.input_ff_layer(tokenizer_inputs)
+
+ patch_padding = patched_masks_bool[..., -1]
+
+ sequence_length = input_embeddings.shape[1]
+ num_masked = patch_padding.to(torch.int32).sum(dim=-1, keepdim=True)
+ position_ids = torch.arange(sequence_length, device=input_embeddings.device).unsqueeze(0) - num_masked
+
+ padding_mask = (~patch_padding).to(torch.int64)
+ attention_mask = create_causal_mask(self.config, input_embeddings, padding_mask, past_key_values=None)
+ position_embeddings = self.rotary_emb(input_embeddings, position_ids)
+
+ hidden_states = input_embeddings
+
+ for layer in self.layers:
+ hidden_states = layer(
+ hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ **kwargs,
+ )
+
+ loc = context_mu[:, -1]
+ scale = torch.clamp(context_sigma[:, -1], min=self.tolerance)
+
+ return TimesFm2_5Output(
+ last_hidden_state=hidden_states,
+ loc=loc,
+ scale=scale,
+ context_mu=context_mu,
+ context_sigma=context_sigma,
+ )
+
+
+class TimesFm2_5ModelForPrediction(TimesFmModelForPrediction):
+ def __init__(self, config: TimesFm2_5Config):
+ super().__init__(config)
+ self.config = config
+ self.context_len = config.context_length
+ self.horizon_len = config.horizon_length
+
+ # Remove inherited attributes from parent TimesFmModelForPrediction
+ del self.decoder
+ del self.horizon_ff_layer
+
+ self.model = TimesFm2_5Model(config)
+
+ num_quantiles = len(config.quantiles) + 1
+ self.output_projection_point = TimesFm2_5ResidualBlock(
+ config,
+ input_dims=config.hidden_size,
+ hidden_dims=config.hidden_size,
+ output_dims=config.horizon_length * num_quantiles,
+ )
+ self.output_projection_quantiles = TimesFm2_5ResidualBlock(
+ config,
+ input_dims=config.hidden_size,
+ hidden_dims=config.hidden_size,
+ output_dims=config.output_quantile_len * num_quantiles,
+ )
+
+ self.post_init()
+
+ def _decode_and_project(
+ self,
+ normalized_ts: torch.Tensor,
+ input_padding: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ """Run the decoder and project to point/quantile outputs.
+
+ Returns:
+ Tuple of (point_forecast, quantile_spreads), each of shape `(batch, length, num_quantiles)`.
+ """
+ model_outputs = self.model(
+ past_values=normalized_ts,
+ past_values_padding=input_padding,
+ **kwargs,
+ )
+
+ hidden_states = model_outputs.last_hidden_state
+ context_mu = model_outputs.context_mu
+ context_sigma = model_outputs.context_sigma
+
+ point_output = self.model._revin(
+ self.output_projection_point(hidden_states), context_mu, context_sigma, reverse=True
+ )
+ quantile_output = self.model._revin(
+ self.output_projection_quantiles(hidden_states), context_mu, context_sigma, reverse=True
+ )
+
+ batch_size, num_patches = point_output.shape[:2]
+ num_quantiles = len(self.config.quantiles) + 1
+
+ point_forecast = point_output.view(batch_size, num_patches, self.config.horizon_length, num_quantiles)[
+ :, -1, :, :
+ ]
+ quantile_spreads = quantile_output.view(
+ batch_size, num_patches, self.config.output_quantile_len, num_quantiles
+ )[:, -1, :, :]
+
+ # Ensure both outputs are on the same device for model parallelism
+ quantile_spreads = quantile_spreads.to(point_forecast.device)
+
+ return point_forecast, quantile_spreads, model_outputs
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ past_values: Sequence[torch.Tensor],
+ window_size: int | None = None,
+ future_values: torch.Tensor | None = None,
+ forecast_context_len: int | None = None,
+ truncate_negative: bool | None = None,
+ force_flip_invariance: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> TimesFm2_5OutputForPrediction:
+ r"""
+ past_values (`Sequence[torch.Tensor]`):
+ Past values of the time series that serves as input to the model. Each tensor is a 1D time series.
+ window_size (`int`, *optional*):
+ Window size of trend + residual decomposition. If `None`, decomposition is not applied.
+ future_values (`torch.Tensor`, *optional*):
+ Optional future values used to compute the loss.
+ forecast_context_len (`int`, *optional*):
+ Optional context length override used during forecasting.
+ truncate_negative (`bool`, *optional*):
+ Whether to clamp outputs to non-negative values. If `None`, defaults to `config.infer_is_positive`.
+ force_flip_invariance (`bool`, *optional*):
+ Whether to apply the flip-invariance combination. If `None`, defaults to
+ `config.force_flip_invariance`.
+ """
+ forecast_context_len = forecast_context_len or self.context_len
+ device = past_values[0].device
+
+ inputs = [ts[-forecast_context_len:] for ts in past_values]
+ input_min = torch.min(torch.stack([torch.min(ts) for ts in inputs]))
+
+ if window_size is not None:
+ new_inputs: list[torch.Tensor] = []
+ for ts in inputs:
+ new_inputs.extend(self._timesfm_moving_average(ts, window_size))
+ inputs = new_inputs
+
+ if truncate_negative is None:
+ truncate_negative = self.config.infer_is_positive
+ if force_flip_invariance is None:
+ force_flip_invariance = self.config.force_flip_invariance
+
+ input_ts, input_padding = self._preprocess(inputs, context_len=forecast_context_len)
+ input_ts = input_ts.to(device)
+ input_padding = input_padding.to(device)
+
+ mu_global = input_ts.mean(dim=1, keepdim=True)
+ sigma_global = input_ts.std(dim=1, keepdim=True)
+
+ normalized_ts = self.model._revin(input_ts, mu_global, sigma_global, reverse=False)
+
+ pf_outputs, quantile_spreads, model_outputs = self._decode_and_project(normalized_ts, input_padding, **kwargs)
+
+ if force_flip_invariance:
+ flipped_pf, flipped_qs, _ = self._decode_and_project(-normalized_ts, input_padding, **kwargs)
+
+ def _flip_quantiles(x: torch.Tensor) -> torch.Tensor:
+ return torch.cat([x[..., :1], torch.flip(x[..., 1:], dims=(-1,))], dim=-1)
+
+ pf_outputs = (pf_outputs - _flip_quantiles(flipped_pf)) / 2
+ quantile_spreads = (quantile_spreads - _flip_quantiles(flipped_qs)) / 2
+
+ horizon = min(self.horizon_len, pf_outputs.shape[1])
+ full_forecast = pf_outputs[:, :horizon, :].clone()
+
+ median_index = min(self.config.decode_index, full_forecast.shape[-1] - 1)
+ if self.config.use_continuous_quantile_head:
+ max_quantile_horizon = min(horizon, quantile_spreads.shape[1])
+ for idx, _ in enumerate(self.config.quantiles, start=1):
+ if idx == median_index or idx >= full_forecast.shape[-1]:
+ continue
+ full_forecast[:, :max_quantile_horizon, idx] = (
+ quantile_spreads[:, :max_quantile_horizon, idx]
+ - quantile_spreads[:, :max_quantile_horizon, median_index]
+ + full_forecast[:, :max_quantile_horizon, median_index]
+ )
+
+ full_predictions = self.model._revin(full_forecast, mu_global, sigma_global, reverse=True)
+ decode_index = min(self.config.decode_index, full_predictions.shape[-1] - 1)
+ mean_predictions = full_predictions[:, :, decode_index]
+
+ if window_size is not None:
+ mean_predictions = mean_predictions[0::2, ...] + mean_predictions[1::2, ...]
+ full_predictions = full_predictions[0::2, ...] + full_predictions[1::2, ...]
+
+ if truncate_negative:
+ zero = torch.zeros(1, device=mean_predictions.device, dtype=mean_predictions.dtype)
+ clamped_mean = torch.maximum(mean_predictions, zero)
+ clamped_full = torch.maximum(full_predictions, zero)
+ should_clamp = (input_min >= 0).to(mean_predictions.device)
+ mean_predictions = torch.where(should_clamp, clamped_mean, mean_predictions)
+ full_predictions = torch.where(should_clamp, clamped_full, full_predictions)
+
+ loss = None
+ if future_values is not None:
+ target_len = future_values.shape[1]
+ # Compute loss in normalized space for scale-invariant training.
+ # full_forecast is already in normalized space (before denormalization).
+ normalized_preds = full_forecast[:, :target_len]
+ normalized_targets = self.model._revin(future_values, mu_global, sigma_global, reverse=False)
+ normalized_mean_preds = normalized_preds[:, :, decode_index]
+ mse_loss = F.mse_loss(normalized_mean_preds, normalized_targets)
+ quantile_indices = [i for i in range(normalized_preds.shape[-1]) if i != decode_index]
+ if quantile_indices:
+ index_tensor = torch.tensor(quantile_indices, device=normalized_preds.device, dtype=torch.long)
+ quantile_tensor = torch.index_select(normalized_preds, dim=-1, index=index_tensor)
+ quantile_loss = self._quantile_loss(quantile_tensor, normalized_targets)
+ loss = mse_loss + quantile_loss
+ else:
+ loss = mse_loss
+
+ return TimesFm2_5OutputForPrediction(
+ last_hidden_state=model_outputs.last_hidden_state,
+ hidden_states=model_outputs.hidden_states,
+ attentions=model_outputs.attentions,
+ mean_predictions=mean_predictions,
+ full_predictions=full_predictions,
+ loss=loss,
+ )
+
+
+__all__ = [
+ "TimesFm2_5Config",
+ "TimesFm2_5ModelForPrediction",
+ "TimesFm2_5PreTrainedModel",
+ "TimesFm2_5Model",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/timesformer/__init__.py b/lib/python3.11/site-packages/transformers/models/timesformer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0cc9d3d6a68569b0e0e94c94573d7191b153a68
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesformer/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_timesformer import *
+ from .modeling_timesformer import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/timesformer/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesformer/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e9ae193c5859638926b811c76b0939c01f0fa925
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesformer/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesformer/__pycache__/configuration_timesformer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesformer/__pycache__/configuration_timesformer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e4c4b317eb5cab0c7354e5396588da5a4a45631f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesformer/__pycache__/configuration_timesformer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesformer/__pycache__/modeling_timesformer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timesformer/__pycache__/modeling_timesformer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a28f2ff6e8bc6cb87e817dff49a73ab103222a7
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timesformer/__pycache__/modeling_timesformer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timesformer/configuration_timesformer.py b/lib/python3.11/site-packages/transformers/models/timesformer/configuration_timesformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..554d0e02531e394e21f83d72af4665e1b0728bb2
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesformer/configuration_timesformer.py
@@ -0,0 +1,66 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""TimeSformer model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="facebook/timesformer-base-finetuned-k600")
+@strict
+class TimesformerConfig(PreTrainedConfig):
+ r"""
+ num_frames (`int`, *optional*, defaults to 8):
+ The number of frames in each video.
+ attention_type (`str`, *optional*, defaults to `"divided_space_time"`):
+ The attention type to use. Must be one of `"divided_space_time"`, `"space_only"`, `"joint_space_time"`.
+
+ Example:
+
+ ```python
+ >>> from transformers import TimesformerConfig, TimesformerModel
+
+ >>> # Initializing a TimeSformer timesformer-base style configuration
+ >>> configuration = TimesformerConfig()
+
+ >>> # Initializing a model from the configuration
+ >>> model = TimesformerModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "timesformer"
+
+ image_size: int | list[int] | tuple[int, int] = 224
+ patch_size: int | list[int] | tuple[int, int] = 16
+ num_channels: int = 3
+ num_frames: int = 8
+ hidden_size: int = 768
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ intermediate_size: int = 3072
+ hidden_act: str = "gelu"
+ hidden_dropout_prob: float | int = 0.0
+ attention_probs_dropout_prob: float | int = 0.0
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-6
+ qkv_bias: bool = True
+ attention_type: str = "divided_space_time"
+ drop_path_rate: int = 0
+
+
+__all__ = ["TimesformerConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/timesformer/modeling_timesformer.py b/lib/python3.11/site-packages/transformers/models/timesformer/modeling_timesformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf2a7632a49b9e8e0c71860aeb151b1a26737888
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timesformer/modeling_timesformer.py
@@ -0,0 +1,751 @@
+# Copyright 2022 Meta and The HuggingFace Inc. 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.
+"""PyTorch TimeSformer model."""
+
+import collections
+
+import torch
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, ImageClassifierOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import (
+ auto_docstring,
+ logging,
+)
+from .configuration_timesformer import TimesformerConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+# Adapted from https://github.com/facebookresearch/TimeSformer/blob/a5ef29a7b7264baff199a30b3306ac27de901133/timesformer/models/vit.py#L155
+class TimesformerPatchEmbeddings(nn.Module):
+ """Image to Patch Embedding"""
+
+ def __init__(self, config):
+ super().__init__()
+
+ image_size = config.image_size
+ patch_size = config.patch_size
+
+ image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+
+ num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
+ self.image_size = image_size
+ self.patch_size = patch_size
+ self.num_patches = num_patches
+
+ self.projection = nn.Conv2d(config.num_channels, config.hidden_size, kernel_size=patch_size, stride=patch_size)
+
+ def forward(self, pixel_values):
+ batch_size, num_frames, num_channels, height, width = pixel_values.shape
+ pixel_values = pixel_values.reshape(batch_size * num_frames, num_channels, height, width)
+
+ embeddings = self.projection(pixel_values)
+ patch_width = embeddings.size(-1)
+ embeddings = embeddings.flatten(2).transpose(1, 2)
+ return embeddings, num_frames, patch_width
+
+
+class TimesformerEmbeddings(nn.Module):
+ """
+ Construct the patch and position embeddings.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+
+ embed_dim = config.hidden_size
+ num_frames = config.num_frames
+ drop_rate = config.hidden_dropout_prob
+ attention_type = config.attention_type
+
+ self.attention_type = attention_type
+ self.patch_embeddings = TimesformerPatchEmbeddings(config)
+ self.num_patches = self.patch_embeddings.num_patches
+
+ # Positional Embeddings
+ self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+ self.position_embeddings = nn.Parameter(torch.zeros(1, self.num_patches + 1, embed_dim))
+ self.pos_drop = nn.Dropout(p=drop_rate)
+ if attention_type != "space_only":
+ self.time_embeddings = nn.Parameter(torch.zeros(1, num_frames, embed_dim))
+ self.time_drop = nn.Dropout(p=drop_rate)
+
+ def forward(self, pixel_values):
+ batch_size = pixel_values.shape[0]
+
+ # create patch embeddings
+ embeddings, num_frames, patch_width = self.patch_embeddings(pixel_values)
+
+ cls_tokens = self.cls_token.expand(embeddings.size(0), -1, -1)
+ embeddings = torch.cat((cls_tokens, embeddings), dim=1)
+
+ # resizing the positional embeddings in case they don't match the input at inference
+ if embeddings.size(1) != self.position_embeddings.size(1):
+ position_embeddings = self.position_embeddings
+ cls_pos_embed = position_embeddings[0, 0, :].unsqueeze(0).unsqueeze(1)
+ other_pos_embed = position_embeddings[0, 1:, :].unsqueeze(0).transpose(1, 2)
+ patch_num = int(other_pos_embed.size(2) ** 0.5)
+ patch_height = embeddings.size(1) // patch_width
+ other_pos_embed = other_pos_embed.reshape(1, embeddings.size(2), patch_num, patch_num)
+ new_pos_embed = nn.functional.interpolate(
+ other_pos_embed, size=(patch_height, patch_width), mode="nearest"
+ )
+ new_pos_embed = new_pos_embed.flatten(2)
+ new_pos_embed = new_pos_embed.transpose(1, 2)
+ new_pos_embed = torch.cat((cls_pos_embed, new_pos_embed), 1)
+ embeddings = embeddings + new_pos_embed
+ else:
+ embeddings = embeddings + self.position_embeddings
+ embeddings = self.pos_drop(embeddings)
+
+ # Time Embeddings
+ if self.attention_type != "space_only":
+ cls_tokens = embeddings[:batch_size, 0, :].unsqueeze(1)
+ embeddings = embeddings[:, 1:]
+ _, patch_height, patch_width = embeddings.shape
+ embeddings = (
+ embeddings.reshape(batch_size, num_frames, patch_height, patch_width)
+ .permute(0, 2, 1, 3)
+ .reshape(batch_size * patch_height, num_frames, patch_width)
+ )
+ # Resizing time embeddings in case they don't match
+ if num_frames != self.time_embeddings.size(1):
+ time_embeddings = self.time_embeddings.transpose(1, 2)
+ new_time_embeddings = nn.functional.interpolate(time_embeddings, size=(num_frames), mode="nearest")
+ new_time_embeddings = new_time_embeddings.transpose(1, 2)
+ embeddings = embeddings + new_time_embeddings
+ else:
+ embeddings = embeddings + self.time_embeddings
+ embeddings = self.time_drop(embeddings)
+ embeddings = embeddings.view(batch_size, patch_height, num_frames, patch_width).reshape(
+ batch_size, patch_height * num_frames, patch_width
+ )
+ embeddings = torch.cat((cls_tokens, embeddings), dim=1)
+
+ return embeddings
+
+
+# Adapted from https://github.com/facebookresearch/TimeSformer/blob/a5ef29a7b7264baff199a30b3306ac27de901133/timesformer/models/vit.py#L57
+class TimesformerSelfAttention(nn.Module):
+ def __init__(self, config: TimesformerConfig):
+ super().__init__()
+
+ num_heads = config.num_attention_heads
+ qkv_bias = config.qkv_bias
+ attention_dropout_prob = config.attention_probs_dropout_prob
+
+ self.num_heads = num_heads
+ head_dim = config.hidden_size // num_heads
+ self.scale = head_dim**-0.5
+ self.qkv = nn.Linear(config.hidden_size, config.hidden_size * 3, bias=qkv_bias)
+ self.attn_drop = nn.Dropout(attention_dropout_prob)
+
+ def forward(self, hidden_states, output_attentions: bool = False):
+ batch_size, hidden_size, num_channels = hidden_states.shape
+ qkv = (
+ self.qkv(hidden_states)
+ .reshape(batch_size, hidden_size, 3, self.num_heads, num_channels // self.num_heads)
+ .permute(2, 0, 3, 1, 4)
+ )
+ query, key, value = qkv[0], qkv[1], qkv[2]
+
+ attention_probs = (query @ key.transpose(-2, -1)) * self.scale
+ attention_probs = attention_probs.softmax(dim=-1)
+ attention_probs = self.attn_drop(attention_probs)
+
+ context_layer = (attention_probs @ value).transpose(1, 2).reshape(batch_size, hidden_size, num_channels)
+
+ outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+ return outputs
+
+
+class TimesformerSelfOutput(nn.Module):
+ """
+ The residual connection is defined in TimesformerLayer instead of here (as is the case with other models), due to
+ the layernorm applied before each block.
+ """
+
+ def __init__(self, config: TimesformerConfig) -> None:
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ return hidden_states
+
+
+class TimeSformerAttention(nn.Module):
+ def __init__(self, config: TimesformerConfig) -> None:
+ super().__init__()
+ self.attention = TimesformerSelfAttention(config)
+ self.output = TimesformerSelfOutput(config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ output_attentions: bool = False,
+ ) -> tuple[torch.Tensor, torch.Tensor] | tuple[torch.Tensor]:
+ self_outputs = self.attention(hidden_states, output_attentions)
+
+ attention_output = self.output(self_outputs[0])
+
+ outputs = (attention_output,) + self_outputs[1:] # add attentions if we output them
+ return outputs
+
+
+# Adapted from https://github.com/facebookresearch/TimeSformer/blob/a5ef29a7b7264baff199a30b3306ac27de901133/timesformer/models/vit.py#L39
+class TimesformerIntermediate(nn.Module):
+ def __init__(self, config: TimesformerConfig) -> None:
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ return hidden_states
+
+
+class TimesformerOutput(nn.Module):
+ def __init__(self, config: TimesformerConfig) -> None:
+ super().__init__()
+ self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ return hidden_states
+
+
+# Copied from transformers.models.swin.modular_swin.SwinDropPath with SwinDropPath->TimesformerDropPath
+class TimesformerDropPath(nn.Module):
+ """Stochastic depth (DropPath) per sample, for residual blocks.
+
+ Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
+ <https://arxiv.org/abs/1603.09382>`_.
+ """
+
+ def __init__(self, drop_prob: float = 0.0) -> None:
+ super().__init__()
+ self.drop_prob = drop_prob
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ if self.drop_prob == 0.0 or not self.training:
+ return hidden_states
+ keep_prob = 1 - self.drop_prob
+ shape = (hidden_states.shape[0],) + (1,) * (hidden_states.ndim - 1)
+ random_tensor = torch.rand(shape, dtype=hidden_states.dtype, device=hidden_states.device)
+ random_tensor = torch.floor(random_tensor + keep_prob)
+ return hidden_states.div(keep_prob) * random_tensor
+
+ def extra_repr(self) -> str:
+ return f"p={self.drop_prob}"
+
+
+# Adapted from https://github.com/facebookresearch/TimeSformer/blob/a5ef29a7b7264baff199a30b3306ac27de901133/timesformer/models/vit.py#L89
+class TimesformerLayer(GradientCheckpointingLayer):
+ def __init__(self, config: TimesformerConfig, layer_index: int) -> None:
+ super().__init__()
+
+ attention_type = config.attention_type
+
+ drop_path_rates = [
+ x.item() for x in torch.linspace(0, config.drop_path_rate, config.num_hidden_layers, device="cpu")
+ ] # stochastic depth decay rule
+ drop_path_rate = drop_path_rates[layer_index]
+
+ self.drop_path = TimesformerDropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity()
+ self.attention = TimeSformerAttention(config)
+ self.intermediate = TimesformerIntermediate(config)
+ self.output = TimesformerOutput(config)
+ self.layernorm_before = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.layernorm_after = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ self.config = config
+ self.attention_type = attention_type
+ if attention_type not in ["divided_space_time", "space_only", "joint_space_time"]:
+ raise ValueError(f"Unknown attention type: {attention_type}")
+
+ # Temporal Attention Parameters
+ if self.attention_type == "divided_space_time":
+ self.temporal_layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.temporal_attention = TimeSformerAttention(config)
+ self.temporal_dense = nn.Linear(config.hidden_size, config.hidden_size)
+
+ def forward(self, hidden_states: torch.Tensor, output_attentions: bool = False):
+ num_frames = self.config.num_frames
+ num_patch_width = self.config.image_size // self.config.patch_size
+ batch_size = hidden_states.shape[0]
+ num_spatial_tokens = (hidden_states.size(1) - 1) // num_frames
+ num_patch_height = num_spatial_tokens // num_patch_width
+
+ if self.attention_type in ["space_only", "joint_space_time"]:
+ self_attention_outputs = self.attention(
+ self.layernorm_before(hidden_states), output_attentions=output_attentions
+ )
+ attention_output = self_attention_outputs[0]
+ outputs = self_attention_outputs[1:] # add self attentions if we output attention weights
+
+ hidden_states = hidden_states + self.drop_path(attention_output)
+
+ layer_output = self.layernorm_after(hidden_states)
+ layer_output = self.intermediate(layer_output)
+ layer_output = self.output(layer_output)
+ layer_output = hidden_states + self.drop_path(layer_output)
+
+ outputs = (layer_output,) + outputs
+
+ return outputs
+
+ elif self.attention_type == "divided_space_time":
+ # Temporal
+ temporal_embedding = hidden_states[:, 1:, :]
+ temporal_embedding = temporal_embedding.reshape(
+ batch_size, num_patch_height, num_patch_width, num_frames, temporal_embedding.shape[2]
+ ).reshape(batch_size * num_patch_height * num_patch_width, num_frames, temporal_embedding.shape[2])
+
+ temporal_attention_outputs = self.temporal_attention(
+ self.temporal_layernorm(temporal_embedding),
+ )
+ attention_output = temporal_attention_outputs[0]
+
+ residual_temporal = self.drop_path(attention_output)
+
+ residual_temporal = residual_temporal.reshape(
+ batch_size, num_patch_height, num_patch_width, num_frames, residual_temporal.shape[2]
+ ).reshape(batch_size, num_patch_height * num_patch_width * num_frames, residual_temporal.shape[2])
+ residual_temporal = self.temporal_dense(residual_temporal)
+ temporal_embedding = hidden_states[:, 1:, :] + residual_temporal
+
+ # Spatial
+ init_cls_token = hidden_states[:, 0, :].unsqueeze(1)
+ cls_token = init_cls_token.repeat(1, num_frames, 1)
+ cls_token = cls_token.reshape(batch_size * num_frames, 1, cls_token.shape[2])
+ spatial_embedding = temporal_embedding
+ spatial_embedding = (
+ spatial_embedding.reshape(
+ batch_size, num_patch_height, num_patch_width, num_frames, spatial_embedding.shape[2]
+ )
+ .permute(0, 3, 1, 2, 4)
+ .reshape(batch_size * num_frames, num_patch_height * num_patch_width, spatial_embedding.shape[2])
+ )
+ spatial_embedding = torch.cat((cls_token, spatial_embedding), 1)
+
+ spatial_attention_outputs = self.attention(
+ self.layernorm_before(spatial_embedding), output_attentions=output_attentions
+ )
+ attention_output = spatial_attention_outputs[0]
+ outputs = spatial_attention_outputs[1:] # add self attentions if we output attention weights
+
+ residual_spatial = self.drop_path(attention_output)
+
+ # Taking care of CLS token
+ cls_token = residual_spatial[:, 0, :]
+ cls_token = cls_token.reshape(batch_size, num_frames, cls_token.shape[1])
+ cls_token = torch.mean(cls_token, 1, True) # averaging for every frame
+ residual_spatial = residual_spatial[:, 1:, :]
+ residual_spatial = (
+ residual_spatial.reshape(
+ batch_size, num_frames, num_patch_height, num_patch_width, residual_spatial.shape[2]
+ )
+ .permute(0, 2, 3, 1, 4)
+ .reshape(batch_size, num_patch_height * num_patch_width * num_frames, residual_spatial.shape[2])
+ )
+ residual = residual_spatial
+ hidden_states = temporal_embedding
+
+ # Mlp
+ hidden_states = torch.cat((init_cls_token, hidden_states), 1) + torch.cat((cls_token, residual), 1)
+ layer_output = self.layernorm_after(hidden_states)
+ layer_output = self.intermediate(layer_output)
+ layer_output = self.output(layer_output)
+ layer_output = hidden_states + self.drop_path(layer_output)
+
+ outputs = (layer_output,) + outputs
+
+ return outputs
+
+
+class TimesformerEncoder(nn.Module):
+ def __init__(self, config: TimesformerConfig) -> None:
+ super().__init__()
+ self.config = config
+ self.layer = nn.ModuleList([TimesformerLayer(config, ind) for ind in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ output_attentions: bool = False,
+ output_hidden_states: bool = False,
+ return_dict: bool = True,
+ ) -> tuple | BaseModelOutput:
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ for i, layer_module in enumerate(self.layer):
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ layer_outputs = layer_module(hidden_states, output_attentions)
+
+ hidden_states = layer_outputs[0]
+
+ if output_attentions:
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+
+@auto_docstring
+class TimesformerPreTrainedModel(PreTrainedModel):
+ config: TimesformerConfig
+ base_model_prefix = "timesformer"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["TimesformerLayer"]
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ if isinstance(module, (nn.Linear, nn.Conv2d)):
+ init.trunc_normal_(module.weight, std=self.config.initializer_range)
+ if module.bias is not None:
+ init.constant_(module.bias, 0)
+ elif isinstance(module, nn.LayerNorm):
+ init.constant_(module.bias, 0)
+ init.constant_(module.weight, 1.0)
+ elif isinstance(module, TimesformerEmbeddings):
+ init.trunc_normal_(module.cls_token, std=self.config.initializer_range)
+ init.trunc_normal_(module.position_embeddings, std=self.config.initializer_range)
+
+
+@auto_docstring
+class TimesformerModel(TimesformerPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.config = config
+
+ self.embeddings = TimesformerEmbeddings(config)
+ self.encoder = TimesformerEncoder(config)
+
+ self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings.patch_embeddings
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | BaseModelOutput:
+ r"""
+ Examples:
+
+ ```python
+ >>> import av
+ >>> import numpy as np
+
+ >>> from transformers import AutoImageProcessor, TimesformerModel
+ >>> from huggingface_hub import hf_hub_download
+
+ >>> np.random.seed(0)
+
+
+ >>> def read_video_pyav(container, indices):
+ ... '''
+ ... Decode the video with PyAV decoder.
+ ... Args:
+ ... container (`av.container.input.InputContainer`): PyAV container.
+ ... indices (`list[int]`): List of frame indices to decode.
+ ... Returns:
+ ... result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
+ ... '''
+ ... frames = []
+ ... container.seek(0)
+ ... start_index = indices[0]
+ ... end_index = indices[-1]
+ ... for i, frame in enumerate(container.decode(video=0)):
+ ... if i > end_index:
+ ... break
+ ... if i >= start_index and i in indices:
+ ... frames.append(frame)
+ ... return np.stack([x.to_ndarray(format="rgb24") for x in frames])
+
+
+ >>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
+ ... '''
+ ... Sample a given number of frame indices from the video.
+ ... Args:
+ ... clip_len (`int`): Total number of frames to sample.
+ ... frame_sample_rate (`int`): Sample every n-th frame.
+ ... seg_len (`int`): Maximum allowed index of sample's last frame.
+ ... Returns:
+ ... indices (`list[int]`): List of sampled frame indices
+ ... '''
+ ... converted_len = int(clip_len * frame_sample_rate)
+ ... end_idx = np.random.randint(converted_len, seg_len)
+ ... start_idx = end_idx - converted_len
+ ... indices = np.linspace(start_idx, end_idx, num=clip_len)
+ ... indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
+ ... return indices
+
+
+ >>> # video clip consists of 300 frames (10 seconds at 30 FPS)
+ >>> file_path = hf_hub_download(
+ ... repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
+ ... )
+ >>> container = av.open(file_path)
+
+ >>> # sample 8 frames
+ >>> indices = sample_frame_indices(clip_len=8, frame_sample_rate=4, seg_len=container.streams.video[0].frames)
+ >>> video = read_video_pyav(container, indices)
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base")
+ >>> model = TimesformerModel.from_pretrained("facebook/timesformer-base-finetuned-k400")
+
+ >>> # prepare video for the model
+ >>> inputs = image_processor(list(video), return_tensors="pt")
+
+ >>> # forward pass
+ >>> outputs = model(**inputs)
+ >>> last_hidden_states = outputs.last_hidden_state
+ >>> list(last_hidden_states.shape)
+ [1, 1569, 768]
+ ```"""
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ embedding_output = self.embeddings(pixel_values)
+
+ encoder_outputs = self.encoder(
+ embedding_output,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ sequence_output = encoder_outputs[0]
+ if self.layernorm is not None:
+ sequence_output = self.layernorm(sequence_output)
+
+ if not return_dict:
+ return (sequence_output,) + encoder_outputs[1:]
+
+ return BaseModelOutput(
+ last_hidden_state=sequence_output,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ TimeSformer Model transformer with a video classification head on top (a linear layer on top of the final hidden state
+ of the [CLS] token) e.g. for ImageNet.
+ """
+)
+class TimesformerForVideoClassification(TimesformerPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.num_labels = config.num_labels
+ self.timesformer = TimesformerModel(config)
+
+ # Classifier head
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels) if config.num_labels > 0 else nn.Identity()
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor | None = None,
+ labels: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | ImageClassifierOutput:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+
+ Examples:
+
+ ```python
+ >>> import av
+ >>> import torch
+ >>> import numpy as np
+
+ >>> from transformers import AutoImageProcessor, TimesformerForVideoClassification
+ >>> from huggingface_hub import hf_hub_download
+
+ >>> np.random.seed(0)
+
+
+ >>> def read_video_pyav(container, indices):
+ ... '''
+ ... Decode the video with PyAV decoder.
+ ... Args:
+ ... container (`av.container.input.InputContainer`): PyAV container.
+ ... indices (`list[int]`): List of frame indices to decode.
+ ... Returns:
+ ... result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
+ ... '''
+ ... frames = []
+ ... container.seek(0)
+ ... start_index = indices[0]
+ ... end_index = indices[-1]
+ ... for i, frame in enumerate(container.decode(video=0)):
+ ... if i > end_index:
+ ... break
+ ... if i >= start_index and i in indices:
+ ... frames.append(frame)
+ ... return np.stack([x.to_ndarray(format="rgb24") for x in frames])
+
+
+ >>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
+ ... '''
+ ... Sample a given number of frame indices from the video.
+ ... Args:
+ ... clip_len (`int`): Total number of frames to sample.
+ ... frame_sample_rate (`int`): Sample every n-th frame.
+ ... seg_len (`int`): Maximum allowed index of sample's last frame.
+ ... Returns:
+ ... indices (`list[int]`): List of sampled frame indices
+ ... '''
+ ... converted_len = int(clip_len * frame_sample_rate)
+ ... end_idx = np.random.randint(converted_len, seg_len)
+ ... start_idx = end_idx - converted_len
+ ... indices = np.linspace(start_idx, end_idx, num=clip_len)
+ ... indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
+ ... return indices
+
+
+ >>> # video clip consists of 300 frames (10 seconds at 30 FPS)
+ >>> file_path = hf_hub_download(
+ ... repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
+ ... )
+ >>> container = av.open(file_path)
+
+ >>> # sample 8 frames
+ >>> indices = sample_frame_indices(clip_len=8, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
+ >>> video = read_video_pyav(container, indices)
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics")
+ >>> model = TimesformerForVideoClassification.from_pretrained("facebook/timesformer-base-finetuned-k400")
+
+ >>> inputs = image_processor(list(video), return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+ ... logits = outputs.logits
+
+ >>> # model predicts one of the 400 Kinetics-400 classes
+ >>> predicted_label = logits.argmax(-1).item()
+ >>> print(model.config.id2label[predicted_label])
+ eating spaghetti
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.timesformer(
+ pixel_values,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = outputs[0][:, 0]
+
+ logits = self.classifier(sequence_output)
+
+ loss = None
+ if labels is not None:
+ if self.config.problem_type is None:
+ if self.num_labels == 1:
+ self.config.problem_type = "regression"
+ elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+ self.config.problem_type = "single_label_classification"
+ else:
+ self.config.problem_type = "multi_label_classification"
+
+ if self.config.problem_type == "regression":
+ loss_fct = MSELoss()
+ if self.num_labels == 1:
+ loss = loss_fct(logits.squeeze(), labels.squeeze())
+ else:
+ loss = loss_fct(logits, labels)
+ elif self.config.problem_type == "single_label_classification":
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+ elif self.config.problem_type == "multi_label_classification":
+ loss_fct = BCEWithLogitsLoss()
+ loss = loss_fct(logits, labels)
+
+ if not return_dict:
+ output = (logits,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return ImageClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = ["TimesformerModel", "TimesformerForVideoClassification", "TimesformerPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/timm_backbone/__init__.py b/lib/python3.11/site-packages/transformers/models/timm_backbone/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a58f096b1e48227518b04a11250d66635c65701
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timm_backbone/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_timm_backbone import *
+ from .modeling_timm_backbone import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/timm_backbone/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timm_backbone/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c488bf5a65de31aef2b535d6dab7ec1801a277a
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timm_backbone/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timm_backbone/__pycache__/configuration_timm_backbone.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timm_backbone/__pycache__/configuration_timm_backbone.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4697990288e6e9816f78d60972869fa9ff5c3d31
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timm_backbone/__pycache__/configuration_timm_backbone.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timm_backbone/__pycache__/modeling_timm_backbone.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timm_backbone/__pycache__/modeling_timm_backbone.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d664ce16a5a83c0ee5920cafe07b7c709892804
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timm_backbone/__pycache__/modeling_timm_backbone.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timm_backbone/configuration_timm_backbone.py b/lib/python3.11/site-packages/transformers/models/timm_backbone/configuration_timm_backbone.py
new file mode 100644
index 0000000000000000000000000000000000000000..15c0a9cd8d280e835ea53a2b724831d2c1fe807c
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timm_backbone/configuration_timm_backbone.py
@@ -0,0 +1,90 @@
+# Copyright 2023 The HuggingFace Inc. 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.
+
+"""Configuration for Backbone models"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import BackboneConfigMixin
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="")
+@strict
+class TimmBackboneConfig(BackboneConfigMixin, PreTrainedConfig):
+ r"""
+ backbone (`str`, *optional*):
+ The timm checkpoint to load.
+ features_only (`bool`, *optional*, defaults to `True`):
+ Whether to output only the features or also the logits.
+ freeze_batch_norm_2d (`bool`, *optional*, defaults to `False`):
+ Converts all `BatchNorm2d` and `SyncBatchNorm` layers of provided module into `FrozenBatchNorm2d`.
+
+ Example:
+ ```python
+ >>> from transformers import TimmBackboneConfig, TimmBackbone
+
+ >>> # Initializing a timm backbone
+ >>> configuration = TimmBackboneConfig("resnet50")
+
+ >>> # Initializing a model from the configuration
+ >>> model = TimmBackbone(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```
+ """
+
+ model_type = "timm_backbone"
+
+ backbone: str | None = None
+ num_channels: int = 3
+ features_only: bool = True
+ _out_indices: list[int] | None = None
+ freeze_batch_norm_2d: bool = False
+ output_stride: int | None = None
+
+ def __post_init__(self, **kwargs):
+ self.out_indices = self.out_indices if self.out_indices is not None else [-1]
+ super().__post_init__(**kwargs)
+
+ @property
+ def out_indices(self):
+ return self._out_indices
+
+ @out_indices.setter
+ def out_indices(self, out_indices: tuple[int, ...] | list[int]):
+ """
+ Set the out_indices attribute. This will also update the out_features attribute to match the new out_indices.
+ """
+ self._out_indices = list(out_indices) if out_indices is not None else out_indices
+ if getattr(self, "stage_names", None) is not None:
+ self.set_output_features_output_indices(out_features=None, out_indices=out_indices)
+
+ @property
+ def out_features(self):
+ return self._out_features
+
+ @out_features.setter
+ def out_features(self, out_features: list[str]):
+ """
+ Set the out_features attribute. This will also update the out_indices attribute to match the new out_features.
+ """
+ self._out_features = out_features
+ if getattr(self, "stage_names", None) is not None:
+ self.set_output_features_output_indices(out_features=out_features, out_indices=None)
+
+
+__all__ = ["TimmBackboneConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/timm_backbone/modeling_timm_backbone.py b/lib/python3.11/site-packages/transformers/models/timm_backbone/modeling_timm_backbone.py
new file mode 100644
index 0000000000000000000000000000000000000000..c60606a7657ec9e9648ff808b5461337ae67a784
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timm_backbone/modeling_timm_backbone.py
@@ -0,0 +1,161 @@
+# Copyright 2023 The HuggingFace Inc. 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 torch
+from torch import Tensor, nn
+
+from ... import initialization as init
+from ...backbone_utils import BackboneMixin, filter_output_hidden_states
+from ...modeling_outputs import BackboneOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import is_timm_available, requires_backends
+from ...utils.generic import can_return_tuple
+from .configuration_timm_backbone import TimmBackboneConfig
+
+
+if is_timm_available():
+ import timm
+
+
+class TimmBackbone(BackboneMixin, PreTrainedModel):
+ """
+ Wrapper class for timm models to be used as backbones. This enables using the timm models interchangeably with the
+ other models in the library keeping the same API.
+ """
+
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ supports_gradient_checkpointing = False
+ config: TimmBackboneConfig
+
+ def __init__(self, config, **kwargs):
+ requires_backends(self, "timm")
+
+ if config.backbone is None:
+ raise ValueError("backbone is not set in the config. Please set it to a timm model name.")
+
+ # We just take the final layer by default. This matches the default for the transformers models.
+ out_indices = config.out_indices if getattr(config, "out_indices", None) is not None else (-1,)
+ pretrained = kwargs.pop("pretrained", False)
+ in_chans = kwargs.pop("in_chans", config.num_channels)
+
+ backbone = timm.create_model(
+ config.backbone,
+ pretrained=pretrained,
+ # This is currently not possible for transformer architectures.
+ features_only=config.features_only,
+ in_chans=in_chans,
+ out_indices=out_indices,
+ output_stride=config.output_stride,
+ **kwargs,
+ )
+
+ # Needs to be called after creating timm model, because `super()` will try to infer
+ # `stage_names` from model architecture
+ super().__init__(config, timm_backbone=backbone)
+ self._backbone = backbone
+
+ # Converts all `BatchNorm2d` and `SyncBatchNorm` or `BatchNormAct2d` and `SyncBatchNormAct2d` layers of
+ # provided module into `FrozenBatchNorm2d` or `FrozenBatchNormAct2d` respectively
+ if getattr(config, "freeze_batch_norm_2d", False):
+ self.freeze_batch_norm_2d()
+
+ # These are used to control the output of the model when called. If output_hidden_states is True, then
+ # return_layers is modified to include all layers.
+ self._return_layers = {
+ layer["module"]: str(layer["index"]) for layer in self._backbone.feature_info.get_dicts()
+ }
+ self._all_layers = {layer["module"]: str(i) for i, layer in enumerate(self._backbone.feature_info.info)}
+
+ self.post_init()
+
+ @classmethod
+ def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):
+ requires_backends(cls, ["vision", "timm"])
+
+ config = kwargs.pop("config", TimmBackboneConfig())
+ num_channels = kwargs.pop("num_channels", config.num_channels)
+ features_only = kwargs.pop("features_only", config.features_only)
+ out_indices = kwargs.pop("out_indices", config.out_indices)
+ config = TimmBackboneConfig(
+ backbone=pretrained_model_name_or_path,
+ num_channels=num_channels,
+ features_only=features_only,
+ out_indices=out_indices,
+ )
+ return super()._from_config(config, pretrained=True, **kwargs)
+
+ def freeze_batch_norm_2d(self):
+ timm.utils.model.freeze_batch_norm_2d(self._backbone)
+
+ def unfreeze_batch_norm_2d(self):
+ timm.utils.model.unfreeze_batch_norm_2d(self._backbone)
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """We need to at least re-init the non-persistent buffers if the model was initialized on meta device (we
+ assume weights and persistent buffers will be part of checkpoint as we have no way to control timm inits)"""
+ if hasattr(module, "init_non_persistent_buffers"):
+ module.init_non_persistent_buffers()
+ elif isinstance(module, nn.BatchNorm2d):
+ # For non-pretrained models, always initialize buffers (handles both meta device and to_empty() cases)
+ running_mean = getattr(module, "running_mean", None)
+ if running_mean is not None:
+ init.zeros_(module.running_mean)
+ init.ones_(module.running_var)
+ init.zeros_(module.num_batches_tracked)
+
+ @can_return_tuple
+ @filter_output_hidden_states
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> BackboneOutput | tuple[Tensor, ...]:
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+
+ if output_attentions:
+ raise ValueError("Cannot output attentions for timm backbones at the moment")
+
+ if output_hidden_states:
+ # We modify the return layers to include all the stages of the backbone
+ self._backbone.return_layers = self._all_layers
+ hidden_states = self._backbone(pixel_values, **kwargs)
+ self._backbone.return_layers = self._return_layers
+ feature_maps = tuple(hidden_states[i] for i in self.out_indices)
+ else:
+ feature_maps = self._backbone(pixel_values, **kwargs)
+ hidden_states = None
+
+ feature_maps = tuple(feature_maps)
+ hidden_states = tuple(hidden_states) if hidden_states is not None else None
+
+ if not return_dict:
+ output = (feature_maps,)
+ if output_hidden_states:
+ output = output + (hidden_states,)
+ return output
+
+ return BackboneOutput(feature_maps=feature_maps, hidden_states=hidden_states, attentions=None)
+
+
+__all__ = ["TimmBackbone"]
diff --git a/lib/python3.11/site-packages/transformers/models/timm_wrapper/__init__.py b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..be5cbab568a23814888cf71bcdaddc7a7b199e00
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2024 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_timm_wrapper import *
+ from .image_processing_timm_wrapper import *
+ from .modeling_timm_wrapper import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..471aa32ec54ccf2dd31fd80b33c471d7acd85e87
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/configuration_timm_wrapper.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/configuration_timm_wrapper.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1331856cbc6cdacb88d3a560a7768dfa1a897321
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/configuration_timm_wrapper.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/image_processing_timm_wrapper.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/image_processing_timm_wrapper.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..31efcdb33c8c6e3d92af883bd01531619676ac26
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/image_processing_timm_wrapper.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/modeling_timm_wrapper.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/modeling_timm_wrapper.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e3c26aca7f1b5a7740662ad90b013a1ccc28801
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/timm_wrapper/__pycache__/modeling_timm_wrapper.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/timm_wrapper/configuration_timm_wrapper.py b/lib/python3.11/site-packages/transformers/models/timm_wrapper/configuration_timm_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d4a5fae3b6e11ae7cc1556b2c3f0c736c6395d3
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timm_wrapper/configuration_timm_wrapper.py
@@ -0,0 +1,112 @@
+# Copyright 2024 The HuggingFace Inc. 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.
+
+"""Configuration for TimmWrapper models"""
+
+from typing import Any
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring, is_timm_available, requires_backends
+
+
+if is_timm_available():
+ from timm.data import ImageNetInfo, infer_imagenet_subset
+
+
+@auto_docstring(checkpoint="resnet50")
+@strict
+class TimmWrapperConfig(PreTrainedConfig):
+ r"""
+ architecture (`str`, *optional*, defaults to `"resnet50"`):
+ The timm architecture to load.
+ do_pooling (`bool`, *optional*, defaults to `True`):
+ Whether to do pooling for the last_hidden_state in `TimmWrapperModel` or not.
+ model_args (`dict[str, Any]`, *optional*):
+ Additional keyword arguments to pass to the `timm.create_model` function. e.g. `model_args={"depth": 3}`
+ for `timm/vit_base_patch32_clip_448.laion2b_ft_in12k_in1k` to create a model with 3 blocks. Defaults to `None`.
+
+ Example:
+ ```python
+ >>> from transformers import TimmWrapperModel
+
+ >>> # Initializing a timm model
+ >>> model = TimmWrapperModel.from_pretrained("timm/resnet18.a1_in1k")
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```
+ """
+
+ model_type = "timm_wrapper"
+
+ architecture: str = "resnet50"
+ initializer_range: float = 0.02
+ do_pooling: bool = True
+ model_args: dict[str, Any] | None = None
+
+ @classmethod
+ def from_dict(cls, config_dict: dict[str, Any], **kwargs):
+ # Create a copy to avoid mutating the original dict
+ config_dict = config_dict.copy()
+
+ label_names = config_dict.get("label_names")
+ is_custom_model = "num_labels" in kwargs or "id2label" in kwargs
+
+ # if no labels added to config, use imagenet labeller in timm
+ if label_names is None and not is_custom_model:
+ requires_backends(cls, ["timm"])
+ imagenet_subset = infer_imagenet_subset(config_dict)
+ if imagenet_subset:
+ dataset_info = ImageNetInfo(imagenet_subset)
+ synsets = dataset_info.label_names()
+ label_descriptions = dataset_info.label_descriptions(as_dict=True)
+ label_names = [label_descriptions[synset] for synset in synsets]
+
+ if label_names is not None and not is_custom_model:
+ kwargs["id2label"] = dict(enumerate(label_names))
+
+ # if all label names are unique, create label2id mapping as well
+ if len(set(label_names)) == len(label_names):
+ kwargs["label2id"] = {name: i for i, name in enumerate(label_names)}
+ else:
+ kwargs["label2id"] = None
+
+ # timm config stores the `num_classes` attribute in both the root of config and in the "pretrained_cfg" dict.
+ # We are removing these attributes in order to have the native `transformers` num_labels attribute in config
+ # and to avoid duplicate attributes
+ num_labels_in_kwargs = kwargs.pop("num_labels", None)
+ num_labels_in_dict = config_dict.pop("num_classes", None)
+
+ # passed num_labels has priority over num_classes in config_dict
+ kwargs["num_labels"] = num_labels_in_kwargs or num_labels_in_dict
+
+ # pop num_classes from "pretrained_cfg",
+ # it is not necessary to have it, only root one is used in timm
+ if "pretrained_cfg" in config_dict and "num_classes" in config_dict["pretrained_cfg"]:
+ config_dict["pretrained_cfg"].pop("num_classes", None)
+
+ return super().from_dict(config_dict, **kwargs)
+
+ def to_dict(self) -> dict[str, Any]:
+ output = super().to_dict()
+ output.setdefault("num_classes", self.num_labels)
+ output.setdefault("label_names", list(self.id2label.values()))
+ output.pop("id2label", None)
+ output.pop("label2id", None)
+ return output
+
+
+__all__ = ["TimmWrapperConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/timm_wrapper/image_processing_timm_wrapper.py b/lib/python3.11/site-packages/transformers/models/timm_wrapper/image_processing_timm_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..05c0694026ab010a23a2c23d74c301077ee31940
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timm_wrapper/image_processing_timm_wrapper.py
@@ -0,0 +1,138 @@
+# Copyright 2024 The HuggingFace Inc. 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
+from typing import Any
+
+import torch
+
+from ...image_processing_utils import BaseImageProcessor, BatchFeature
+from ...image_transforms import to_pil_image
+from ...image_utils import ImageInput, make_flat_list_of_images
+from ...utils import TensorType, logging, requires_backends
+from ...utils.import_utils import is_timm_available, is_torch_available, requires
+
+
+if is_timm_available():
+ import timm
+
+if is_torch_available():
+ import torch
+
+
+logger = logging.get_logger(__name__)
+
+
+@requires(backends=("torch", "timm", "torchvision"))
+class TimmWrapperImageProcessor(BaseImageProcessor):
+ """
+ Wrapper class for timm models to be used within transformers.
+
+ Args:
+ pretrained_cfg (`dict[str, Any]`):
+ The configuration of the pretrained model used to resolve evaluation and
+ training transforms.
+ architecture (`Optional[str]`, *optional*):
+ Name of the architecture of the model.
+ """
+
+ main_input_name = "pixel_values"
+
+ def __init__(
+ self,
+ pretrained_cfg: dict[str, Any],
+ architecture: str | None = None,
+ **kwargs,
+ ):
+ requires_backends(self, "timm")
+ super().__init__(architecture=architecture)
+
+ self.data_config = timm.data.resolve_data_config(pretrained_cfg, model=None, verbose=False)
+ self.val_transforms = timm.data.create_transform(**self.data_config, is_training=False)
+
+ # useful for training, see examples/pytorch/image-classification/run_image_classification.py
+ self.train_transforms = timm.data.create_transform(**self.data_config, is_training=True)
+
+ # If `ToTensor` is in the transforms, then the input should be numpy array or PIL image.
+ # Otherwise, the input can be a tensor. In later timm versions, `MaybeToTensor` is used
+ # which can handle both numpy arrays / PIL images and tensors.
+ self._not_supports_tensor_input = any(
+ transform.__class__.__name__ == "ToTensor" for transform in self.val_transforms.transforms
+ )
+
+ def to_dict(self) -> dict[str, Any]:
+ """
+ Serializes this instance to a Python dictionary.
+ """
+ output = super().to_dict()
+ output.pop("train_transforms", None)
+ output.pop("val_transforms", None)
+ output.pop("_not_supports_tensor_input", None)
+ return output
+
+ @classmethod
+ def get_image_processor_dict(
+ cls, pretrained_model_name_or_path: str | os.PathLike, **kwargs
+ ) -> tuple[dict[str, Any], dict[str, Any]]:
+ """
+ Get the image processor dict for the model.
+ """
+ image_processor_filename = kwargs.pop("image_processor_filename", "config.json")
+ return super().get_image_processor_dict(
+ pretrained_model_name_or_path, image_processor_filename=image_processor_filename, **kwargs
+ )
+
+ def preprocess(
+ self,
+ images: ImageInput,
+ return_tensors: str | TensorType | None = "pt",
+ ) -> BatchFeature:
+ """
+ Preprocess an image or batch of images.
+
+ Args:
+ images (`ImageInput`):
+ Image to preprocess. Expects a single or batch of images
+ return_tensors (`str` or `TensorType`, *optional*):
+ The type of tensors to return.
+ """
+ if return_tensors != "pt":
+ raise ValueError(f"return_tensors for TimmWrapperImageProcessor must be 'pt', but got {return_tensors}")
+
+ if self._not_supports_tensor_input and isinstance(images, torch.Tensor):
+ images = images.cpu().numpy()
+
+ # If the input is a torch tensor, then no conversion is needed
+ # Otherwise, we need to pass in a list of PIL images
+ if isinstance(images, torch.Tensor):
+ images = self.val_transforms(images)
+ # Add batch dimension if a single image
+ images = images.unsqueeze(0) if images.ndim == 3 else images
+ else:
+ images = make_flat_list_of_images(images)
+ images = [to_pil_image(image) for image in images]
+ images = torch.stack([self.val_transforms(image) for image in images])
+
+ return BatchFeature({"pixel_values": images}, tensor_type=return_tensors)
+
+ def save_pretrained(self, *args, **kwargs):
+ # disable it to make checkpoint the same as in `timm` library.
+ logger.warning_once(
+ "The `save_pretrained` method is disabled for TimmWrapperImageProcessor. "
+ "The image processor configuration is saved directly in `config.json` when "
+ "`save_pretrained` is called for saving the model."
+ )
+
+
+__all__ = ["TimmWrapperImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/timm_wrapper/modeling_timm_wrapper.py b/lib/python3.11/site-packages/transformers/models/timm_wrapper/modeling_timm_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f956901df2193cb0be90a50746b83630d6e4389
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/timm_wrapper/modeling_timm_wrapper.py
@@ -0,0 +1,400 @@
+# Copyright 2024 The HuggingFace Inc. 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 dataclasses import dataclass
+
+import torch
+from torch import Tensor, nn
+
+from ... import initialization as init
+from ...modeling_outputs import ImageClassifierOutput, ModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring, is_timm_available, requires_backends
+from .configuration_timm_wrapper import TimmWrapperConfig
+
+
+if is_timm_available():
+ import timm
+
+
+@auto_docstring(
+ custom_intro="""
+ Output class for models TimmWrapperModel, containing the last hidden states, an optional pooled output,
+ and optional hidden states.
+ """
+)
+@dataclass
+class TimmWrapperModelOutput(ModelOutput):
+ r"""
+ last_hidden_state (`torch.FloatTensor`):
+ The last hidden state of the model, output before applying the classification head.
+ pooler_output (`torch.FloatTensor`, *optional*):
+ The pooled output derived from the last hidden state, if applicable.
+ hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned if `output_hidden_states=True` is set or if `config.output_hidden_states=True`):
+ A tuple containing the intermediate hidden states of the model at the output of each layer or specified layers.
+ attentions (`tuple(torch.FloatTensor)`, *optional*, returned if `output_attentions=True` is set or if `config.output_attentions=True`.):
+ A tuple containing the intermediate attention weights of the model at the output of each layer.
+ Note: Currently, Timm models do not support attentions output.
+ """
+
+ last_hidden_state: torch.FloatTensor
+ pooler_output: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+
+
+def _create_timm_model_with_error_handling(config: "TimmWrapperConfig", **model_kwargs):
+ """
+ Creates a timm model and provides a clear error message if the model is not found,
+ suggesting a library update.
+ """
+ try:
+ model = timm.create_model(
+ config.architecture,
+ pretrained=False,
+ **model_kwargs,
+ )
+ return model
+ except RuntimeError as e:
+ if "Unknown model" in str(e):
+ # A good general check for unknown models.
+ raise ImportError(
+ f"The model architecture '{config.architecture}' is not supported in your version of timm ({timm.__version__}). "
+ "Please upgrade timm to a more recent version with `pip install -U timm`."
+ ) from e
+ raise e
+
+
+@auto_docstring
+class TimmWrapperPreTrainedModel(PreTrainedModel):
+ base_model_prefix = "timm_model"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ config: TimmWrapperConfig
+ # add WA here as `timm` does not support model parallelism
+ _no_split_modules = ["TimmWrapperModel"]
+ model_tags = ["timm"]
+
+ # used in Trainer to avoid passing `loss_kwargs` to model forward
+ accepts_loss_kwargs = False
+
+ def post_init(self):
+ self.supports_gradient_checkpointing = self._timm_model_supports_gradient_checkpointing()
+ super().post_init()
+
+ def load_state_dict(self, state_dict, *args, **kwargs):
+ """
+ Override original method to fix state_dict keys on load for cases when weights are loaded
+ without using the `from_pretrained` method (e.g., in Trainer to resume from checkpoint).
+ """
+ state_dict = {f"timm_model.{k}" if "timm_model." not in k else k: v for k, v in state_dict.items()}
+ return super().load_state_dict(state_dict, *args, **kwargs)
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """
+ Initialize weights function to properly initialize Linear layer weights.
+ Since model architectures may vary, we assume only the classifier requires
+ initialization, while all other weights should be loaded from the checkpoint.
+ """
+ if isinstance(module, nn.Linear):
+ init.normal_(module.weight, mean=0.0, std=self.config.initializer_range)
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ # Also, reinit all non-persistent buffers if any!
+ if hasattr(module, "init_non_persistent_buffers"):
+ module.init_non_persistent_buffers()
+ elif (
+ hasattr(module, "_get_pos_embed_values")
+ and hasattr(module, "feat_shape")
+ and module.feat_shape is not None
+ ):
+ module.pos_embed = module._get_pos_embed_values(
+ feat_shape=module.feat_shape,
+ device=module.pos_embed.device if module.pos_embed is not None else None,
+ dtype=module.pos_embed.dtype if module.pos_embed is not None else torch.float32,
+ )
+ elif isinstance(module, nn.BatchNorm2d):
+ # TimmWrapper always creates models with pretrained=False, so buffers are never pre-loaded
+ # Always initialize buffers (handles both meta device and to_empty() cases)
+ running_mean = getattr(module, "running_mean", None)
+ if running_mean is not None:
+ init.zeros_(module.running_mean)
+ init.ones_(module.running_var)
+ init.zeros_(module.num_batches_tracked)
+
+ def _timm_model_supports_gradient_checkpointing(self):
+ """
+ Check if the timm model supports gradient checkpointing by checking if the `set_grad_checkpointing` method is available.
+ Some timm models will have the method but will raise an AssertionError when called so in this case we return False.
+ """
+ if not hasattr(self.timm_model, "set_grad_checkpointing"):
+ return False
+
+ try:
+ self.timm_model.set_grad_checkpointing(enable=True)
+ self.timm_model.set_grad_checkpointing(enable=False)
+ return True
+ except Exception:
+ return False
+
+ def _set_gradient_checkpointing(self, enable: bool = True, *args, **kwargs):
+ self.timm_model.set_grad_checkpointing(enable)
+
+ def get_input_embeddings(self):
+ # TIMM backbones operate directly on images and do not expose token embeddings.
+ return None
+
+ def set_input_embeddings(self, value):
+ raise NotImplementedError("TimmWrapper models do not own token embeddings and cannot set them.")
+
+
+class TimmWrapperModel(TimmWrapperPreTrainedModel):
+ """
+ Wrapper class for timm models to be used in transformers.
+ """
+
+ def __init__(self, config: TimmWrapperConfig):
+ requires_backends(self, ["vision", "timm"])
+ super().__init__(config)
+ # using num_classes=0 to avoid creating classification head
+ extra_init_kwargs = config.model_args or {}
+ self.features_only = extra_init_kwargs.get("features_only", False)
+ self.timm_model = _create_timm_model_with_error_handling(config, num_classes=0, **extra_init_kwargs)
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | list[int] | None = None,
+ return_dict: bool | None = None,
+ do_pooling: bool | None = None,
+ use_cache: bool | None = None,
+ **kwargs,
+ ) -> TimmWrapperModelOutput | tuple[Tensor, ...]:
+ r"""
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. Not compatible with timm wrapped models.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. Not compatible with timm wrapped models.
+ do_pooling (`bool`, *optional*):
+ Whether to do pooling for the last_hidden_state in `TimmWrapperModel` or not. If `None` is passed, the
+ `do_pooling` value from the config is used.
+
+ Examples:
+ ```python
+ >>> import torch
+ >>> from PIL import Image
+ >>> from urllib.request import urlopen
+ >>> from transformers import AutoModel, AutoImageProcessor
+
+ >>> # Load image
+ >>> image = Image.open(urlopen(
+ ... 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
+ ... ))
+
+ >>> # Load model and image processor
+ >>> checkpoint = "timm/resnet50.a1_in1k"
+ >>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
+ >>> model = AutoModel.from_pretrained(checkpoint).eval()
+
+ >>> # Preprocess image
+ >>> inputs = image_processor(image)
+
+ >>> # Forward pass
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> # Get pooled output
+ >>> pooled_output = outputs.pooler_output
+
+ >>> # Get last hidden state
+ >>> last_hidden_state = outputs.last_hidden_state
+ ```
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ do_pooling = do_pooling if do_pooling is not None else self.config.do_pooling
+
+ if output_attentions:
+ raise ValueError("Cannot set `output_attentions` for timm models.")
+
+ if output_hidden_states and not hasattr(self.timm_model, "forward_intermediates"):
+ raise ValueError(
+ "The 'output_hidden_states' option cannot be set for this timm model. "
+ "To enable this feature, the 'forward_intermediates' method must be implemented "
+ "in the timm model (available in timm versions > 1.*). Please consider using a "
+ "different architecture or updating the timm package to a compatible version."
+ )
+
+ pixel_values = pixel_values.to(self.device, self.dtype)
+
+ if self.features_only:
+ last_hidden_state = self.timm_model.forward(pixel_values, **kwargs)
+ hidden_states = last_hidden_state if output_hidden_states else None
+ pooler_output = None
+ else:
+ if output_hidden_states:
+ # to enable hidden states selection
+ if isinstance(output_hidden_states, (list, tuple)):
+ kwargs["indices"] = output_hidden_states
+ last_hidden_state, hidden_states = self.timm_model.forward_intermediates(pixel_values, **kwargs)
+ else:
+ last_hidden_state = self.timm_model.forward_features(pixel_values, **kwargs)
+ hidden_states = None
+
+ if do_pooling:
+ # classification head is not created, applying pooling only
+ pooler_output = self.timm_model.forward_head(last_hidden_state)
+ else:
+ pooler_output = None
+
+ if not return_dict:
+ outputs = (last_hidden_state, pooler_output, hidden_states)
+ outputs = tuple(output for output in outputs if output is not None)
+ return outputs
+
+ return TimmWrapperModelOutput(
+ last_hidden_state=last_hidden_state,
+ pooler_output=pooler_output,
+ hidden_states=hidden_states,
+ )
+
+
+class TimmWrapperForImageClassification(TimmWrapperPreTrainedModel):
+ """
+ Wrapper class for timm models to be used in transformers for image classification.
+ """
+
+ def __init__(self, config: TimmWrapperConfig):
+ requires_backends(self, ["vision", "timm"])
+ super().__init__(config)
+
+ if config.num_labels == 0:
+ raise ValueError(
+ "You are trying to load weights into `TimmWrapperForImageClassification` from a checkpoint with no classifier head. "
+ "Please specify the number of classes, e.g. `model = TimmWrapperForImageClassification.from_pretrained(..., num_labels=10)`, "
+ "or use `TimmWrapperModel` for feature extraction."
+ )
+
+ extra_init_kwargs = config.model_args or {}
+ self.timm_model = _create_timm_model_with_error_handling(
+ config, num_classes=config.num_labels, **extra_init_kwargs
+ )
+ self.num_labels = config.num_labels
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ labels: torch.LongTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | list[int] | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> ImageClassifierOutput | tuple[Tensor, ...]:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. Not compatible with timm wrapped models.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. Not compatible with timm wrapped models.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+ **kwargs:
+ Additional keyword arguments passed along to the `timm` model forward.
+
+ Examples:
+ ```python
+ >>> import torch
+ >>> from PIL import Image
+ >>> from urllib.request import urlopen
+ >>> from transformers import AutoModelForImageClassification, AutoImageProcessor
+
+ >>> # Load image
+ >>> image = Image.open(urlopen(
+ ... 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
+ ... ))
+
+ >>> # Load model and image processor
+ >>> checkpoint = "timm/resnet50.a1_in1k"
+ >>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
+ >>> model = AutoModelForImageClassification.from_pretrained(checkpoint).eval()
+
+ >>> # Preprocess image
+ >>> inputs = image_processor(image)
+
+ >>> # Forward pass
+ >>> with torch.no_grad():
+ ... logits = model(**inputs).logits
+
+ >>> # Get top 5 predictions
+ >>> top5_probabilities, top5_class_indices = torch.topk(logits.softmax(dim=1) * 100, k=5)
+ ```
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+
+ if output_attentions:
+ raise ValueError("Cannot set `output_attentions` for timm models.")
+
+ if output_hidden_states and not hasattr(self.timm_model, "forward_intermediates"):
+ raise ValueError(
+ "The 'output_hidden_states' option cannot be set for this timm model. "
+ "To enable this feature, the 'forward_intermediates' method must be implemented "
+ "in the timm model (available in timm versions > 1.*). Please consider using a "
+ "different architecture or updating the timm package to a compatible version."
+ )
+
+ pixel_values = pixel_values.to(self.device, self.dtype)
+
+ if output_hidden_states:
+ # to enable hidden states selection
+ if isinstance(output_hidden_states, (list, tuple)):
+ kwargs["indices"] = output_hidden_states
+ last_hidden_state, hidden_states = self.timm_model.forward_intermediates(pixel_values, **kwargs)
+ logits = self.timm_model.forward_head(last_hidden_state)
+ else:
+ logits = self.timm_model(pixel_values, **kwargs)
+ hidden_states = None
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config)
+
+ if not return_dict:
+ outputs = (loss, logits, hidden_states)
+ outputs = tuple(output for output in outputs if output is not None)
+ return outputs
+
+ return ImageClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=hidden_states,
+ )
+
+
+__all__ = ["TimmWrapperPreTrainedModel", "TimmWrapperModel", "TimmWrapperForImageClassification"]
diff --git a/lib/python3.11/site-packages/transformers/models/trocr/__init__.py b/lib/python3.11/site-packages/transformers/models/trocr/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..96ae1927c1b56002e6d3cf20f1fea145854f53f3
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/trocr/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2024 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_trocr import *
+ from .modeling_trocr import *
+ from .processing_trocr import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..15de033a20035d989d10240c2f2b9c765b8d953f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/configuration_trocr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/configuration_trocr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7938d1d50b42c9904da689d04bec3fdb35085787
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/configuration_trocr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/modeling_trocr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/modeling_trocr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e10231fe07ef13ac2289034531cfdc105ed9ed2
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/modeling_trocr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/processing_trocr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/processing_trocr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a870cc0a769ea30650a8a4e3f2f08648bfd9adce
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/trocr/__pycache__/processing_trocr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/trocr/configuration_trocr.py b/lib/python3.11/site-packages/transformers/models/trocr/configuration_trocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..689471190af005eb0193461fca1811d429ac8a31
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/trocr/configuration_trocr.py
@@ -0,0 +1,79 @@
+# Copyright 2021 The HuggingFace Inc. 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.
+"""TrOCR model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="microsoft/trocr-base-handwritten")
+@strict
+class TrOCRConfig(PreTrainedConfig):
+ r"""
+ use_learned_position_embeddings (`bool`, *optional*, defaults to `True`):
+ Whether or not to use learned position embeddings. If not, sinusoidal position embeddings will be used.
+ layernorm_embedding (`bool`, *optional*, defaults to `True`):
+ Whether or not to use a layernorm after the word + position embeddings.
+
+ Example:
+
+ ```python
+ >>> from transformers import TrOCRConfig, TrOCRForCausalLM
+
+ >>> # Initializing a TrOCR-base style configuration
+ >>> configuration = TrOCRConfig()
+
+ >>> # Initializing a model (with random weights) from the TrOCR-base style configuration
+ >>> model = TrOCRForCausalLM(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "trocr"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ attribute_map = {
+ "num_attention_heads": "decoder_attention_heads",
+ "hidden_size": "d_model",
+ "num_hidden_layers": "decoder_layers",
+ }
+
+ vocab_size: int = 50265
+ d_model: int = 1024
+ decoder_layers: int = 12
+ decoder_attention_heads: int = 16
+ decoder_ffn_dim: int = 4096
+ activation_function: str = "gelu"
+ max_position_embeddings: int = 512
+ dropout: float | int = 0.1
+ attention_dropout: float | int = 0.0
+ activation_dropout: float | int = 0.0
+ decoder_start_token_id: int = 2
+ init_std: float = 0.02
+ decoder_layerdrop: float | int = 0.0
+ use_cache: bool = True
+ scale_embedding: bool = False
+ use_learned_position_embeddings: bool = True
+ layernorm_embedding: bool = True
+ pad_token_id: int | None = 1
+ bos_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 2
+ cross_attention_hidden_size: int | None = None
+ is_decoder: bool = False
+ tie_word_embeddings: bool = True
+
+
+__all__ = ["TrOCRConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/trocr/modeling_trocr.py b/lib/python3.11/site-packages/transformers/models/trocr/modeling_trocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..74f2e82384a534eeb47c04c3f4acd4f4deb6f5f5
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/trocr/modeling_trocr.py
@@ -0,0 +1,777 @@
+# Copyright 2021 The Fairseq Authors and The HuggingFace Inc. 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.
+"""PyTorch TrOCR decoder model (based on RoBERTa)."""
+
+import math
+
+import torch
+from torch import nn
+from torch.nn import CrossEntropyLoss
+
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutputWithPastAndCrossAttentions, CausalLMOutputWithCrossAttentions
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring, logging
+from .configuration_trocr import TrOCRConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+# Copied from transformers.models.bart.modeling_bart.BartLearnedPositionalEmbedding with Bart->TrOCR
+class TrOCRLearnedPositionalEmbedding(nn.Embedding):
+ """
+ This module learns positional embeddings up to a fixed maximum size.
+ """
+
+ def __init__(self, num_embeddings: int, embedding_dim: int):
+ # TrOCR is set up so that if padding_idx is specified then offset the embedding ids by 2
+ # and adjust num_embeddings appropriately. Other models don't have this hack
+ self.offset = 2
+ super().__init__(num_embeddings + self.offset, embedding_dim)
+
+ def forward(
+ self, input_ids: torch.Tensor, past_key_values_length: int = 0, position_ids: torch.Tensor | None = None
+ ):
+ """`input_ids' shape is expected to be [bsz x seqlen]."""
+
+ if position_ids is None:
+ bsz, seq_len = input_ids.shape[:2]
+ position_ids = torch.arange(
+ past_key_values_length, past_key_values_length + seq_len, dtype=torch.long, device=self.weight.device
+ ).expand(bsz, -1)
+ else:
+ position_ids = position_ids.unsqueeze(0)
+
+ return super().forward(position_ids + self.offset)
+
+
+# Copied from transformers.models.bart.modeling_bart.BartScaledWordEmbedding with Bart->TrOCR
+class TrOCRScaledWordEmbedding(nn.Embedding):
+ """
+ This module overrides nn.Embeddings' forward by multiplying with embeddings scale.
+ """
+
+ def __init__(self, num_embeddings: int, embedding_dim: int, padding_idx: int, embed_scale: float | None = 1.0):
+ super().__init__(num_embeddings, embedding_dim, padding_idx)
+ self.embed_scale = embed_scale
+
+ def forward(self, input_ids: torch.Tensor):
+ return super().forward(input_ids) * self.embed_scale
+
+
+class TrOCRSinusoidalPositionalEmbedding(nn.Module):
+ """This module produces sinusoidal positional embeddings of any length."""
+
+ def __init__(self, num_positions: int, embedding_dim: int, padding_idx: int | None = None):
+ super().__init__()
+ self.offset = 2
+ self.embedding_dim = embedding_dim
+ self.padding_idx = padding_idx
+ self.weights = self.get_embedding(num_positions, embedding_dim, padding_idx)
+
+ @staticmethod
+ def get_embedding(num_embeddings: int, embedding_dim: int, padding_idx: int | None = None):
+ """
+ Build sinusoidal embeddings. This matches the implementation in tensor2tensor, but differs slightly from the
+ description in Section 3.5 of "Attention Is All You Need".
+ """
+ half_dim = embedding_dim // 2
+ emb = math.log(10000) / (half_dim - 1)
+ emb = torch.exp(torch.arange(half_dim, dtype=torch.int64).float() * -emb)
+ emb = torch.arange(num_embeddings, dtype=torch.int64).float().unsqueeze(1) * emb.unsqueeze(0)
+ emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1).view(num_embeddings, -1)
+ if embedding_dim % 2 == 1:
+ # zero pad
+ emb = torch.cat([emb, torch.zeros(num_embeddings, 1)], dim=1)
+ if padding_idx is not None:
+ emb[padding_idx, :] = 0
+
+ return emb.to(torch.get_default_dtype())
+
+ @torch.no_grad()
+ def forward(self, input_ids: torch.Tensor, past_key_values_length: int = 0):
+ bsz, seq_len = input_ids.size()
+ # Create the position ids from the input token ids. Any padded tokens remain padded.
+ position_ids = self.create_position_ids_from_input_ids(input_ids, self.padding_idx, past_key_values_length).to(
+ input_ids.device
+ )
+
+ # expand embeddings if needed
+ max_pos = self.padding_idx + 1 + seq_len
+ if self.weights is None or max_pos > self.weights.size(0):
+ # recompute/expand embeddings if needed
+ self.weights = self.get_embedding(max_pos, self.embedding_dim, self.padding_idx)
+
+ x = self.weights.index_select(0, position_ids.view(-1)).view(bsz, seq_len, -1).detach()
+
+ return x
+
+ def create_position_ids_from_input_ids(
+ self, input_ids: torch.Tensor, padding_idx: int, past_key_values_length: int | None = 0
+ ):
+ """
+ Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding
+ symbols are ignored. This is modified from fairseq's `utils.make_positions`.
+ """
+ # The series of casts and type-conversions here are carefully balanced to both work with ONNX export and XLA.
+ mask = input_ids.ne(padding_idx).int()
+ incremental_indices = (torch.cumsum(mask, dim=1).type_as(mask) + past_key_values_length) * mask
+ return incremental_indices.long() + padding_idx
+
+
+class TrOCRAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper."""
+
+ def __init__(
+ self,
+ config,
+ embed_dim: int,
+ num_heads: int,
+ kdim: int | None = None,
+ vdim: int | None = None,
+ dropout: float | None = 0.0,
+ is_decoder: bool | None = False,
+ bias: bool | None = True,
+ is_cross_attention: bool | None = False,
+ layer_idx: bool | None = None,
+ ):
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.kdim = kdim if kdim is not None else embed_dim
+ self.vdim = vdim if vdim is not None else embed_dim
+ self.num_heads = num_heads
+ self.dropout = dropout
+ self.head_dim = embed_dim // num_heads
+ if not (self.head_dim * num_heads == self.embed_dim):
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+ f" {num_heads})."
+ )
+ self.scaling = self.head_dim**-0.5
+ self.is_decoder = is_decoder
+ self.layer_idx = layer_idx
+
+ self.k_proj = nn.Linear(self.kdim, embed_dim, bias=bias)
+ self.v_proj = nn.Linear(self.vdim, embed_dim, bias=bias)
+ self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+ self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ key_value_states: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = False,
+ **kwargs,
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ """Input shape: Batch x Time x Channel"""
+
+ # if key_value_states are provided this layer is used as a cross-attention layer
+ # for the decoder
+ is_cross_attention = key_value_states is not None
+ bsz, tgt_len, embed_dim = hidden_states.size()
+
+ # get query proj
+ query_states = self.q_proj(hidden_states) * self.scaling
+
+ is_updated = False
+ if past_key_values is not None:
+ if isinstance(past_key_values, EncoderDecoderCache):
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ if is_cross_attention:
+ # after the first generated id, we can subsequently re-use all key/value_states from cache
+ curr_past_key_values = past_key_values.cross_attention_cache
+ else:
+ curr_past_key_values = past_key_values.self_attention_cache
+ else:
+ curr_past_key_values = past_key_values
+
+ current_states = key_value_states if is_cross_attention else hidden_states
+ if is_cross_attention and past_key_values is not None and is_updated:
+ # reuse k,v, cross_attentions
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+ else:
+ key_states = self.k_proj(current_states)
+ value_states = self.v_proj(current_states)
+ key_states = key_states.view(bsz, -1, self.num_heads, self.head_dim).transpose(1, 2)
+ value_states = value_states.view(bsz, -1, self.num_heads, self.head_dim).transpose(1, 2)
+
+ if past_key_values is not None:
+ # save all key/value_states to cache to be re-used for fast auto-regressive generation
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+ if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+ past_key_values.is_updated[self.layer_idx] = True
+
+ proj_shape = (bsz * self.num_heads, -1, self.head_dim)
+ query_states = query_states.view(bsz, tgt_len, self.num_heads, self.head_dim).transpose(1, 2)
+ query_states = query_states.reshape(*proj_shape)
+ key_states = key_states.reshape(*proj_shape)
+ value_states = value_states.reshape(*proj_shape)
+
+ src_len = key_states.size(1)
+ attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))
+
+ if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len):
+ raise ValueError(
+ f"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is"
+ f" {attn_weights.size()}"
+ )
+
+ if attention_mask is not None:
+ if attention_mask.size() != (bsz, 1, tgt_len, src_len):
+ raise ValueError(
+ f"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {attention_mask.size()}"
+ )
+ attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len) + attention_mask
+ attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+
+ if output_attentions:
+ # this operation is a bit awkward, but it's required to
+ # make sure that attn_weights keeps its gradient.
+ # In order to do so, attn_weights have to be reshaped
+ # twice and have to be reused in the following
+ attn_weights_reshaped = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
+ attn_weights = attn_weights_reshaped.view(bsz * self.num_heads, tgt_len, src_len)
+ else:
+ attn_weights_reshaped = None
+
+ attn_probs = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+ attn_output = torch.bmm(attn_probs, value_states)
+
+ if attn_output.size() != (bsz * self.num_heads, tgt_len, self.head_dim):
+ raise ValueError(
+ f"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is"
+ f" {attn_output.size()}"
+ )
+
+ attn_output = attn_output.view(bsz, self.num_heads, tgt_len, self.head_dim)
+ attn_output = attn_output.transpose(1, 2)
+ attn_output = attn_output.reshape(bsz, tgt_len, embed_dim)
+
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights_reshaped
+
+
+class TrOCRDecoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: TrOCRConfig, layer_idx=None):
+ super().__init__()
+ self.embed_dim = config.hidden_size
+
+ self.self_attn = TrOCRAttention(
+ config,
+ embed_dim=self.embed_dim,
+ num_heads=config.decoder_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=True,
+ layer_idx=layer_idx,
+ )
+ self.dropout = config.dropout
+ self.activation_fn = ACT2FN[config.activation_function]
+ self.activation_dropout = config.activation_dropout
+
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ if config.is_decoder:
+ self.encoder_attn = TrOCRAttention(
+ config,
+ embed_dim=self.embed_dim,
+ num_heads=config.decoder_attention_heads,
+ kdim=config.cross_attention_hidden_size,
+ vdim=config.cross_attention_hidden_size,
+ dropout=config.attention_dropout,
+ is_decoder=True,
+ is_cross_attention=True,
+ layer_idx=layer_idx,
+ )
+ self.encoder_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ self.fc1 = nn.Linear(self.embed_dim, config.decoder_ffn_dim)
+ self.fc2 = nn.Linear(config.decoder_ffn_dim, self.embed_dim)
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ encoder_hidden_states: torch.Tensor | None = None,
+ encoder_attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ output_attentions: bool | None = False,
+ use_cache: bool | None = True,
+ **kwargs,
+ ):
+ """
+ Args:
+ hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+ attention_mask (`torch.FloatTensor`): attention mask of size
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+ encoder_hidden_states (`torch.FloatTensor`):
+ cross attention input to the layer of shape `(batch, seq_len, embed_dim)`
+ encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+ past_key_values (`Cache`): cached past key and value projection states
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ """
+ residual = hidden_states
+
+ # Self Attention
+ hidden_states, self_attn_weights = self.self_attn(
+ hidden_states=hidden_states,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.self_attn_layer_norm(hidden_states)
+
+ # Cross-Attention Block
+ cross_attn_weights = None
+ if encoder_hidden_states is not None:
+ residual = hidden_states
+
+ hidden_states, cross_attn_weights = self.encoder_attn(
+ hidden_states=hidden_states,
+ key_value_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.encoder_attn_layer_norm(hidden_states)
+
+ # Fully Connected
+ residual = hidden_states
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+ hidden_states = self.fc2(hidden_states)
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+ hidden_states = residual + hidden_states
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (self_attn_weights, cross_attn_weights)
+
+ return outputs
+
+
+@auto_docstring
+class TrOCRPreTrainedModel(PreTrainedModel):
+ config: TrOCRConfig
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["TrOCRDecoderLayer"]
+
+
+class TrOCRDecoder(TrOCRPreTrainedModel):
+ """
+ Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`TrOCRDecoderLayer`]
+
+ Args:
+ config: TrOCRConfig
+ """
+
+ def __init__(self, config: TrOCRConfig):
+ super().__init__(config)
+ self.dropout = config.dropout
+ self.layerdrop = config.decoder_layerdrop
+ self.padding_idx = config.pad_token_id
+ embed_scale = math.sqrt(config.hidden_size) if config.scale_embedding else 1.0
+
+ self.embed_tokens = TrOCRScaledWordEmbedding(
+ config.vocab_size, config.hidden_size, self.padding_idx, embed_scale=embed_scale
+ )
+
+ if config.use_learned_position_embeddings:
+ self.embed_positions = TrOCRLearnedPositionalEmbedding(config.max_position_embeddings, config.hidden_size)
+ else:
+ self.embed_positions = TrOCRSinusoidalPositionalEmbedding(
+ config.max_position_embeddings + self.padding_idx + 1,
+ config.hidden_size,
+ self.padding_idx,
+ )
+
+ if config.layernorm_embedding:
+ self.layernorm_embedding = nn.LayerNorm(config.hidden_size)
+ else:
+ self.layernorm_embedding = None
+
+ self.layers = nn.ModuleList([TrOCRDecoderLayer(config, layer_idx=i) for i in range(config.decoder_layers)])
+
+ self.gradient_checkpointing = False
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def forward(
+ self,
+ input_ids=None,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ past_key_values=None,
+ inputs_embeds=None,
+ use_cache=None,
+ output_attentions=None,
+ output_hidden_states=None,
+ return_dict=None,
+ **kwargs,
+ ):
+ r"""
+ Args:
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you
+ provide it.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*):
+ Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
+ of the decoder.
+ encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, encoder_sequence_length)`, *optional*):
+ Mask to avoid performing cross-attention on padding tokens indices of encoder input_ids. Mask values
+ selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and in the
+ cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
+
+ If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those
+ that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of
+ all `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+ Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation.
+ This is useful if you want more control over how to convert `input_ids` indices into associated vectors
+ than the model's internal embedding lookup matrix.
+ output_attentions (`bool`, *optional*):
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+ returned tensors for more detail.
+ output_hidden_states (`bool`, *optional*):
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+ for more detail.
+ return_dict (`bool`, *optional*):
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # retrieve input_ids and inputs_embeds
+ if input_ids is not None and inputs_embeds is not None:
+ raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
+ elif input_ids is not None:
+ input = input_ids
+ input_ids = input_ids.view(-1, input.shape[-1])
+ elif inputs_embeds is not None:
+ input = inputs_embeds[:, :, -1]
+ else:
+ raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds")
+
+ if self.gradient_checkpointing and self.training:
+ if use_cache:
+ logger.warning_once(
+ "`use_cache = True` is incompatible with gradient checkpointing. Setting `use_cache = False`..."
+ )
+ use_cache = False
+
+ if use_cache and past_key_values is None:
+ past_key_values = (
+ EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache(config=self.config))
+ if encoder_hidden_states is not None or self.config.is_encoder_decoder
+ else DynamicCache(config=self.config)
+ )
+
+ past_key_values_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+
+ if inputs_embeds is None:
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if self.config.use_learned_position_embeddings:
+ embed_pos = self.embed_positions(input, past_key_values_length=past_key_values_length)
+ else:
+ embed_pos = self.embed_positions(input_ids, past_key_values_length=past_key_values_length)
+
+ hidden_states = inputs_embeds + embed_pos
+
+ if self.layernorm_embedding is not None:
+ hidden_states = self.layernorm_embedding(hidden_states)
+
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+ attention_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+
+ # expand encoder attention mask
+ if encoder_hidden_states is not None and encoder_attention_mask is not None:
+ encoder_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+
+ # decoder layers
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attns = () if output_attentions else None
+ all_cross_attentions = () if (output_attentions and encoder_hidden_states is not None) else None
+
+ for idx, decoder_layer in enumerate(self.layers):
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+ if self.training:
+ dropout_probability = torch.rand([])
+ if dropout_probability < self.layerdrop:
+ continue
+
+ layer_outputs = decoder_layer(
+ hidden_states,
+ attention_mask,
+ encoder_hidden_states, # as a positional argument for gradient checkpointing
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ use_cache=use_cache,
+ )
+ hidden_states = layer_outputs[0]
+
+ if output_attentions:
+ all_self_attns += (layer_outputs[1],)
+
+ if encoder_hidden_states is not None:
+ all_cross_attentions += (layer_outputs[2],)
+
+ # add hidden states from the last decoder layer
+ if output_hidden_states:
+ all_hidden_states += (hidden_states,)
+
+ if not return_dict:
+ return tuple(
+ v
+ for v in [hidden_states, past_key_values, all_hidden_states, all_self_attns, all_cross_attentions]
+ if v is not None
+ )
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attns,
+ cross_attentions=all_cross_attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ The TrOCR Model with a language modeling head. Can be used for summarization.
+ This wrapper class is a helper class to correctly load pretrained checkpoints when the causal language model is
+ used in combination with the [`EncoderDecoderModel`] framework.
+ """
+)
+class TrOCRDecoderWrapper(TrOCRPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.decoder = TrOCRDecoder(config)
+ self.post_init()
+
+ def forward(self, *args, **kwargs):
+ return self.decoder(*args, **kwargs)
+
+
+@auto_docstring(
+ custom_intro="""
+ The TrOCR Decoder with a language modeling head. Can be used as the decoder part of [`EncoderDecoderModel`] and
+ """
+)
+class TrOCRForCausalLM(TrOCRPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"output_projection.weight": "model.decoder.embed_tokens.weight"}
+
+ def __init__(self, config):
+ config.is_decoder = True
+ config.is_encoder_decoder = False
+ super().__init__(config)
+ self.model = TrOCRDecoderWrapper(config)
+
+ self.output_projection = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.model.decoder.embed_tokens
+
+ def set_input_embeddings(self, value):
+ self.model.decoder.embed_tokens = value
+
+ def get_output_embeddings(self):
+ return self.output_projection
+
+ def set_output_embeddings(self, new_embeddings):
+ self.output_projection = new_embeddings
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ encoder_hidden_states: torch.FloatTensor | None = None,
+ encoder_attention_mask: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | CausalLMOutputWithCrossAttentions:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+ Example:
+
+ ```python
+ >>> from transformers import (
+ ... TrOCRConfig,
+ ... TrOCRProcessor,
+ ... TrOCRForCausalLM,
+ ... ViTConfig,
+ ... ViTModel,
+ ... VisionEncoderDecoderModel,
+ ... )
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> from PIL import Image
+
+ >>> # TrOCR is a decoder model and should be used within a VisionEncoderDecoderModel
+ >>> # init vision2text model with random weights
+ >>> encoder = ViTModel(ViTConfig())
+ >>> decoder = TrOCRForCausalLM(TrOCRConfig())
+ >>> model = VisionEncoderDecoderModel(encoder=encoder, decoder=decoder)
+
+ >>> # If you want to start from the pretrained model, load the checkpoint with `VisionEncoderDecoderModel`
+ >>> processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-handwritten")
+ >>> model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten")
+
+ >>> # load image from the IAM dataset
+ >>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read())).convert("RGB")
+ >>> pixel_values = processor(image, return_tensors="pt").pixel_values
+ >>> text = "industry, ' Mr. Brown commented icily. ' Let us have a"
+
+ >>> # training
+ >>> model.config.decoder_start_token_id = processor.tokenizer.eos_token_id
+ >>> model.config.pad_token_id = processor.tokenizer.pad_token_id
+ >>> model.config.vocab_size = model.config.decoder.vocab_size
+
+ >>> labels = processor.tokenizer(text, return_tensors="pt").input_ids
+ >>> outputs = model(pixel_values, labels=labels)
+ >>> loss = outputs.loss
+ >>> round(loss.item(), 2)
+ 5.30
+
+ >>> # inference
+ >>> generated_ids = model.generate(pixel_values)
+ >>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+ >>> generated_text
+ 'industry, " Mr. Brown commented icily. " Let us have a'
+ ```"""
+
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
+ outputs = self.model.decoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ logits = self.output_projection(outputs[0])
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.config.vocab_size), labels.view(-1))
+
+ if not return_dict:
+ output = (logits,) + outputs[1:]
+ return (loss,) + output if loss is not None else output
+
+ return CausalLMOutputWithCrossAttentions(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ cross_attentions=outputs.cross_attentions,
+ )
+
+
+__all__ = ["TrOCRForCausalLM", "TrOCRPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/trocr/processing_trocr.py b/lib/python3.11/site-packages/transformers/models/trocr/processing_trocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..d04b9852eb877fb56e4dd78ad5371c20f0c15821
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/trocr/processing_trocr.py
@@ -0,0 +1,69 @@
+# Copyright 2021 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.
+"""
+Processor class for TrOCR.
+"""
+
+from ...image_processing_utils import BatchFeature
+from ...image_utils import ImageInput
+from ...processing_utils import ProcessingKwargs, ProcessorMixin, Unpack
+from ...tokenization_utils_base import PreTokenizedInput, TextInput
+from ...utils import auto_docstring
+
+
+class TrOCRProcessorKwargs(ProcessingKwargs, total=False):
+ _defaults = {}
+
+
+@auto_docstring
+class TrOCRProcessor(ProcessorMixin):
+ def __init__(self, image_processor=None, tokenizer=None, **kwargs):
+ super().__init__(image_processor, tokenizer)
+
+ @auto_docstring
+ def __call__(
+ self,
+ images: ImageInput | None = None,
+ text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None,
+ **kwargs: Unpack[TrOCRProcessorKwargs],
+ ) -> BatchFeature:
+ if images is None and text is None:
+ raise ValueError("You need to specify either an `images` or `text` input to process.")
+
+ output_kwargs = self._merge_kwargs(
+ TrOCRProcessorKwargs,
+ tokenizer_init_kwargs=self.tokenizer.init_kwargs,
+ **kwargs,
+ )
+
+ if images is not None:
+ inputs = self.image_processor(images, **output_kwargs["images_kwargs"])
+ if text is not None:
+ encodings = self.tokenizer(text, **output_kwargs["text_kwargs"])
+
+ if text is None:
+ return inputs
+ elif images is None:
+ return encodings
+ else:
+ inputs["labels"] = encodings["input_ids"]
+ return inputs
+
+ @property
+ def model_input_names(self):
+ image_processor_input_names = self.image_processor.model_input_names
+ return image_processor_input_names + ["labels"]
+
+
+__all__ = ["TrOCRProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/__init__.py b/lib/python3.11/site-packages/transformers/models/tvp/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..84743aadba23c46bfc4db70274dadab5f24b1fef
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tvp/__init__.py
@@ -0,0 +1,30 @@
+# Copyright 2024 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_tvp import *
+ from .image_processing_pil_tvp import *
+ from .image_processing_tvp import *
+ from .modeling_tvp import *
+ from .processing_tvp import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90a5248fd3e642813763851e0ab99b17a99b5bf5
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/configuration_tvp.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/configuration_tvp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9cb640e6972c37dc31fb7f946488ff6a373864be
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/configuration_tvp.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/image_processing_pil_tvp.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/image_processing_pil_tvp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4aeea374e51b97cd65673f81408c4bc3b72e1e58
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/image_processing_pil_tvp.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/image_processing_tvp.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/image_processing_tvp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1c3c76cd3af3a39fd5307f73828a8f144e120fa
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/image_processing_tvp.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/modeling_tvp.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/modeling_tvp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..716d42ccc7514e8c811759f4ddfa91639d8a400d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/modeling_tvp.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/processing_tvp.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/processing_tvp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d36380de3f1044e78f0a11ea4c9c5bcf4b4e4d3d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/tvp/__pycache__/processing_tvp.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/configuration_tvp.py b/lib/python3.11/site-packages/transformers/models/tvp/configuration_tvp.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e0d2d53d085e2805885ef1a65bfbf9a48f75827
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tvp/configuration_tvp.py
@@ -0,0 +1,91 @@
+# Copyright 2023 The Intel AIA Team Authors, and HuggingFace Inc. 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.
+"""TVP model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import consolidate_backbone_kwargs_to_config
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import AutoConfig
+
+
+@auto_docstring(checkpoint="Intel/tvp-base")
+@strict
+class TvpConfig(PreTrainedConfig):
+ r"""
+ distance_loss_weight (`float`, *optional*, defaults to 1.0):
+ The weight of distance loss.
+ duration_loss_weight (`float`, *optional*, defaults to 0.1):
+ The weight of duration loss.
+ visual_prompter_type (`str`, *optional*, defaults to `"framepad"`):
+ Visual prompt type. The type of padding. Framepad means padding on each frame. Should be one of "framepad"
+ or "framedownpad"
+ visual_prompter_apply (`str`, *optional*, defaults to `"replace"`):
+ The way of applying visual prompt. Replace means use the value of prompt to change the original value in
+ visual inputs. Should be one of "replace", or "add", or "remove".
+ visual_prompt_size (`int`, *optional*, defaults to 96):
+ The size of visual prompt.
+ max_img_size (`int`, *optional*, defaults to 448):
+ The maximum size of frame.
+ num_frames (`int`, *optional*, defaults to 48):
+ The number of frames extracted from a video.
+ max_position_embeddings (`int`, *optional*, defaults to 512):
+ The maximum sequence length that this model might ever be used with. Typically set this to something large
+ just in case (e.g., 512 or 1024 or 2048).
+ max_grid_col_position_embeddings (`int`, *optional*, defaults to 100):
+ The largest number of horizontal patches from a video frame.
+ max_grid_row_position_embeddings (`int`, *optional*, defaults to 100):
+ The largest number of vertical patches from a video frame.
+ """
+
+ model_type = "tvp"
+ sub_configs = {"backbone_config": AutoConfig}
+
+ backbone_config: dict | PreTrainedConfig | None = None
+ distance_loss_weight: float = 1.0
+ duration_loss_weight: float = 0.1
+ visual_prompter_type: str = "framepad"
+ visual_prompter_apply: str = "replace"
+ visual_prompt_size: int = 96
+ max_img_size: int = 448
+ num_frames: int = 48
+ vocab_size: int = 30522
+ type_vocab_size: int = 2
+ hidden_size: int = 768
+ intermediate_size: int = 3072
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ max_position_embeddings: int = 512
+ max_grid_col_position_embeddings: int = 100
+ max_grid_row_position_embeddings: int = 100
+ hidden_dropout_prob: float | int = 0.1
+ hidden_act: str = "gelu"
+ layer_norm_eps: float = 1e-12
+ initializer_range: float = 0.02
+ attention_probs_dropout_prob: float | int = 0.1
+ pad_token_id: int | None = None
+
+ def __post_init__(self, **kwargs):
+ self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+ backbone_config=self.backbone_config,
+ default_config_type="resnet",
+ default_config_kwargs={"out_features": ["stage4"]},
+ **kwargs,
+ )
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["TvpConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/image_processing_pil_tvp.py b/lib/python3.11/site-packages/transformers/models/tvp/image_processing_pil_tvp.py
new file mode 100644
index 0000000000000000000000000000000000000000..41fe34f14147a52154b46130cb2eb1b3aac7a7cc
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tvp/image_processing_pil_tvp.py
@@ -0,0 +1,264 @@
+# Copyright 2025 The HuggingFace Inc. 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.
+"""Image processor class for TVP."""
+
+import numpy as np
+
+from ...image_processing_backends import PilBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import PaddingMode, flip_channel_order
+from ...image_transforms import pad as np_pad
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ChannelDimension,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+ get_image_size,
+ make_nested_list_of_images,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring, is_torchvision_available
+
+
+if is_torchvision_available():
+ pass
+
+
+def get_resize_output_image_size(
+ input_image: np.ndarray,
+ max_size: int = 448,
+ input_data_format: str | ChannelDimension | None = None,
+) -> tuple[int, int]:
+ height, width = get_image_size(input_image, input_data_format)
+ if height >= width:
+ ratio = width * 1.0 / height
+ new_height = max_size
+ new_width = new_height * ratio
+ else:
+ ratio = height * 1.0 / width
+ new_width = max_size
+ new_height = new_width * ratio
+ size = (int(new_height), int(new_width))
+
+ return size
+
+
+# Adapted from transformers.models.tvp.image_processing_tvp.TvpImageProcessorKwargs
+class TvpImageProcessorKwargs(ImagesKwargs, total=False):
+ r"""
+ do_flip_channel_order (`bool`, *optional*, defaults to `self.do_flip_channel_order`):
+ Whether to flip the channel order of the image from RGB to BGR.
+ constant_values (`float` or `List[float]`, *optional*, defaults to `self.constant_values`):
+ Value used to fill the padding area when `pad_mode` is `'constant'`.
+ pad_mode (`str`, *optional*, defaults to `self.pad_mode`):
+ Padding mode to use — `'constant'`, `'edge'`, `'reflect'`, or `'symmetric'`.
+ """
+
+ do_flip_channel_order: bool
+ constant_values: float | list[float] | None
+ pad_mode: str | None
+
+
+@auto_docstring
+class TvpImageProcessorPil(PilBackend):
+ resample = PILImageResampling.BILINEAR
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"longest_edge": 448}
+ default_to_square = False
+ crop_size = {"height": 448, "width": 448}
+ do_resize = True
+ do_center_crop = True
+ do_rescale = True
+ rescale_factor = 1 / 255
+ do_pad = True
+ pad_size = {"height": 448, "width": 448}
+ constant_values = 0
+ pad_mode = "constant"
+ do_normalize = True
+ do_flip_channel_order = True
+ valid_kwargs = TvpImageProcessorKwargs
+
+ def __init__(self, **kwargs: Unpack[TvpImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(
+ self,
+ videos: ImageInput | list[ImageInput] | list[list[ImageInput]],
+ **kwargs: Unpack[TvpImageProcessorKwargs],
+ ) -> BatchFeature:
+ r"""
+ videos (`ImageInput` or `list[ImageInput]` or `list[list[ImageInput]]`):
+ Frames to preprocess.
+ """
+ return super().preprocess(videos, **kwargs)
+
+ def _prepare_images_structure(
+ self,
+ images: ImageInput,
+ **kwargs,
+ ) -> ImageInput:
+ """
+ Prepare the images structure for processing.
+
+ Args:
+ images (`ImageInput`):
+ The input images to process.
+
+ Returns:
+ `ImageInput`: The images with a valid nesting.
+ """
+ images = self.fetch_images(images)
+ return make_nested_list_of_images(images, **kwargs)
+
+ def resize(
+ self,
+ image: np.ndarray,
+ size: SizeDict,
+ resample: PILImageResampling = PILImageResampling.BILINEAR,
+ ) -> np.ndarray:
+ """
+ Resize an image.
+
+ Args:
+ image (`np.ndarray`):
+ Image to resize.
+ size (`SizeDict`):
+ Size of the output image. If `size` has `longest_edge`, resize the longest edge to that value
+ while maintaining aspect ratio. Otherwise, use the base class resize method.
+ resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BILINEAR`):
+ Resampling filter to use when resizing the image.
+ """
+ # Handle longest_edge case (TVP-specific)
+ if size.longest_edge:
+ output_size = get_resize_output_image_size(
+ image, size.longest_edge, input_data_format=ChannelDimension.FIRST
+ )
+ return super().resize(image, SizeDict(height=output_size[0], width=output_size[1]), resample)
+
+ # Use base class resize method for other cases
+ return super().resize(image, size, resample)
+
+ def pad_image(
+ self,
+ image: np.ndarray,
+ pad_size: SizeDict | None = None,
+ constant_values: float | list[float] = 0,
+ pad_mode: str | PaddingMode = PaddingMode.CONSTANT,
+ ):
+ """
+ Pad an image with zeros to the given size.
+
+ Args:
+ image (`np.ndarray`):
+ Image to pad.
+ pad_size (`SizeDict`):
+ Size of the output image with pad.
+ constant_values (`Union[float, Iterable[float]]`):
+ The fill value to use when padding the image.
+ pad_mode (`PaddingMode` or `str`):
+ The pad mode, default to PaddingMode.CONSTANT
+ """
+ height, width = get_image_size(image, channel_dim=ChannelDimension.FIRST)
+ max_height = pad_size.height
+ max_width = pad_size.width
+
+ pad_right, pad_bottom = max_width - width, max_height - height
+ if pad_right < 0 or pad_bottom < 0:
+ raise ValueError("The padding size must be greater than image size")
+
+ padding = ((0, pad_bottom), (0, pad_right))
+ padded_image = np_pad(
+ image,
+ padding=padding,
+ mode=pad_mode if isinstance(pad_mode, PaddingMode) else PaddingMode(pad_mode),
+ constant_values=constant_values,
+ data_format=ChannelDimension.FIRST,
+ input_data_format=ChannelDimension.FIRST,
+ )
+
+ return padded_image
+
+ def _flip_channel_order(self, image: np.ndarray) -> np.ndarray:
+ """
+ Flip channel order from RGB to BGR.
+ """
+ return flip_channel_order(image=image, input_data_format=ChannelDimension.FIRST)
+
+ def _preprocess(
+ self,
+ images: list[list[np.ndarray]],
+ do_resize: bool,
+ size: SizeDict,
+ resample: PILImageResampling | None,
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_pad: bool,
+ pad_size: SizeDict,
+ constant_values: float | list[float],
+ pad_mode: str,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_flip_channel_order: bool,
+ return_tensors: str | TensorType | None = None,
+ **kwargs,
+ ) -> BatchFeature:
+ """
+ Preprocess videos using PIL backend.
+
+ This method processes each video frame through the same pipeline as the original
+ TVP image processor but uses PIL/NumPy operations.
+ """
+ processed_videos = []
+ for video in images:
+ processed_frames = []
+ for frame in video:
+ if do_resize:
+ frame = self.resize(frame, size, resample)
+ if do_center_crop:
+ frame = self.center_crop(frame, crop_size)
+ if do_rescale:
+ frame = self.rescale(frame, rescale_factor)
+ if do_normalize:
+ frame = self.normalize(frame, image_mean, image_std)
+ if do_pad:
+ pad_mode_enum = pad_mode if isinstance(pad_mode, PaddingMode) else PaddingMode(pad_mode)
+ frame = self.pad_image(frame, pad_size, constant_values, pad_mode_enum)
+ if do_flip_channel_order:
+ frame = self._flip_channel_order(frame)
+ processed_frames.append(frame)
+ processed_videos.append(processed_frames)
+
+ if return_tensors == "pt":
+ from ...utils import is_torch_available
+
+ if not is_torch_available():
+ raise ImportError("PyTorch is required to return tensors")
+ import torch
+
+ processed_videos = [
+ torch.stack([torch.from_numpy(frame.copy()) for frame in video], dim=0) for video in processed_videos
+ ]
+ processed_videos = torch.stack(processed_videos, dim=0)
+
+ return BatchFeature(data={"pixel_values": processed_videos}, tensor_type=return_tensors)
+
+
+__all__ = ["TvpImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/image_processing_tvp.py b/lib/python3.11/site-packages/transformers/models/tvp/image_processing_tvp.py
new file mode 100644
index 0000000000000000000000000000000000000000..c13feeddf947a5f139809b7367249f99d697b662
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tvp/image_processing_tvp.py
@@ -0,0 +1,233 @@
+# Copyright 2025 The HuggingFace Inc. 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.
+"""Image processor class for TVP."""
+
+import torch
+from torchvision.transforms.v2 import functional as tvF
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+ make_nested_list_of_images,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+class TvpImageProcessorKwargs(ImagesKwargs, total=False):
+ r"""
+ do_flip_channel_order (`bool`, *optional*, defaults to `self.do_flip_channel_order`):
+ Whether to flip the channel order of the image from RGB to BGR.
+ constant_values (`float` or `List[float]`, *optional*, defaults to `self.constant_values`):
+ Value used to fill the padding area when `pad_mode` is `'constant'`.
+ pad_mode (`str`, *optional*, defaults to `self.pad_mode`):
+ Padding mode to use — `'constant'`, `'edge'`, `'reflect'`, or `'symmetric'`.
+ """
+
+ do_flip_channel_order: bool
+ constant_values: float | list[float] | None
+ pad_mode: str | None
+
+
+@auto_docstring
+class TvpImageProcessor(TorchvisionBackend):
+ resample = PILImageResampling.BILINEAR
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"longest_edge": 448}
+ default_to_square = False
+ crop_size = {"height": 448, "width": 448}
+ do_resize = True
+ do_center_crop = True
+ do_rescale = True
+ rescale_factor = 1 / 255
+ do_pad = True
+ pad_size = {"height": 448, "width": 448}
+ constant_values = 0
+ pad_mode = "constant"
+ do_normalize = True
+ do_flip_channel_order = True
+ valid_kwargs = TvpImageProcessorKwargs
+
+ def __init__(self, **kwargs: Unpack[TvpImageProcessorKwargs]):
+ super().__init__(**kwargs)
+
+ @auto_docstring
+ def preprocess(
+ self,
+ videos: ImageInput | list[ImageInput] | list[list[ImageInput]],
+ **kwargs: Unpack[TvpImageProcessorKwargs],
+ ) -> BatchFeature:
+ r"""
+ videos (`ImageInput` or `list[ImageInput]` or `list[list[ImageInput]]`):
+ Frames to preprocess.
+ """
+ return super().preprocess(videos, **kwargs)
+
+ def _prepare_images_structure(
+ self,
+ images: ImageInput,
+ **kwargs,
+ ) -> ImageInput:
+ """
+ Prepare the images structure for processing.
+
+ Args:
+ images (`ImageInput`):
+ The input images to process.
+
+ Returns:
+ `ImageInput`: The images with a valid nesting.
+ """
+ images = self.fetch_images(images)
+ return make_nested_list_of_images(images, **kwargs)
+
+ def resize(
+ self,
+ image: "torch.Tensor",
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None" = None,
+ antialias: bool = True,
+ **kwargs,
+ ) -> "torch.Tensor":
+ """
+ Resize an image to the specified size.
+
+ Args:
+ image (`torch.Tensor`):
+ Image to resize.
+ size (`SizeDict`):
+ Size dictionary. If `size` has `longest_edge`, resize the longest edge to that value
+ while maintaining aspect ratio. Otherwise, use the base class resize method.
+ resample (`tvF.InterpolationMode`, *optional*):
+ Interpolation method to use.
+ antialias (`bool`, *optional*, defaults to `True`):
+ Whether to use antialiasing.
+
+ Returns:
+ `torch.Tensor`: The resized image.
+ """
+
+ # Handle longest_edge case (TVP-specific)
+ if size.longest_edge:
+ # Get current dimensions
+ current_height, current_width = image.shape[-2:]
+
+ # Calculate new dimensions maintaining aspect ratio
+ if current_height >= current_width:
+ ratio = current_width * 1.0 / current_height
+ new_height = size.longest_edge
+ new_width = int(new_height * ratio)
+ else:
+ ratio = current_height * 1.0 / current_width
+ new_width = size.longest_edge
+ new_height = int(new_width * ratio)
+
+ return super().resize(
+ image, SizeDict(height=new_height, width=new_width), resample=resample, antialias=antialias
+ )
+
+ # Use base class resize method for other cases
+ return super().resize(image, size, resample=resample, antialias=antialias, **kwargs)
+
+ def _flip_channel_order(self, frames: "torch.Tensor") -> "torch.Tensor":
+ """
+ Flip channel order from RGB to BGR.
+
+ The slow processor puts the red channel at the end (BGR format),
+ but the channel order is different. We need to match the exact
+ channel order of the slow processor:
+
+ Slow processor:
+ - Channel 0: Blue (originally Red)
+ - Channel 1: Green
+ - Channel 2: Red (originally Blue)
+ """
+ # Assuming frames are in channels_first format (..., C, H, W)
+ frames = frames.flip(-3)
+
+ return frames
+
+ def _preprocess(
+ self,
+ images: list[list["torch.Tensor"]],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_pad: bool,
+ pad_size: SizeDict,
+ constant_values: float | list[float],
+ pad_mode: str,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_flip_channel_order: bool,
+ return_tensors: str | TensorType | None,
+ disable_grouping: bool | None,
+ **kwargs,
+ ) -> BatchFeature:
+ """
+ Preprocess videos using the fast image processor.
+
+ This method processes each video frame through the same pipeline as the original
+ TVP image processor but uses torchvision operations for better performance.
+ """
+ grouped_images, grouped_images_index = group_images_by_shape(
+ images, disable_grouping=disable_grouping, is_nested=True
+ )
+ processed_images_grouped = {}
+ for shape, stacked_frames in grouped_images.items():
+ # Resize if needed
+ if do_resize:
+ stacked_frames = self.resize(stacked_frames, size, resample)
+
+ # Center crop if needed
+ if do_center_crop:
+ stacked_frames = self.center_crop(stacked_frames, crop_size)
+
+ # Rescale and normalize using fused method for consistency
+ stacked_frames = self.rescale_and_normalize(
+ stacked_frames, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+
+ # Pad if needed
+ if do_pad:
+ stacked_frames = self.pad(stacked_frames, pad_size, fill_value=constant_values, pad_mode=pad_mode)
+ stacked_frames = torch.stack(stacked_frames, dim=0)
+
+ # Flip channel order if needed (RGB to BGR)
+ if do_flip_channel_order:
+ stacked_frames = self._flip_channel_order(stacked_frames)
+
+ processed_images_grouped[shape] = stacked_frames
+
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index, is_nested=True)
+ if return_tensors == "pt":
+ processed_images = [torch.stack(images, dim=0) for images in processed_images]
+ processed_images = torch.stack(processed_images, dim=0)
+
+ return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+
+__all__ = ["TvpImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/modeling_tvp.py b/lib/python3.11/site-packages/transformers/models/tvp/modeling_tvp.py
new file mode 100644
index 0000000000000000000000000000000000000000..eeeb9ce2738cfb9baab4da28985c5bba8b6fff29
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tvp/modeling_tvp.py
@@ -0,0 +1,885 @@
+# Copyright 2023 The Intel AIA Team Authors, and HuggingFace Inc. 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.
+"""PyTorch TVP Model"""
+
+import math
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...backbone_utils import load_backbone
+from ...masking_utils import create_bidirectional_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling, ModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring, logging
+from .configuration_tvp import TvpConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring
+@dataclass
+class TvpVideoGroundingOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `return_loss` is `True`):
+ Temporal-Distance IoU loss for video grounding.
+ logits (`torch.FloatTensor` of shape `(batch_size, 2)`):
+ Contains start_time/duration and end_time/duration. It is the time slot of the videos corresponding to the
+ input texts.
+ attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor, ...] | None = None
+ attentions: tuple[torch.FloatTensor, ...] | None = None
+
+
+class TvpLoss(nn.Module):
+ """
+ This class computes the losses for `TvpForVideoGrounding`. The process happens in two steps: 1) we compute
+ hungarian assignment between ground truth boxes and the outputs of the model 2) we supervise each pair of matched
+ ground-truth / prediction (supervise class and box).
+
+ Args:
+ losses (`list[str]`):
+ List of all the losses to be applied.
+ """
+
+ def __init__(self, losses):
+ super().__init__()
+ self.loss_map = {
+ "iou": self.loss_iou,
+ "distance": self.loss_distance,
+ "duration": self.loss_duration,
+ }
+ for loss in losses:
+ if loss not in self.loss_map:
+ raise ValueError(f"Loss {loss} not supported")
+
+ self.losses = losses
+
+ def loss_iou(self, start_time, end_time, candidates_start_time, candidates_end_time, duration):
+ """
+ Measure the intersection over union.
+ """
+ inter = torch.min(candidates_end_time, end_time) - torch.max(candidates_start_time, start_time)
+ union = torch.max(candidates_end_time, end_time) - torch.min(candidates_start_time, start_time)
+ iou = 1 - inter.clamp(min=0) / union
+
+ return iou
+
+ def loss_distance(self, start_time, end_time, candidates_start_time, candidates_end_time, duration):
+ """
+ Measure the distance of mid points.
+ """
+ mid_candidates = torch.div(torch.add(candidates_start_time, candidates_end_time), 2.0)
+ mid_groundtruth = torch.div(torch.add(start_time, end_time), 2.0)
+ distance_diff = torch.div(
+ torch.max(mid_candidates, mid_groundtruth) - torch.min(mid_candidates, mid_groundtruth), duration
+ ).clamp(min=0.2)
+
+ return distance_diff
+
+ def loss_duration(self, start_time, end_time, candidates_start_time, candidates_end_time, duration):
+ """
+ Measure the difference of duration.
+ """
+ duration_candidates = torch.sub(candidates_end_time, candidates_start_time)
+ duration_groundtruth = torch.sub(end_time, start_time)
+ duration_diff = torch.square(torch.div(torch.sub(duration_candidates, duration_groundtruth), duration))
+ duration_diff = duration_diff.clamp(min=0.4)
+
+ return duration_diff
+
+ def forward(self, logits, labels):
+ """
+ This performs the loss computation.
+
+ Args:
+ logits (`torch.FloatTensor`):
+ The output logits of head module.
+ labels (`list[torch.FloatTensor]`):
+ List of tensors ([start, end, duration]), which contains start time, end time of the video corresponding to the text, and also the duration.
+ """
+ duration, start_time, end_time = labels
+ candidates = torch.mul(logits, duration)
+ candidates_start_time, candidates_end_time = candidates[:, 0].float(), candidates[:, 1].float()
+
+ losses_dict = {}
+ for loss in self.losses:
+ losses_dict.update(
+ {loss: self.loss_map[loss](start_time, end_time, candidates_start_time, candidates_end_time, duration)}
+ )
+
+ return losses_dict
+
+
+class TvpVisionModel(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.backbone = load_backbone(config)
+
+ if config.backbone_config is not None:
+ in_channels = config.backbone_config.hidden_sizes[-1]
+ elif hasattr(self.backbone, "config") and hasattr(self.backbone.config, "hidden_sizes"):
+ in_channels = self.backbone.config.hidden_sizes[-1]
+ elif hasattr(self.backbone, "config") and hasattr(self.backbone.config, "hidden_size"):
+ in_channels = self.backbone.config.hidden_size
+ else:
+ raise ValueError("Backbone config not found")
+
+ self.grid_encoder_conv = nn.Conv2d(
+ in_channels,
+ config.hidden_size,
+ kernel_size=3,
+ stride=1,
+ padding=1,
+ groups=1,
+ bias=False,
+ )
+
+ def forward(self, pixel_values):
+ batch_size, num_frames, num_channels, height, width = pixel_values.shape
+ # (batch_size * num_frames, num_channels, height, width)
+ pixel_values = pixel_values.view(batch_size * num_frames, num_channels, height, width)
+ grid_feat_outputs = self.backbone(pixel_values)["feature_maps"][0]
+ grid = self.grid_encoder_conv(grid_feat_outputs)
+ grid = nn.functional.max_pool2d(grid, kernel_size=2, stride=2)
+ grid = nn.functional.relu(grid, inplace=True)
+ new_channel, new_height, new_width = grid.shape[-3:]
+ # (batch_size, num_frames, num_channels, height, width)
+ grid = grid.view(batch_size, num_frames, new_channel, new_height, new_width)
+ # (batch_size, num_frames, height, width, num_channels)
+ grid = grid.permute(0, 1, 3, 4, 2)
+ return grid
+
+
+class TvpVisualInputEmbedding(nn.Module):
+ """
+ Takes input of both image and video (multi-frame)
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ # sequence embedding
+ self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+ self.row_position_embeddings = nn.Embedding(config.max_grid_row_position_embeddings, config.hidden_size)
+ self.col_position_embeddings = nn.Embedding(config.max_grid_col_position_embeddings, config.hidden_size)
+ self.token_type_embeddings = nn.Embedding(1, config.hidden_size)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+ self.max_grid_row_position_embeddings = config.max_grid_row_position_embeddings
+ self.max_grid_col_position_embeddings = config.max_grid_col_position_embeddings
+
+ def interpolate_pos_encoding(self, embedding: torch.Tensor, height: int, width: int) -> torch.Tensor:
+ """
+ This method allows to interpolate the pre-trained pad weights , to be able to use the model on collection of high
+ resolution images (high resolution videos).
+
+ """
+ h0 = w0 = 1
+ # if height dimension is to be interpolated
+ if height > self.max_grid_row_position_embeddings:
+ h0 = height / self.max_grid_row_position_embeddings
+ # if width dimension is to be interpolated
+ if width > self.max_grid_col_position_embeddings:
+ w0 = width / self.max_grid_col_position_embeddings
+ embedding = embedding.permute(0, 3, 1, 2) # (batch_size, hidden_dim, height, width)
+ embedding = nn.functional.interpolate(
+ embedding,
+ scale_factor=(h0, w0),
+ mode="bicubic",
+ align_corners=False,
+ )
+ embedding = embedding.permute(0, 2, 3, 1) # (batch_size, height, width, hidden_dim)
+ return embedding
+
+ def add_2d_positional_embeddings(self, grid, interpolate_pos_encoding: bool = False):
+ """
+ Args:
+ grid: (batch_size, height, width, hidden_dim)
+ interpolate_pos_encoding: (`bool`, *optional*, defaults to `False`):
+ Whether to interpolate the pre-trained position encodings.
+ Returns:
+ grid + col_position_embeddings.view(*col_shape): (batch_size, *, height, width, hidden_dim)
+ """
+ batch_size, height, width, hidden_dim = grid.shape
+
+ # add row-wise position embeddings
+ # (height, )
+ row_height = min(self.max_grid_row_position_embeddings, height)
+ row_position_ids = torch.arange(row_height, dtype=torch.long, device=grid.device)
+ # (height, hidden_dim)
+ row_position_embeddings = self.row_position_embeddings(row_position_ids)
+ row_shape = (1,) * (len(grid.shape) - 3) + (row_height, 1, hidden_dim)
+ # (batch_size, height, 1, hidden_dim)
+ row_position_embeddings = row_position_embeddings.view(*row_shape)
+
+ # add column-wise position embeddings
+ row_width = min(self.max_grid_col_position_embeddings, width)
+ col_position_ids = torch.arange(row_width, dtype=torch.long, device=grid.device)
+ # (width, hidden_dim)
+ col_position_embeddings = self.col_position_embeddings(col_position_ids)
+ col_shape = (batch_size, 1, row_width, hidden_dim)
+ # (batch_size, 1, width, hidden_dim)
+ col_position_embeddings = col_position_embeddings.view(*col_shape)
+ # (batch_size, height, width, hidden_dim)
+ positional_embeddings = row_position_embeddings + col_position_embeddings
+
+ # This interpolation gets triggered ONLY when the input image dim is larger in any dimension than the original position embeddings
+ if interpolate_pos_encoding and (
+ height > self.max_grid_row_position_embeddings or width > self.max_grid_col_position_embeddings
+ ):
+ grid = grid + self.interpolate_pos_encoding(positional_embeddings, height, width)
+ else:
+ grid = grid + positional_embeddings
+ return grid
+
+ def forward(self, grid, interpolate_pos_encoding: bool = False):
+ """
+ Args:
+ grid: Array of shape (batch_size, num_frames, height, width, num_channels).
+ It contains processed frames extracted from videos, and is generated by Tvp image preprocessor. Note,
+ num_frames can be 1
+ interpolate_pos_encoding: (bool, *optional*, defaults to `False`):
+ Whether to interpolate the pre-trained position encodings.
+
+ Returns:
+ embeddings: The embedding of grid with size (batch_size, height*width, num_channels)
+
+ """
+ batch_size, num_frames, height, width, num_channels = grid.shape
+ # temporal mean pooling, (batch_size, height, width, hidden_size)
+ grid = grid.mean(1)
+ grid = self.add_2d_positional_embeddings(grid, interpolate_pos_encoding=interpolate_pos_encoding)
+ # image token sequence, (batch_size, height*width, num_channels)
+ visual_tokens = grid.view(batch_size, -1, num_channels)
+ visual_tokens_shape = visual_tokens.shape[:-1]
+ device = visual_tokens.device
+
+ # image token type embeddings.
+ token_type_ids = torch.zeros(visual_tokens_shape, dtype=torch.long, device=device)
+ token_type_embeddings = self.token_type_embeddings(token_type_ids)
+
+ embeddings = visual_tokens + token_type_embeddings
+ embeddings = self.layer_norm(embeddings)
+ embeddings = self.dropout(embeddings)
+ return embeddings
+
+
+class TvpTextInputEmbeddings(nn.Module):
+ """Construct the embeddings from word, position and token_type embeddings."""
+
+ def __init__(self, config):
+ super().__init__()
+ self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+ self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+ self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None):
+ if input_ids is not None:
+ input_shape = input_ids.size()
+ else:
+ input_shape = inputs_embeds.size()[:-1]
+
+ seq_length = input_shape[1]
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
+ if position_ids is None:
+ position_ids = torch.arange(seq_length, dtype=torch.long, device=device)
+ position_ids = position_ids.unsqueeze(0).expand(input_shape)
+ if token_type_ids is None:
+ token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
+
+ if inputs_embeds is None:
+ inputs_embeds = self.word_embeddings(input_ids)
+ position_embeddings = self.position_embeddings(position_ids)
+ token_type_embeddings = self.token_type_embeddings(token_type_ids)
+
+ embeddings = inputs_embeds + position_embeddings + token_type_embeddings
+ embeddings = self.layer_norm(embeddings)
+ embeddings = self.dropout(embeddings)
+ return embeddings
+
+
+class TvpAttention(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+ raise ValueError(
+ f"The hidden size {config.hidden_size} is not a multiple of the number of attention heads {config.num_attention_heads}"
+ )
+
+ self.num_attention_heads = config.num_attention_heads
+ self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+ self.all_head_size = self.num_attention_heads * self.attention_head_size
+
+ self.query = nn.Linear(config.hidden_size, self.all_head_size)
+ self.key = nn.Linear(config.hidden_size, self.all_head_size)
+ self.value = nn.Linear(config.hidden_size, self.all_head_size)
+ self.attn_dropout = nn.Dropout(config.attention_probs_dropout_prob)
+
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def _reshape(self, tensor: torch.Tensor, sequence_length: int, batch_size: int):
+ return (
+ tensor.view(batch_size, sequence_length, self.num_attention_heads, self.attention_head_size)
+ .transpose(1, 2)
+ .contiguous()
+ )
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ output_attentions: bool | None = None,
+ ):
+ batch_size, sequence_length = hidden_states.shape[:2]
+ mixed_query_layer = self.query(hidden_states)
+
+ mixed_key_layer = self.key(hidden_states)
+ mixed_value_layer = self.value(hidden_states)
+
+ query_layer = self._reshape(mixed_query_layer, sequence_length, batch_size)
+ key_layer = self._reshape(mixed_key_layer, sequence_length, batch_size)
+ value_layer = self._reshape(mixed_value_layer, sequence_length, batch_size)
+
+ # Take the dot product between "query" and "key" to get the raw attention scores.
+ attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+ attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+ if attention_mask is not None:
+ attention_scores = attention_scores + attention_mask
+
+ # Normalize the attention scores to probabilities.
+ attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+ # This is actually dropping out entire tokens to attend to, which might
+ # seem a bit unusual, but is taken from the original Transformer paper.
+ attention_probs = self.attn_dropout(attention_probs)
+
+ attn_output = torch.matmul(attention_probs, value_layer)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ attn_output = attn_output.reshape(batch_size, sequence_length, self.all_head_size)
+
+ attn_output = self.dense(attn_output)
+ attn_output = self.dropout(attn_output)
+ attn_output = self.layer_norm(attn_output + hidden_states)
+ # add attentions if we output them
+ outputs = (attn_output, attention_probs) if output_attentions else (attn_output,)
+ return outputs
+
+
+# Copied from transformers.models.bert.modeling_bert.BertIntermediate with Bert->Tvp
+class TvpIntermediate(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ return hidden_states
+
+
+class TvpOutputLayer(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.layer_norm(hidden_states + input_tensor)
+ return hidden_states
+
+
+class TvpEncodeLayer(GradientCheckpointingLayer):
+ def __init__(self, config):
+ super().__init__()
+ self.attention = TvpAttention(config)
+ self.intermediate = TvpIntermediate(config)
+ self.output = TvpOutputLayer(config)
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ output_attentions: bool | None = None,
+ ):
+ self_attention_outputs = self.attention(
+ hidden_states,
+ attention_mask,
+ output_attentions=output_attentions,
+ )
+ attention_output = self_attention_outputs[0]
+ outputs = self_attention_outputs[1:] # add self attentions if we output attention weights
+ intermediate_output = self.intermediate(attention_output)
+ layer_output = self.output(intermediate_output, attention_output)
+ outputs = (layer_output,) + outputs
+ return outputs
+
+
+class TvpEncoder(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.layer = nn.ModuleList([TvpEncodeLayer(config) for _ in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ ) -> tuple | BaseModelOutput:
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ all_hidden_states = ()
+ all_attentions = ()
+
+ for i, layer_module in enumerate(self.layer):
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ layer_outputs = layer_module(hidden_states, attention_mask, output_attentions)
+
+ hidden_states = layer_outputs[0]
+ if output_attentions:
+ all_attentions = all_attentions + (layer_outputs[1],)
+
+ # Add last layer
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ outputs = (hidden_states,)
+ if output_hidden_states:
+ outputs = outputs + (all_hidden_states,)
+ if output_attentions:
+ outputs = outputs + (all_attentions,)
+ return outputs # last-layer hidden state, (all hidden states), (all attentions)
+
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states if output_hidden_states else None,
+ attentions=all_attentions if output_attentions else None,
+ )
+
+
+# Copied from transformers.models.bert.modeling_bert.BertPooler with Bert->Tvp
+class TvpPooler(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+ self.activation = nn.Tanh()
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ # We "pool" the model by simply taking the hidden state corresponding
+ # to the first token.
+ first_token_tensor = hidden_states[:, 0]
+ pooled_output = self.dense(first_token_tensor)
+ pooled_output = self.activation(pooled_output)
+ return pooled_output
+
+
+@auto_docstring
+class TvpPreTrainedModel(PreTrainedModel):
+ config: TvpConfig
+ base_model_prefix = "model"
+ input_modalities = ("video", "text")
+ supports_gradient_checkpointing = True
+
+ @torch.no_grad()
+ def _init_weights(self, module: nn.Module):
+ """Initialize the weights"""
+ if isinstance(module, (nn.Linear, nn.Embedding)):
+ init.normal_(module.weight, mean=0.0, std=self.config.initializer_range)
+ elif isinstance(module, nn.LayerNorm):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ elif isinstance(module, nn.Conv2d):
+ init.kaiming_normal_(module.weight, mode="fan_out", nonlinearity="relu")
+ if module.bias is not None:
+ init.constant_(module.bias, 0)
+ elif isinstance(module, TvpModel):
+ init.normal_(module.text_prompt)
+
+ if isinstance(module, nn.Linear) and module.bias is not None:
+ init.zeros_(module.bias)
+ if hasattr(module, "pad_up"):
+ init.normal_(module.pad_up)
+ if hasattr(module, "pad_down"):
+ init.normal_(module.pad_down)
+ if hasattr(module, "pad_left"):
+ init.normal_(module.pad_left)
+ if hasattr(module, "pad_right"):
+ init.normal_(module.pad_right)
+
+
+class TvpFrameDownPadPrompter(nn.Module):
+ """
+ Pad frames extracted from videos only at the bottom.
+ """
+
+ def __init__(self, config):
+ if config.visual_prompter_apply not in ("add", "replace", "remove"):
+ raise ValueError("`visual_prompter_apply` must be in (add, replace, remove)")
+
+ super().__init__()
+ self.visual_prompt_size = config.visual_prompt_size
+ self.frame_num = config.frame_num
+ self.max_img_size = config.max_img_size
+ self.visual_prompter_apply = config.visual_prompter_apply
+
+ self.pad_down = nn.Parameter(
+ torch.randn([1, config.frame_num, 3, config.visual_prompt_size, config.max_img_size])
+ )
+
+ def forward(self, pixel_values):
+ if self.visual_prompter_apply != "add":
+ visual_prompt_mask = torch.ones(
+ [self.max_img_size, self.max_img_size], dtype=pixel_values.dtype, device=pixel_values.device
+ )
+ visual_prompt_mask[self.max_img_size - self.visual_prompt_size : self.max_img_size, :] = 0.0
+ pixel_values *= visual_prompt_mask
+ if self.visual_prompter_apply != "remove":
+ prompt = torch.zeros(
+ [pixel_values.shape[0], pixel_values.shape[1], 3, self.max_img_size, self.max_img_size],
+ device=pixel_values.device,
+ )
+ start_point = self.max_img_size - self.visual_prompt_size
+ prompt[:, :, :, start_point : self.max_img_size, :] = self.pad_down
+ pixel_values += prompt.to(pixel_values.dtype)
+ return pixel_values
+
+
+class TvpFramePadPrompter(nn.Module):
+ """
+ Pad frames extracted from videos in the surroundings.
+ """
+
+ def __init__(self, config):
+ if config.visual_prompter_apply not in ("add", "replace", "remove"):
+ raise ValueError("`visual_prompter_apply` must be in (add, replace, remove)")
+
+ super().__init__()
+ self.num_frames = config.num_frames
+ self.max_img_size = config.max_img_size
+ self.visual_prompter_apply = config.visual_prompter_apply
+ self.base_size = config.max_img_size - config.visual_prompt_size * 2
+ self.pad_up = nn.Parameter(
+ torch.randn([1, config.num_frames, 3, config.visual_prompt_size, config.max_img_size])
+ )
+ self.pad_down = nn.Parameter(
+ torch.randn([1, config.num_frames, 3, config.visual_prompt_size, config.max_img_size])
+ )
+ self.pad_left = nn.Parameter(
+ torch.randn(
+ [
+ 1,
+ config.num_frames,
+ 3,
+ config.max_img_size - config.visual_prompt_size * 2,
+ config.visual_prompt_size,
+ ]
+ )
+ )
+ self.pad_right = nn.Parameter(
+ torch.randn(
+ [
+ 1,
+ config.num_frames,
+ 3,
+ config.max_img_size - config.visual_prompt_size * 2,
+ config.visual_prompt_size,
+ ]
+ )
+ )
+
+ def interpolate_pad_encoding(self, prompt: torch.Tensor, height: int, width: int) -> torch.Tensor:
+ """
+ This method allows to interpolate the pre-trained pad weights, to be able to use the model on collection of high
+ resolution images (high resolution videos).
+
+ """
+
+ # creates scale factor from height and width of original image wrt to the config.max_img_size
+ h0, w0 = height / self.max_img_size, width / self.max_img_size
+
+ batch, num_frames, channels, prompt_height, prompt_width = prompt.shape
+
+ # reshaping the batch and num_frames dimension into a single one (i.e (b,frames,c,h,w)-->(b*frames,c,h,w)), to apply bicubic interpolation
+ prompt = prompt.reshape(batch * num_frames, channels, prompt_height, prompt_width)
+ prompt = nn.functional.interpolate(
+ prompt,
+ scale_factor=(h0, w0),
+ mode="bicubic",
+ align_corners=False,
+ )
+ # reversing back to (batch,frames,channels,height,width), where height and width is the new interpolated height and width
+ prompt = prompt.reshape(batch, num_frames, channels, height, width)
+ return prompt
+
+ def forward(self, pixel_values, interpolate_pad_encoding: bool = False):
+ height, width = (
+ (pixel_values.shape[-2], pixel_values.shape[-1])
+ if interpolate_pad_encoding
+ else (self.max_img_size, self.max_img_size)
+ )
+ if self.visual_prompter_apply not in ("add", "remove", "replace"):
+ raise ValueError(f"Invalid visual_prompter_apply value {self.visual_prompter_apply}")
+ if self.visual_prompter_apply in ("replace", "remove"):
+ visual_prompt_mask = torch.ones([height, width], dtype=pixel_values.dtype, device=pixel_values.device)
+ pixel_values *= visual_prompt_mask
+ if self.visual_prompter_apply in ("replace", "add"):
+ base = torch.zeros(1, self.num_frames, 3, self.base_size, self.base_size, device=pixel_values.device)
+
+ prompt = torch.cat([self.pad_left, base, self.pad_right], dim=4)
+ prompt = torch.cat([self.pad_up, prompt, self.pad_down], dim=3)
+ prompt = torch.cat(pixel_values.size(0) * [prompt])
+ if interpolate_pad_encoding:
+ prompt = self.interpolate_pad_encoding(prompt, height, width)
+ pixel_values = pixel_values + prompt.to(pixel_values.dtype)
+ return pixel_values
+
+
+TVP_PROMPTER_CLASSES_MAPPING = {
+ "framedownpad": TvpFrameDownPadPrompter,
+ "framepad": TvpFramePadPrompter,
+}
+
+
+@auto_docstring(
+ custom_intro="""
+ The bare Tvp Model transformer outputting BaseModelOutputWithPooling object without any specific head on top.
+ """
+)
+class TvpModel(TvpPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.config = config
+ self.vision_model = TvpVisionModel(config)
+ self.embeddings = TvpTextInputEmbeddings(config)
+ self.visual_embeddings = TvpVisualInputEmbedding(config)
+ self.encoder = TvpEncoder(config)
+ self.pooler = TvpPooler(config)
+ self.text_prompt = nn.Parameter(torch.randn([1, 10, config.hidden_size]))
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+ if config.visual_prompter_type not in TVP_PROMPTER_CLASSES_MAPPING:
+ raise ValueError("`visual_prompter_type` must be in (framedownpad, framepad)")
+ self.visual_prompter = TVP_PROMPTER_CLASSES_MAPPING[config.visual_prompter_type](config)
+
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings.word_embeddings
+
+ def set_input_embeddings(self, value):
+ self.embeddings.word_embeddings = value
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs,
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ Examples:
+ ```python
+ >>> import torch
+ >>> from transformers import AutoConfig, AutoTokenizer, TvpModel
+
+ >>> model = TvpModel.from_pretrained("Jiqing/tiny-random-tvp")
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("Jiqing/tiny-random-tvp")
+
+ >>> pixel_values = torch.rand(1, 1, 3, 448, 448)
+ >>> text_inputs = tokenizer("This is an example input", return_tensors="pt")
+ >>> output = model(text_inputs.input_ids, pixel_values, text_inputs.attention_mask)
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ # Add visual prompt, it compensates for the spatiotemporal information loss in 2D visual features.
+ pixel_values = self.vision_model(
+ self.visual_prompter(pixel_values, interpolate_pad_encoding=interpolate_pos_encoding)
+ )
+ # (batch_size, sequence_length, hidden_size)
+ text_embedding_output = self.embeddings(input_ids=input_ids)
+ # (batch_size, visual_sequence_length, hidden_size)
+ visual_embedding_output = self.visual_embeddings(
+ pixel_values, interpolate_pos_encoding=interpolate_pos_encoding
+ )
+
+ if attention_mask is not None:
+ # (batch_size, visual_sequence_length)
+ visual_attention_mask = attention_mask.new_ones(visual_embedding_output.shape[:2])
+ pt_mask = torch.ones(attention_mask.shape[0], 10).to(
+ device=attention_mask.device, dtype=attention_mask.dtype
+ )
+ attention_mask = torch.cat([pt_mask, attention_mask, visual_attention_mask], dim=-1)
+
+ text_prompt = self.text_prompt.expand(text_embedding_output.shape[0], -1, -1)
+ # (batch_size, sequence_length + visual_sequence_length, hidden_size)
+ embedding_output = torch.cat([text_prompt, text_embedding_output, visual_embedding_output], dim=1)
+
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=embedding_output,
+ attention_mask=attention_mask,
+ )
+
+ encoder_outputs = self.encoder(
+ embedding_output,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ last_hidden_state = encoder_outputs.last_hidden_state if return_dict else encoder_outputs[0]
+ pooled_output = self.pooler(last_hidden_state)
+ last_hidden_state = self.dropout(last_hidden_state)
+ pooled_output = self.dropout(pooled_output)
+ if not return_dict:
+ return (last_hidden_state, pooled_output) + encoder_outputs[1:]
+ return BaseModelOutputWithPooling(
+ last_hidden_state=last_hidden_state,
+ pooler_output=pooled_output,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ )
+
+
+class TvpVideoGroundingHead(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.layer_0 = nn.Linear(config.hidden_size, config.hidden_size * 2)
+ self.layer_1 = nn.Linear(config.hidden_size * 2, 2)
+ self.activation_0 = nn.ReLU()
+ self.activation_1 = nn.Sigmoid()
+
+ def forward(self, pooler_output):
+ logits = self.activation_0(self.layer_0(pooler_output))
+ logits = self.activation_1(self.layer_1(logits))
+ return logits
+
+
+@auto_docstring(
+ custom_intro="""
+ Tvp Model with a video grounding head on top computing IoU, distance, and duration loss.
+ """
+)
+class TvpForVideoGrounding(TvpPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.config = config
+ self.model = TvpModel(config)
+ self.video_grounding_head = TvpVideoGroundingHead(config)
+
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ labels: tuple[torch.Tensor] | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ interpolate_pos_encoding: bool = False,
+ **kwargs,
+ ) -> tuple | TvpVideoGroundingOutput:
+ r"""
+ labels (`torch.FloatTensor` of shape `(batch_size, 3)`, *optional*):
+ The labels contains duration, start time, and end time of the video corresponding to the text.
+
+ Examples:
+ ```python
+ >>> import torch
+ >>> from transformers import AutoConfig, AutoTokenizer, TvpForVideoGrounding
+
+ >>> model = TvpForVideoGrounding.from_pretrained("Jiqing/tiny-random-tvp")
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("Jiqing/tiny-random-tvp")
+
+ >>> pixel_values = torch.rand(1, 1, 3, 448, 448)
+ >>> text_inputs = tokenizer("This is an example input", return_tensors="pt")
+ >>> output = model(text_inputs.input_ids, pixel_values, text_inputs.attention_mask)
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ outputs = self.model(
+ input_ids,
+ pixel_values,
+ attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ interpolate_pos_encoding=interpolate_pos_encoding,
+ )
+ pooler_output = outputs[1]
+ logits = self.video_grounding_head(pooler_output)
+
+ loss = None
+ if labels is not None:
+ criterion = TvpLoss(["iou", "distance", "duration"])
+ criterion.to(self.device)
+ loss_dict = criterion(logits, labels)
+ loss = (
+ loss_dict["iou"]
+ + self.config.distance_loss_weight * loss_dict["distance"]
+ + self.config.duration_loss_weight * loss_dict["duration"]
+ )
+ if not return_dict:
+ outputs = (logits,) + outputs[2:]
+ if loss is not None:
+ outputs = (loss,) + outputs
+ return outputs
+
+ return TvpVideoGroundingOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = ["TvpModel", "TvpPreTrainedModel", "TvpForVideoGrounding"]
diff --git a/lib/python3.11/site-packages/transformers/models/tvp/processing_tvp.py b/lib/python3.11/site-packages/transformers/models/tvp/processing_tvp.py
new file mode 100644
index 0000000000000000000000000000000000000000..b72f6be48c02d5a0766437c6fc8745bede3e19f6
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/tvp/processing_tvp.py
@@ -0,0 +1,63 @@
+# Copyright 2023 The Intel AIA Team Authors, and HuggingFace Inc. 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.
+"""
+Processor class for TVP.
+"""
+
+from ...processing_utils import ProcessingKwargs, ProcessorMixin
+from ...utils import auto_docstring
+
+
+class TvpProcessorKwargs(ProcessingKwargs, total=False):
+ _defaults = {
+ "text_kwargs": {
+ "truncation": True,
+ "padding": "max_length",
+ "pad_to_max_length": True,
+ "return_token_type_ids": False,
+ },
+ }
+
+
+@auto_docstring
+class TvpProcessor(ProcessorMixin):
+ def __init__(self, image_processor=None, tokenizer=None, **kwargs):
+ super().__init__(image_processor, tokenizer)
+ self.video_processor = image_processor
+
+ def post_process_video_grounding(self, logits, video_durations):
+ """
+ Compute the time of the video.
+
+ Args:
+ logits (`torch.Tensor`):
+ The logits output of TvpForVideoGrounding.
+ video_durations (`float`):
+ The video's duration.
+
+ Returns:
+ start (`float`):
+ The start time of the video.
+ end (`float`):
+ The end time of the video.
+ """
+ start, end = (
+ round(logits.tolist()[0][0] * video_durations, 1),
+ round(logits.tolist()[0][1] * video_durations, 1),
+ )
+
+ return start, end
+
+
+__all__ = ["TvpProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/udop/__init__.py b/lib/python3.11/site-packages/transformers/models/udop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..852ad5e3c81ad5979157b7783b21579b8dc22efb
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/udop/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2024 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_udop import *
+ from .modeling_udop import *
+ from .processing_udop import *
+ from .tokenization_udop import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/udop/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f7e25a79f6c44105550df7e000a00eca83418402
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/udop/__pycache__/configuration_udop.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/configuration_udop.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e55159d019b296b9f4d730f7834578a41cc4972e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/configuration_udop.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/udop/__pycache__/modeling_udop.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/modeling_udop.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a90e83c6c35170344ffddd98d64687c0779a493d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/modeling_udop.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/udop/__pycache__/processing_udop.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/processing_udop.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6a13638ca79a0c8adea9dfa1361a6c326a5d96e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/processing_udop.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/udop/__pycache__/tokenization_udop.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/tokenization_udop.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..643f59bcbf6de5829fcb78b1c8c6d67440bc162e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/udop/__pycache__/tokenization_udop.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/udop/configuration_udop.py b/lib/python3.11/site-packages/transformers/models/udop/configuration_udop.py
new file mode 100644
index 0000000000000000000000000000000000000000..58a2315604554eae79cb4bf7a799d13874146913
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/udop/configuration_udop.py
@@ -0,0 +1,96 @@
+# Copyright 2024 HuggingFace Inc.
+#
+# 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.
+"""UDOP model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="microsoft/udop-large")
+@strict
+class UdopConfig(PreTrainedConfig):
+ r"""
+ relative_attention_num_buckets (`int`, *optional*, defaults to 32):
+ The number of buckets to use for each attention layer.
+ relative_attention_max_distance (`int`, *optional*, defaults to 128):
+ The maximum distance of the longer sequences for the bucket separation.
+ relative_bias_args (`list[dict]`, *optional*, defaults to `[{'type': '1d'}, {'type': 'horizontal'}, {'type': 'vertical'}]`):
+ A list of dictionaries containing the arguments for the relative bias layers.
+ feed_forward_proj (`string`, *optional*, defaults to `"relu"`):
+ Type of feed forward layer to be used. Should be one of `"relu"` or `"gated-gelu"`. Udopv1.1 uses the
+ `"gated-gelu"` feed forward projection. Original Udop uses `"relu"`.
+ max_2d_position_embeddings (`int`, *optional*, defaults to 1024):
+ The maximum absolute position embeddings for relative position encoding.
+ """
+
+ model_type = "udop"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ attribute_map = {"hidden_size": "d_model", "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"}
+
+ vocab_size: int = 33201
+ d_model: int = 1024
+ d_kv: int = 64
+ d_ff: int = 4096
+ num_layers: int = 24
+ num_decoder_layers: int | None = None
+ num_heads: int = 16
+ relative_attention_num_buckets: int = 32
+ relative_attention_max_distance: int = 128
+ relative_bias_args: list[dict] | None = None
+ dropout_rate: float | int = 0.1
+ layer_norm_epsilon: float = 1e-6
+ initializer_factor: float = 1.0
+ feed_forward_proj: str = "relu"
+ is_encoder_decoder: bool = True
+ use_cache: bool = True
+ pad_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 1
+ max_2d_position_embeddings: int = 1024
+ image_size: int | list[int] | tuple[int, int] = 224
+ patch_size: int | list[int] | tuple[int, int] = 16
+ num_channels: int = 3
+ is_decoder: bool = False
+ add_cross_attention: bool = False
+ tie_word_embeddings: bool = True
+
+ def __post_init__(self, **kwargs):
+ if self.relative_bias_args is None:
+ self.relative_bias_args = [{"type": "1d"}, {"type": "horizontal"}, {"type": "vertical"}]
+
+ self.num_decoder_layers = (
+ self.num_decoder_layers if self.num_decoder_layers is not None else self.num_layers
+ ) # default = symmetry
+
+ act_info = self.feed_forward_proj.split("-")
+ self.dense_act_fn = act_info[-1]
+ self.is_gated_act = act_info[0] == "gated"
+
+ kwargs.pop("tie_word_embeddings", None)
+ self.tie_word_embeddings = True
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ act_info = self.feed_forward_proj.split("-")
+ if len(act_info) > 1 and act_info[0] != "gated" or len(act_info) > 2:
+ raise ValueError(
+ f"`feed_forward_proj`: {self.feed_forward_proj} is not a valid activation function of the dense layer."
+ "Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. "
+ "'gated-gelu' or 'relu'"
+ )
+
+
+__all__ = ["UdopConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/udop/modeling_udop.py b/lib/python3.11/site-packages/transformers/models/udop/modeling_udop.py
new file mode 100644
index 0000000000000000000000000000000000000000..758d3f2943fadc1fecce564f8167150c36230487
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/udop/modeling_udop.py
@@ -0,0 +1,1730 @@
+# Copyright 2024 Microsoft Research and 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.
+"""PyTorch UDOP model."""
+
+import collections
+import logging
+import math
+import random
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+from torch import Tensor, nn
+from torch.nn import CrossEntropyLoss
+
+from transformers import UdopConfig
+from transformers.modeling_outputs import (
+ Seq2SeqLMOutput,
+ Seq2SeqModelOutput,
+)
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_utils import PreTrainedModel
+from ...utils import (
+ ModelOutput,
+ auto_docstring,
+ is_torchdynamo_compiling,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+@auto_docstring(
+ custom_intro="""
+ Class for the model's outputs that may also contain a past key/values (to speed up sequential decoding). Includes
+ an additional attention mask.
+ """
+)
+@dataclass
+class BaseModelOutputWithAttentionMask(ModelOutput):
+ r"""
+ last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Sequence of hidden-states at the output of the last layer of the model. If `past_key_values` is used only
+ the last hidden-state of the sequences of shape `(batch_size, 1, hidden_size)` is output.
+ attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Attention mask used in the model's forward pass to avoid performing attention on padding token indices.
+ Mask values selected in `[0, 1]`:
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+ Contains pre-computed hidden-states (key and values in the
+ self-attention blocks and optionally if `config.is_encoder_decoder=True` in the cross-attention blocks)
+ that can be used (see `past_key_values` input) to speed up sequential decoding.
+ hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
+ one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of
+ the model at the output of each layer plus the optional initial embedding outputs.
+ attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`. Attentions weights after the attention softmax, used to compute the weighted average in
+ the self-attention heads.
+ cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` and `config.add_cross_attention=True` is passed or when `config.output_attentions=True`):
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax,
+ used to compute the weighted average in the cross-attention heads.
+ """
+
+ last_hidden_state: torch.FloatTensor | None = None
+ attention_mask: torch.FloatTensor | None = None
+ past_key_values: Cache | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+ cross_attentions: tuple[torch.FloatTensor] | None = None
+
+
+def get_visual_bbox(image_size=224, patch_size=16):
+ image_feature_pool_shape = [image_size // patch_size, image_size // patch_size]
+ visual_bbox_x = torch.arange(0, 1.0 * (image_feature_pool_shape[1] + 1), 1.0)
+ visual_bbox_x /= image_feature_pool_shape[1]
+
+ visual_bbox_y = torch.arange(0, 1.0 * (image_feature_pool_shape[0] + 1), 1.0)
+ visual_bbox_y /= image_feature_pool_shape[0]
+
+ visual_bbox_input = torch.stack(
+ [
+ visual_bbox_x[:-1].repeat(image_feature_pool_shape[0], 1),
+ visual_bbox_y[:-1].repeat(image_feature_pool_shape[1], 1).transpose(0, 1),
+ visual_bbox_x[1:].repeat(image_feature_pool_shape[0], 1),
+ visual_bbox_y[1:].repeat(image_feature_pool_shape[1], 1).transpose(0, 1),
+ ],
+ dim=-1,
+ )
+
+ visual_bbox_input = visual_bbox_input.view(-1, 4)
+
+ return visual_bbox_input
+
+
+def pad_sequence(seq, target_len, pad_value=0):
+ if isinstance(seq, torch.Tensor):
+ n = seq.shape[0]
+ else:
+ n = len(seq)
+ seq = torch.tensor(seq)
+ m = target_len - n
+ if m > 0:
+ ret = torch.stack([pad_value] * m).to(seq)
+ seq = torch.cat([seq, ret], dim=0)
+ return seq[:target_len]
+
+
+def combine_image_text_embeddings(
+ image_embeddings,
+ inputs_embeds,
+ bbox,
+ visual_bbox,
+ attention_mask=None,
+ num_patches=14,
+ max_len=0,
+ image_size=224,
+ patch_size=16,
+):
+ """
+ Combine the image and text embeddings for the input to the encoder/decoder of UDOP.
+
+ First, the image embeddings are created by checking for each visual patch if it is inside the bounding box of a
+ token. If it is, the visual patch is combined with the token embedding. Then, the visual bounding boxes are combined
+ with the text bounding boxes. Finally, the visual bounding boxes are combined with the text attention mask.
+ """
+
+ sequence_length = num_patches
+ ocr_points_x = torch.clip(
+ torch.floor((bbox[:, :, 0] + bbox[:, :, 2]) / 2.0 * sequence_length).long(), 0, sequence_length - 1
+ )
+ ocr_points_y = (
+ torch.clip(torch.floor((bbox[:, :, 1] + bbox[:, :, 3]) / 2.0 * sequence_length).long(), 0, sequence_length - 1)
+ * sequence_length
+ )
+ ocr_points = ocr_points_x + ocr_points_y
+ # make sure bounding boxes are of type float to calculate means
+ bbox = bbox.to(torch.float64)
+ target_seg = (bbox.mean(-1) == 0.0) | (bbox.mean(-1) == 1.0)
+ repeated_vision_embeds = torch.gather(
+ image_embeddings, 1, ocr_points.unsqueeze(-1).repeat(1, 1, image_embeddings.size(-1))
+ )
+ repeated_vision_embeds[target_seg] = 0.0
+ inputs_embeds += repeated_vision_embeds
+
+ patch_inds = torch.full_like(image_embeddings[:, :, 0], True).bool()
+ ind = torch.cat(
+ [
+ torch.arange(len(ocr_points))[:, None].repeat(1, ocr_points.size(-1))[:, :, None].to(ocr_points),
+ ocr_points[:, :, None],
+ ],
+ dim=-1,
+ )
+ ind = ind.flatten(0, 1)
+ rows, cols = zip(*ind)
+ patch_inds[rows, cols] = False
+
+ input_vision_patches = [image_embeddings[i][patch_inds[i]] for i in range(len(patch_inds))]
+
+ if visual_bbox is None:
+ visual_bbox = get_visual_bbox(image_size=image_size, patch_size=patch_size)
+ visual_bbox = visual_bbox.unsqueeze(0).repeat(image_embeddings.size(0), 1, 1)
+ visual_bbox = visual_bbox.to(image_embeddings.device)
+
+ visual_bbox = [visual_bbox[i][patch_inds[i]] for i in range(len(patch_inds))]
+
+ if attention_mask is not None:
+ visual_attention_mask = [
+ torch.ones(item.size(0), dtype=attention_mask.dtype, device=attention_mask.device) for item in visual_bbox
+ ]
+
+ if max_len == 0:
+ max_len = image_embeddings.size(1)
+ else:
+ max_len = max_len - inputs_embeds.size(1)
+ inputs_vision_patches = torch.stack(
+ [pad_sequence(item, max_len, torch.zeros_like(image_embeddings[0, 0])) for item in input_vision_patches]
+ )
+ visual_bbox = torch.stack([pad_sequence(item, max_len, torch.zeros_like(bbox[0, 0])) for item in visual_bbox])
+ if attention_mask is not None:
+ visual_attention_mask = torch.stack(
+ [pad_sequence(item, max_len, torch.zeros_like(attention_mask[0, 0])) for item in visual_attention_mask]
+ )
+
+ inputs_embeds = torch.cat([inputs_embeds, inputs_vision_patches], 1)
+ bbox = torch.cat([bbox, visual_bbox], 1)
+ if attention_mask is not None:
+ attention_mask = torch.cat([attention_mask, visual_attention_mask], 1)
+ return inputs_embeds, bbox, attention_mask
+
+
+class UdopPatchEmbeddings(nn.Module):
+ """2D Image to Patch Embeddings"""
+
+ def __init__(self, config):
+ super().__init__()
+ image_size, patch_size = config.image_size, config.patch_size
+ num_channels, hidden_size = config.num_channels, config.hidden_size
+
+ image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+ num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
+ self.image_size = image_size
+ self.patch_size = patch_size
+ self.num_channels = num_channels
+ self.num_patches = num_patches
+
+ self.proj = nn.Conv2d(num_channels, hidden_size, kernel_size=patch_size, stride=patch_size)
+
+ def forward(self, pixel_values):
+ batch_size, num_channels, height, width = pixel_values.shape
+ if height != self.image_size[0] or width != self.image_size[1]:
+ raise ValueError(
+ f"Input image size ({height}*{width}) doesn't match model ({self.image_size[0]}*{self.image_size[1]})."
+ )
+ embeddings = self.proj(pixel_values)
+ embeddings = embeddings.flatten(2).transpose(1, 2)
+ return embeddings
+
+
+@auto_docstring
+class UdopPreTrainedModel(PreTrainedModel):
+ config: UdopConfig
+ base_model_prefix = "transformer"
+ input_modalities = ("image", "text")
+ supports_gradient_checkpointing = True
+
+ _can_compile_fullgraph = False
+ _keep_in_fp32_modules = ["wo"]
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ factor = self.config.initializer_factor # Used for testing weights initialization
+ if isinstance(module, UdopLayerNorm):
+ init.constant_(module.weight, factor * 1.0)
+ elif isinstance(module, nn.Embedding):
+ init.normal_(module.weight, mean=0.0, std=factor)
+ # Here we need the check explicitly, as we slice the weight in the `zeros_` call, so it looses the flag
+ if module.padding_idx is not None and not getattr(module.weight, "_is_hf_initialized", False):
+ init.zeros_(module.weight[module.padding_idx])
+ elif isinstance(module, nn.Conv2d):
+ init.trunc_normal_(module.weight, mean=0.0, std=factor)
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, RelativePositionBiasBase):
+ factor = self.config.initializer_factor
+ d_model = self.config.d_model
+ init.normal_(module.relative_attention_bias.weight, mean=0.0, std=factor * ((d_model) ** -0.5))
+ elif isinstance(module, UdopModel):
+ init.normal_(module.shared.weight, mean=0.0, std=factor * 1.0)
+ elif isinstance(module, UdopForConditionalGeneration):
+ if hasattr(module, "lm_head") and not self.config.tie_word_embeddings:
+ init.normal_(module.lm_head.weight, mean=0.0, std=factor * 1.0)
+ elif isinstance(module, UdopDenseActDense):
+ init.normal_(module.wi.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi, "bias") and module.wi.bias is not None:
+ init.zeros_(module.wi.bias)
+ init.normal_(module.wo.weight, mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
+ if hasattr(module.wo, "bias") and module.wo.bias is not None:
+ init.zeros_(module.wo.bias)
+ elif isinstance(module, UdopDenseGatedActDense):
+ init.normal_(module.wi_0.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi_0, "bias") and module.wi_0.bias is not None:
+ init.zeros_(module.wi_0.bias)
+ init.normal_(module.wi_1.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi_1, "bias") and module.wi_1.bias is not None:
+ init.zeros_(module.wi_1.bias)
+ init.normal_(module.wo.weight, mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
+ if hasattr(module.wo, "bias") and module.wo.bias is not None:
+ init.zeros_(module.wo.bias)
+ elif isinstance(module, UdopAttention):
+ d_model = self.config.d_model
+ key_value_proj_dim = self.config.d_kv
+ n_heads = self.config.num_heads
+ init.normal_(module.q.weight, mean=0.0, std=factor * ((d_model * key_value_proj_dim) ** -0.5))
+ init.normal_(module.k.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.v.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.o.weight, mean=0.0, std=factor * ((n_heads * key_value_proj_dim) ** -0.5))
+ if module.has_relative_attention_bias:
+ init.normal_(module.relative_attention_bias.weight, mean=0.0, std=factor * ((d_model) ** -0.5))
+
+ # Copied from transformers.models.prophetnet.modeling_prophetnet.ProphetNetPreTrainedModel._shift_right with ProphetNet->Udop
+ def _shift_right(self, input_ids):
+ decoder_start_token_id = self.config.decoder_start_token_id
+ pad_token_id = self.config.pad_token_id
+
+ assert decoder_start_token_id is not None, (
+ "self.model.config.decoder_start_token_id has to be defined. In Udop it is usually set to the"
+ " pad_token_id. See Udop docs for more information"
+ )
+
+ # shift inputs to the right
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
+ shifted_input_ids[..., 0] = decoder_start_token_id
+
+ assert pad_token_id is not None, "self.model.config.pad_token_id has to be defined."
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ assert torch.all(shifted_input_ids >= 0).item(), "Verify that `shifted_input_ids` has only positive values"
+
+ return shifted_input_ids
+
+
+# Copied from transformers.models.t5.modeling_t5.T5LayerNorm with T5->Udop
+class UdopLayerNorm(nn.Module):
+ def __init__(self, hidden_size, eps=1e-6):
+ """
+ Construct a layernorm module in the Udop style. No bias and no subtraction of mean.
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states):
+ # Udop uses a layer_norm which only scales and doesn't shift, which is also known as Root Mean
+ # Square Layer Normalization https://huggingface.co/papers/1910.07467 thus variance is calculated
+ # w/o mean and there is no bias. Additionally we want to make sure that the accumulation for
+ # half-precision inputs is done in fp32
+
+ variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+
+ # convert into half-precision if necessary
+ if self.weight.dtype in [torch.float16, torch.bfloat16]:
+ hidden_states = hidden_states.to(self.weight.dtype)
+
+ return self.weight * hidden_states
+
+
+# Copied from transformers.models.t5.modeling_t5.T5DenseActDense with T5->Udop
+class UdopDenseActDense(nn.Module):
+ def __init__(self, config: UdopConfig):
+ super().__init__()
+ self.wi = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.act = ACT2FN[config.dense_act_fn]
+
+ def forward(self, hidden_states):
+ hidden_states = self.wi(hidden_states)
+ hidden_states = self.act(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ if (
+ isinstance(self.wo.weight, torch.Tensor)
+ and hidden_states.dtype != self.wo.weight.dtype
+ and self.wo.weight.dtype != torch.int8
+ ):
+ hidden_states = hidden_states.to(self.wo.weight.dtype)
+ hidden_states = self.wo(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.t5.modeling_t5.T5DenseGatedActDense with T5->Udop
+class UdopDenseGatedActDense(nn.Module):
+ def __init__(self, config: UdopConfig):
+ super().__init__()
+ self.wi_0 = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wi_1 = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.act = ACT2FN[config.dense_act_fn]
+
+ def forward(self, hidden_states):
+ hidden_gelu = self.act(self.wi_0(hidden_states))
+ hidden_linear = self.wi_1(hidden_states)
+ hidden_states = hidden_gelu * hidden_linear
+ hidden_states = self.dropout(hidden_states)
+
+ # To make 8bit quantization work for google/flan-t5-xxl, self.wo is kept in float32.
+ # See https://github.com/huggingface/transformers/issues/20287
+ # we also make sure the weights are not in `int8` in case users will force `_keep_in_fp32_modules` to be `None``
+ if (
+ isinstance(self.wo.weight, torch.Tensor)
+ and hidden_states.dtype != self.wo.weight.dtype
+ and self.wo.weight.dtype != torch.int8
+ ):
+ hidden_states = hidden_states.to(self.wo.weight.dtype)
+
+ hidden_states = self.wo(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.t5.modeling_t5.T5LayerFF with T5->Udop
+class UdopLayerFF(nn.Module):
+ def __init__(self, config: UdopConfig):
+ super().__init__()
+ if config.is_gated_act:
+ self.DenseReluDense = UdopDenseGatedActDense(config)
+ else:
+ self.DenseReluDense = UdopDenseActDense(config)
+
+ self.layer_norm = UdopLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(self, hidden_states):
+ forwarded_states = self.layer_norm(hidden_states)
+ forwarded_states = self.DenseReluDense(forwarded_states)
+ hidden_states = hidden_states + self.dropout(forwarded_states)
+ return hidden_states
+
+
+# Copied from transformers.models.t5.modeling_t5.T5Attention with T5->Udop
+class UdopAttention(nn.Module):
+ def __init__(
+ self,
+ config: UdopConfig,
+ has_relative_attention_bias=False,
+ layer_idx: int | None = None,
+ ):
+ super().__init__()
+ self.is_decoder = config.is_decoder
+ self.has_relative_attention_bias = has_relative_attention_bias
+ self.relative_attention_num_buckets = config.relative_attention_num_buckets
+ self.relative_attention_max_distance = config.relative_attention_max_distance
+ self.d_model = config.d_model
+ self.key_value_proj_dim = config.d_kv
+ self.n_heads = config.num_heads
+ self.dropout = config.dropout_rate
+ self.inner_dim = self.n_heads * self.key_value_proj_dim
+ self.layer_idx = layer_idx
+ if layer_idx is None and self.is_decoder:
+ logger.warning_once(
+ f"Instantiating a decoder {self.__class__.__name__} without passing `layer_idx` is not recommended and "
+ "will to errors during the forward call, if caching is used. Please make sure to provide a `layer_idx` "
+ "when creating this class."
+ )
+
+ self.q = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.k = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.v = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.o = nn.Linear(self.inner_dim, self.d_model, bias=False)
+
+ if self.has_relative_attention_bias:
+ self.relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets, self.n_heads)
+
+ self.gradient_checkpointing = False
+
+ @staticmethod
+ def _relative_position_bucket(relative_position, bidirectional=True, num_buckets=32, max_distance=128):
+ """
+ Adapted from Mesh Tensorflow:
+ https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593
+
+ Translate relative position to a bucket number for relative attention. The relative position is defined as
+ memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to
+ position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for
+ small absolute relative_position and larger buckets for larger absolute relative_positions. All relative
+ positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket.
+ This should allow for more graceful generalization to longer sequences than the model has been trained on
+
+ Args:
+ relative_position: an int32 Tensor
+ bidirectional: a boolean - whether the attention is bidirectional
+ num_buckets: an integer
+ max_distance: an integer
+
+ Returns:
+ a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets)
+ """
+ relative_buckets = 0
+ if bidirectional:
+ num_buckets //= 2
+ relative_buckets += (relative_position > 0).to(torch.long) * num_buckets
+ relative_position = torch.abs(relative_position)
+ else:
+ relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
+ # now relative_position is in the range [0, inf)
+
+ # half of the buckets are for exact increments in positions
+ max_exact = num_buckets // 2
+ is_small = relative_position < max_exact
+
+ # The other half of the buckets are for logarithmically bigger bins in positions up to max_distance
+ relative_position_if_large = max_exact + (
+ torch.log(relative_position.float() / max_exact)
+ / math.log(max_distance / max_exact)
+ * (num_buckets - max_exact)
+ ).to(torch.long)
+ relative_position_if_large = torch.min(
+ relative_position_if_large, torch.full_like(relative_position_if_large, num_buckets - 1)
+ )
+
+ relative_buckets += torch.where(is_small, relative_position, relative_position_if_large)
+ return relative_buckets
+
+ def compute_bias(self, query_length, key_length, device=None, past_seen_tokens=0):
+ """Compute binned relative position bias"""
+ if device is None:
+ device = self.relative_attention_bias.weight.device
+ context_position = torch.arange(query_length, dtype=torch.long, device=device)[:, None] + past_seen_tokens
+ memory_position = torch.arange(key_length, dtype=torch.long, device=device)[None, :]
+ relative_position = memory_position - context_position # shape (query_length, key_length)
+ relative_position_bucket = self._relative_position_bucket(
+ relative_position, # shape (query_length, key_length)
+ bidirectional=(not self.is_decoder),
+ num_buckets=self.relative_attention_num_buckets,
+ max_distance=self.relative_attention_max_distance,
+ )
+ values = self.relative_attention_bias(relative_position_bucket) # shape (query_length, key_length, num_heads)
+ values = values.permute([2, 0, 1]).unsqueeze(0) # shape (1, num_heads, query_length, key_length)
+ return values
+
+ def forward(
+ self,
+ hidden_states,
+ mask=None,
+ key_value_states=None,
+ position_bias=None,
+ past_key_values=None,
+ output_attentions=False,
+ **kwargs,
+ ):
+ """
+ Self-attention (if key_value_states is None) or attention over source sentence (provided by key_value_states).
+ """
+ # Input is (batch_size, seq_length, dim)
+ # Mask is (batch_size, 1, 1, key_length) (non-causal encoder) or (batch_size, 1, seq_length, key_length) (causal decoder)
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.key_value_proj_dim)
+ past_seen_tokens = past_key_values.get_seq_length(self.layer_idx) if past_key_values is not None else 0
+ # We clone here for StaticCache, as we get the value before updating it, but use it after and it's the same ref
+ past_seen_tokens = past_seen_tokens.clone() if isinstance(past_seen_tokens, torch.Tensor) else past_seen_tokens
+
+ # if key_value_states are provided this layer is used as a cross-attention layer for the decoder
+ is_cross_attention = key_value_states is not None
+
+ query_states = self.q(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ # Check is encoder-decoder model is being used. Otherwise we'll get `DynamicCache`
+ is_updated = False
+ if isinstance(past_key_values, EncoderDecoderCache):
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ if is_cross_attention:
+ # after the first generated id, we can subsequently re-use all key/value_states from cache
+ curr_past_key_values = past_key_values.cross_attention_cache
+ else:
+ curr_past_key_values = past_key_values.self_attention_cache
+ else:
+ curr_past_key_values = past_key_values
+
+ current_states = key_value_states if is_cross_attention else hidden_states
+ if is_cross_attention and past_key_values is not None and is_updated:
+ # reuse k,v, cross_attentions
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+ else:
+ kv_shape = (*current_states.shape[:-1], -1, self.key_value_proj_dim)
+ key_states = self.k(current_states).view(kv_shape).transpose(1, 2)
+ value_states = self.v(current_states).view(kv_shape).transpose(1, 2)
+
+ if past_key_values is not None:
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+ if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+ past_key_values.is_updated[self.layer_idx] = True
+
+ # compute scores, equivalent of torch.einsum("bnqd,bnkd->bnqk", query_states, key_states), compatible with onnx op>9
+ scores = torch.matmul(query_states, key_states.transpose(3, 2))
+
+ if position_bias is None:
+ key_length = key_states.shape[-2]
+ if not self.has_relative_attention_bias:
+ position_bias = torch.zeros(
+ (1, query_states.shape[1], input_shape[1], key_length), device=scores.device, dtype=scores.dtype
+ )
+ if self.gradient_checkpointing and self.training:
+ position_bias.requires_grad = True
+ else:
+ position_bias = self.compute_bias(
+ input_shape[1], key_length, device=scores.device, past_seen_tokens=past_seen_tokens
+ )
+
+ if mask is not None:
+ causal_mask = mask[:, :, :, : key_states.shape[-2]]
+ position_bias = position_bias + causal_mask
+
+ position_bias_masked = position_bias
+ scores += position_bias_masked
+
+ # (batch_size, n_heads, seq_length, key_length)
+ attn_weights = nn.functional.softmax(scores.float(), dim=-1).type_as(scores)
+ attn_weights = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+ attn_output = torch.matmul(attn_weights, value_states)
+
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ attn_output = attn_output.reshape(*input_shape, -1)
+ attn_output = self.o(attn_output)
+
+ outputs = (attn_output, position_bias)
+
+ if output_attentions:
+ outputs = outputs + (attn_weights,)
+ return outputs
+
+
+# Copied from transformers.models.t5.modeling_t5.T5LayerSelfAttention with T5->Udop
+class UdopLayerSelfAttention(nn.Module):
+ def __init__(self, config, has_relative_attention_bias=False, layer_idx: int | None = None):
+ super().__init__()
+ self.SelfAttention = UdopAttention(
+ config, has_relative_attention_bias=has_relative_attention_bias, layer_idx=layer_idx
+ )
+ self.layer_norm = UdopLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ position_bias=None,
+ past_key_values=None,
+ use_cache=False,
+ output_attentions=False,
+ **kwargs,
+ ):
+ normed_hidden_states = self.layer_norm(hidden_states)
+ attention_output = self.SelfAttention(
+ normed_hidden_states,
+ mask=attention_mask,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ )
+ hidden_states = hidden_states + self.dropout(attention_output[0])
+ outputs = (hidden_states,) + attention_output[1:] # add attentions if we output them
+ return outputs
+
+
+# Copied from transformers.models.t5.modeling_t5.T5LayerCrossAttention with T5->Udop
+class UdopLayerCrossAttention(nn.Module):
+ def __init__(self, config, layer_idx: int | None = None):
+ super().__init__()
+ self.EncDecAttention = UdopAttention(config, has_relative_attention_bias=False, layer_idx=layer_idx)
+ self.layer_norm = UdopLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states,
+ key_value_states,
+ attention_mask=None,
+ position_bias=None,
+ past_key_values=None,
+ output_attentions=False,
+ **kwargs,
+ ):
+ normed_hidden_states = self.layer_norm(hidden_states)
+ attention_output = self.EncDecAttention(
+ normed_hidden_states,
+ mask=attention_mask,
+ key_value_states=key_value_states,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+ layer_output = hidden_states + self.dropout(attention_output[0])
+ outputs = (layer_output,) + attention_output[1:] # add attentions if we output them
+ return outputs
+
+
+# Copied from transformers.models.t5.modeling_t5.T5Block with T5->Udop
+class UdopBlock(GradientCheckpointingLayer):
+ def __init__(self, config, has_relative_attention_bias=False, layer_idx: int | None = None):
+ super().__init__()
+ self.is_decoder = config.is_decoder
+ self.layer = nn.ModuleList()
+ self.layer.append(
+ UdopLayerSelfAttention(
+ config, has_relative_attention_bias=has_relative_attention_bias, layer_idx=layer_idx
+ )
+ )
+ if self.is_decoder:
+ self.layer.append(UdopLayerCrossAttention(config, layer_idx=layer_idx))
+
+ self.layer.append(UdopLayerFF(config))
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ position_bias=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ encoder_decoder_position_bias=None,
+ past_key_values=None,
+ use_cache=False,
+ output_attentions=False,
+ return_dict=True,
+ **kwargs,
+ ):
+ self_attention_outputs = self.layer[0](
+ hidden_states,
+ attention_mask=attention_mask,
+ position_bias=position_bias,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ )
+ hidden_states = self_attention_outputs[0]
+ attention_outputs = self_attention_outputs[1:] # Keep self-attention outputs and relative position weights
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16:
+ clamp_value = torch.where(
+ torch.isinf(hidden_states).any(),
+ torch.finfo(hidden_states.dtype).max - 1000,
+ torch.finfo(hidden_states.dtype).max,
+ )
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ do_cross_attention = self.is_decoder and encoder_hidden_states is not None
+ if do_cross_attention:
+ cross_attention_outputs = self.layer[1](
+ hidden_states,
+ key_value_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ position_bias=encoder_decoder_position_bias,
+ past_key_values=past_key_values,
+ output_attentions=output_attentions,
+ )
+ hidden_states = cross_attention_outputs[0]
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16:
+ clamp_value = torch.where(
+ torch.isinf(hidden_states).any(),
+ torch.finfo(hidden_states.dtype).max - 1000,
+ torch.finfo(hidden_states.dtype).max,
+ )
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ # Keep cross-attention outputs and relative position weights
+ attention_outputs = attention_outputs + cross_attention_outputs[1:]
+
+ # Apply Feed Forward layer
+ hidden_states = self.layer[-1](hidden_states)
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16:
+ clamp_value = torch.where(
+ torch.isinf(hidden_states).any(),
+ torch.finfo(hidden_states.dtype).max - 1000,
+ torch.finfo(hidden_states.dtype).max,
+ )
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ outputs = (hidden_states,)
+
+ return (
+ outputs + attention_outputs
+ ) # hidden-states, (self-attention position bias), (self-attention weights), (cross-attention position bias), (cross-attention weights)
+
+
+class UdopCellEmbeddings(nn.Module):
+ def __init__(self, max_2d_position_embeddings=501, hidden_size=1024):
+ super().__init__()
+ self.max_2d_position_embeddings = max_2d_position_embeddings
+
+ self.x_position_embeddings = nn.Embedding(max_2d_position_embeddings, hidden_size)
+ self.y_position_embeddings = nn.Embedding(max_2d_position_embeddings, hidden_size)
+
+ def forward(self, bbox):
+ bbox = torch.clip(bbox, 0.0, 1.0)
+ bbox = (bbox * (self.max_2d_position_embeddings - 1)).long()
+ left_position_embeddings = self.x_position_embeddings(bbox[:, :, 0])
+ upper_position_embeddings = self.y_position_embeddings(bbox[:, :, 1])
+ right_position_embeddings = self.x_position_embeddings(bbox[:, :, 2])
+ lower_position_embeddings = self.y_position_embeddings(bbox[:, :, 3])
+
+ embeddings = (
+ left_position_embeddings
+ + upper_position_embeddings
+ + right_position_embeddings
+ + lower_position_embeddings
+ )
+
+ return embeddings
+
+
+# get function for bucket computation
+# protected member access seems to be lesser evil than copy paste whole function
+get_relative_position_bucket = UdopAttention._relative_position_bucket
+AUGMENTATION_RANGE = (0.80, 1.25)
+
+
+class RelativePositionBiasBase(nn.Module, ABC):
+ """
+ Base class of relative biases.
+
+ Args:
+ num_heads (`int`):
+ Number of attention heads in the model, it will create embeddings of size `num_heads`, which will be added to the scores of each token pair.
+ relative_attention_num_buckets (`int`, *optional*, defaults to 32):
+ Pair token metric (distance in the sequence, distance in pixels etc.) will be bucketed, parameter is defining number of such
+ buckets.
+ bidirectional (`bool`, *optional*, defaults to `True`):
+ Whether the distance should be bidirectional for a pair of tokens. If `False`, then distance(tok1, tok2) == distance(tok2, tok1).
+ scaling_factor (`int`, *optional*, defaults to 1):
+ Defining factor which will be used to scale relative distance.
+ max_distance (`int`, *optional*, defaults to 128):
+ All distances above this value will end up in the one/same bucket.
+ augmentation (`bool`, *optional*, defaults to `False`):
+ Whether to multiply relative distances by a random scalar.
+ expand (`bool`, *optional*, defaults to `False`):
+ Whether to expand an existing pretrained model with subsequent additions of prefix_bucket.
+ """
+
+ def __init__(
+ self,
+ num_heads=None,
+ relative_attention_num_buckets=32,
+ bidirectional=True,
+ scaling_factor=1,
+ max_distance=128,
+ level="tokens",
+ augmentation=False,
+ prefix_bucket=False,
+ expand=False,
+ ):
+ super().__init__()
+ self.prefix_bucket = prefix_bucket
+ self.augmentation = augmentation
+ self.level = level
+ self.max_distance = max_distance
+ self.scaling_factor = scaling_factor
+ self.bidirectional = bidirectional
+ self.num_heads = num_heads
+ self.expand = expand
+ self.relative_attention_num_buckets = relative_attention_num_buckets
+ extra_head = 2 if prefix_bucket and not self.expand else 0
+ self.relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets + extra_head, self.num_heads)
+
+ @abstractmethod
+ def prepare_input(
+ self,
+ attention_mask: Tensor | None = None,
+ bbox: dict[str, Any] | None = None,
+ ) -> Tensor:
+ pass
+
+ def get_bucket(self, attention_mask: Tensor | None = None, bbox: dict[str, Any] | None = None) -> Tensor:
+ relative_position = self.prepare_input(attention_mask, bbox)
+ rp_bucket: Tensor = get_relative_position_bucket(
+ relative_position,
+ bidirectional=self.bidirectional,
+ num_buckets=self.relative_attention_num_buckets,
+ max_distance=self.max_distance,
+ )
+ return rp_bucket
+
+ def get_relative_position(self, positions):
+ context_position = positions[:, :, None]
+ memory_position = positions[:, None, :]
+ relative_position = memory_position - context_position
+ if self.augmentation and self.training:
+ relative_position *= random.uniform(*AUGMENTATION_RANGE)
+ relative_position *= self.scaling_factor
+
+ return relative_position.to(torch.long)
+
+ def forward(self, attention_mask: Tensor | None = None, bbox: dict[str, Any] | None = None) -> Tensor:
+ # re-using pretrained model with subsequent addition of prefix_bucket
+ if self.expand and self.prefix_bucket:
+ new_bias = nn.Embedding(self.relative_attention_num_buckets + 2, self.num_heads)
+ new_bias.weight.data[: self.relative_attention_num_buckets] = self.relative_attention_bias.weight.data
+ new_bias.weight.data[self.relative_attention_num_buckets :] = 0.1
+ self.relative_attention_bias = new_bias
+ self.expand = False
+
+ rp_bucket = self.get_bucket(attention_mask, bbox)
+
+ if self.prefix_bucket:
+ if rp_bucket.size(0) == 1 and attention_mask.size(0) > 1:
+ rp_bucket = rp_bucket.repeat(attention_mask.size(0), 1, 1)
+ # based on assumption that prefix bboxes are negative
+ is_prefix = bbox[:, :, 1] < 0
+ num_prefix = is_prefix.sum(-1)
+ for idx, num_prefix_row in enumerate(num_prefix.cpu().numpy()):
+ rp_bucket[idx, :num_prefix_row, num_prefix_row:] = self.relative_attention_num_buckets
+ rp_bucket[idx, num_prefix_row:, :num_prefix_row] = self.relative_attention_num_buckets + 1
+
+ values: Tensor = self.relative_attention_bias(rp_bucket)
+ if values.dim() != 4:
+ raise ValueError("Wrong dimension of values tensor")
+ values = values.permute([0, 3, 1, 2])
+
+ return values
+
+
+class RelativePositionBias1D(RelativePositionBiasBase):
+ def __init__(self, scaling_factor=1, max_distance=128, **kwargs):
+ """
+ Reimplementation of T5 relative position bias. Distance between given tokens is their distance in the sequence.
+ Parameters are the same as in base class
+ """
+ super().__init__(scaling_factor=scaling_factor, max_distance=max_distance, **kwargs)
+
+ def prepare_input(self, attention_mask: Tensor | None = None, bbox: dict[str, Any] | None = None) -> Tensor:
+ if self.scaling_factor != 1:
+ raise ValueError("No need to scale 1d features")
+ relative_position = self.get_relative_position(
+ torch.arange(attention_mask.size(1), dtype=torch.long, device=attention_mask.device)[None, :]
+ )
+
+ return relative_position
+
+
+class RelativePositionBiasHorizontal(RelativePositionBiasBase):
+ def __init__(self, scaling_factor=100, max_distance=100, **kwargs):
+ """
+ Represents in the bucket embeddings horizontal distance between two tokens. Parameters are the same as in base
+ class
+ """
+ super().__init__(scaling_factor=scaling_factor, max_distance=max_distance, **kwargs)
+
+ def prepare_input(self, attention_mask: Tensor | None = None, bbox: dict[str, Any] | None = None) -> Tensor:
+ if not self.scaling_factor > 1.0:
+ raise ValueError("Need to scale the values of bboxes, as there are in small (0,1) range")
+ if bbox is None:
+ raise ValueError("Bbox is required for horizontal relative position bias")
+ # get x positions of left point of bbox
+ horizontal_position: Tensor = bbox[:, :, [0, 2]].mean(dim=-1)
+
+ return self.get_relative_position(horizontal_position)
+
+
+class RelativePositionBiasVertical(RelativePositionBiasBase):
+ def __init__(self, scaling_factor=100, max_distance=100, **kwargs):
+ """
+ Represents in the bucket embeddings vertical distance between two tokens. Parameters are the same as in base
+ class
+ """
+ super().__init__(scaling_factor=scaling_factor, max_distance=max_distance, **kwargs)
+
+ def prepare_input(self, attention_mask: Tensor | None = None, bbox: dict[str, Any] | None = None) -> Tensor:
+ if not self.scaling_factor > 1.0:
+ raise ValueError("Need to scale the values of bboxes, as there are in small (0,1) range")
+ if bbox is None:
+ raise ValueError("Bbox is required for vertical relative position bias")
+ # get y positions of middle of bbox
+ vertical_position: Tensor = bbox[:, :, [1, 3]].mean(dim=-1)
+
+ return self.get_relative_position(vertical_position)
+
+
+class RelativePositionBiasAggregated(nn.Module):
+ def __init__(self, modules: Sequence[RelativePositionBiasBase]):
+ """
+ Class which sums up various computed biases.
+
+ Args:
+ modules (Sequence[RelativePositionBiasBase]):
+ List of relative bias modules.
+ """
+ super().__init__()
+ self.biases = nn.ModuleList(modules)
+
+ def forward(self, attention_mask: Tensor | None = None, bbox: dict[str, Any] | None = None) -> float | Tensor:
+ output = 0.0
+ for bias in self.biases: # type: ignore
+ output = bias(attention_mask, bbox) + output
+
+ return output
+
+
+BIAS_CLASSES = {
+ "1d": RelativePositionBias1D,
+ "horizontal": RelativePositionBiasHorizontal,
+ "vertical": RelativePositionBiasVertical,
+}
+
+
+def create_relative_bias(config: UdopConfig) -> Sequence[RelativePositionBiasBase]:
+ """
+ Creates empty list or one/multiple relative biases.
+
+ :param config: Model's configuration :return: Sequence with created bias modules.
+ """
+ bias_list = []
+ if hasattr(config, "relative_bias_args"):
+ for bias_kwargs_org in config.relative_bias_args:
+ bias_kwargs = deepcopy(bias_kwargs_org)
+ bias_type = bias_kwargs.pop("type")
+ model_num_heads = config.num_heads if hasattr(config, "num_heads") else config.num_attention_heads
+ if "num_heads" in bias_kwargs:
+ if bias_kwargs["num_heads"] != model_num_heads:
+ raise ValueError("Number of heads must match num of heads in the model")
+ else:
+ bias_kwargs["num_heads"] = model_num_heads
+ bias_list.append(BIAS_CLASSES[bias_type](**bias_kwargs)) # type: ignore
+
+ return bias_list
+
+
+class UdopStack(UdopPreTrainedModel):
+ """
+ This class is based on `T5Stack`, but modified to take into account the image modality as well as 2D position
+ embeddings.
+ """
+
+ def __init__(self, config):
+ super().__init__(config)
+ # text and image embeddings
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.d_model)
+ self.embed_patches = UdopPatchEmbeddings(config)
+ self.is_decoder = config.is_decoder
+ self.num_layers = config.num_layers
+
+ self.block = nn.ModuleList(
+ [UdopBlock(config, has_relative_attention_bias=bool(i == 0), layer_idx=i) for i in range(self.num_layers)]
+ )
+ self.final_layer_norm = UdopLayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ if not self.is_decoder:
+ self.cell_2d_embedding = UdopCellEmbeddings(config.max_2d_position_embeddings, config.hidden_size)
+
+ # get weights from encoder position bias
+ self.relative_bias = self._get_relative_bias(config)
+ self.post_init()
+
+ @staticmethod
+ def _get_relative_bias(config: UdopConfig) -> RelativePositionBiasAggregated:
+ relative_bias_list = create_relative_bias(config)
+ return RelativePositionBiasAggregated(relative_bias_list)
+
+ def get_output_embeddings(self):
+ return self.embed_tokens
+
+ def set_input_embeddings(self, new_embeddings):
+ self.embed_tokens = new_embeddings
+
+ def forward(
+ self,
+ input_ids=None,
+ attention_mask=None,
+ bbox=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ inputs_embeds=None,
+ pixel_values=None,
+ visual_bbox=None,
+ image_embeddings=None,
+ position_bias=None,
+ past_key_values=None,
+ use_cache=None,
+ output_attentions=None,
+ output_hidden_states=None,
+ return_dict=None,
+ **kwargs,
+ ) -> tuple | BaseModelOutputWithAttentionMask:
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # input embeddings processing
+
+ if input_ids is not None and inputs_embeds is not None:
+ err_msg_prefix = "decoder_" if self.is_decoder else ""
+ raise ValueError(
+ f"You cannot specify both {err_msg_prefix}inputs and {err_msg_prefix}inputs_embeds at the same time"
+ )
+ elif input_ids is not None and torch.numel(input_ids) > 0:
+ input_shape = input_ids.size()
+ input_ids = input_ids.view(-1, input_shape[-1])
+ elif inputs_embeds is None and input_ids is not None and torch.numel(input_ids) == 0:
+ input_ids = torch.full((4, 1024), self.config.pad_token_id, device=input_ids.device, dtype=input_ids.dtype)
+ attention_mask = torch.zeros((4, 1024), device=input_ids.device, dtype=input_ids.dtype)
+ bbox = torch.zeros((4, 1024, 4), device=input_ids.device, dtype=input_ids.dtype)
+ input_shape = input_ids.size()
+ position_bias = torch.zeros_like(attention_mask[:, None, None, :]).to(self.dtype)
+ logger.warning("Empty batch")
+ elif inputs_embeds is not None:
+ input_shape = inputs_embeds.size()[:-1]
+ else:
+ err_msg_prefix = "decoder_" if self.is_decoder else ""
+ raise ValueError(f"You have to specify either {err_msg_prefix}inputs or {err_msg_prefix}inputs_embeds")
+
+ if inputs_embeds is None:
+ if self.embed_tokens is None:
+ raise ValueError("You have to initialize the model with valid token embeddings")
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ if pixel_values is not None:
+ image_embeddings = self.embed_patches(pixel_values)
+
+ if image_embeddings is not None:
+ # combine visual and OCR text embeddings
+ num_patches = self.config.image_size // self.config.patch_size
+ inputs_embeds, bbox, attention_mask = combine_image_text_embeddings(
+ image_embeddings,
+ inputs_embeds,
+ bbox,
+ visual_bbox,
+ attention_mask,
+ num_patches,
+ 0,
+ self.config.image_size,
+ self.config.patch_size,
+ )
+ input_shape = inputs_embeds.size()[:-1]
+
+ if not self.is_decoder and bbox is not None:
+ inputs_embeds += self.cell_2d_embedding(bbox)
+
+ batch_size, seq_length = input_shape
+
+ if use_cache is True:
+ assert self.is_decoder, f"`use_cache` can only be set to `True` if {self} is used as a decoder"
+
+ if self.is_decoder:
+ if use_cache and past_key_values is None:
+ if self.config.is_encoder_decoder:
+ past_key_values = EncoderDecoderCache(
+ DynamicCache(config=self.config), DynamicCache(config=self.config)
+ )
+ else:
+ past_key_values = DynamicCache(config=self.config)
+ elif not self.is_decoder:
+ # do not pass cache object down the line for encoder stack
+ # it messes indexing later in decoder-stack because cache object is modified in-place
+ past_key_values = None
+
+ past_key_values_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+ if attention_mask is None and not is_torchdynamo_compiling():
+ # required mask seq length can be calculated via length of past cache
+ mask_seq_length = past_key_values_length + seq_length
+ attention_mask = torch.ones(batch_size, mask_seq_length, device=inputs_embeds.device)
+
+ if self.config.is_decoder:
+ causal_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+ else:
+ causal_mask = attention_mask[:, None, None, :]
+ causal_mask = causal_mask.to(dtype=inputs_embeds.dtype)
+ causal_mask = (1.0 - causal_mask) * torch.finfo(inputs_embeds.dtype).min
+
+ if self.is_decoder and encoder_attention_mask is not None:
+ encoder_extended_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+ else:
+ encoder_extended_attention_mask = None
+
+ all_hidden_states = () if output_hidden_states else None
+ all_attentions = () if output_attentions else None
+ all_cross_attentions = () if (output_attentions and self.is_decoder) else None
+
+ if self.is_decoder: # modified lines
+ position_bias = None
+ else:
+ position_bias = self.relative_bias(attention_mask=attention_mask, bbox=bbox)
+ position_bias = position_bias + causal_mask
+ encoder_decoder_position_bias = None
+
+ hidden_states = inputs_embeds
+
+ hidden_states = self.dropout(hidden_states)
+
+ for i, layer_module in enumerate(self.block):
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ layer_outputs = layer_module(
+ hidden_states,
+ causal_mask,
+ position_bias,
+ encoder_hidden_states,
+ encoder_extended_attention_mask,
+ encoder_decoder_position_bias, # as a positional argument for gradient checkpointing
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = layer_outputs[0]
+
+ # We share the position biases between the layers - the first layer store them
+ # layer_outputs = hidden-states, key-value-states (self-attention weights),
+ # (self-attention position bias), (cross-attention weights), (cross-attention position bias)
+
+ position_bias = layer_outputs[1]
+ if self.is_decoder and encoder_hidden_states is not None:
+ encoder_decoder_position_bias = layer_outputs[3 if output_attentions else 2]
+
+ if output_attentions:
+ all_attentions = all_attentions + (layer_outputs[2],) # We keep only self-attention weights for now
+ if self.is_decoder:
+ all_cross_attentions = all_cross_attentions + (layer_outputs[4],)
+
+ hidden_states = self.final_layer_norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ # Add last layer
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(
+ v
+ for v in [
+ hidden_states,
+ attention_mask,
+ past_key_values,
+ all_hidden_states,
+ all_attentions,
+ all_cross_attentions,
+ ]
+ if v is not None
+ )
+
+ return BaseModelOutputWithAttentionMask(
+ last_hidden_state=hidden_states,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ hidden_states=all_hidden_states,
+ attentions=all_attentions,
+ cross_attentions=all_cross_attentions,
+ )
+
+
+@auto_docstring
+class UdopModel(UdopPreTrainedModel):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ "encoder.embed_patches.proj.weight": "patch_embed.proj.weight",
+ "encoder.embed_patches.proj.bias": "patch_embed.proj.bias",
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+
+ # text and image embeddings
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+ self.patch_embed = UdopPatchEmbeddings(config)
+
+ encoder_config = deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = UdopStack(encoder_config)
+
+ decoder_config = deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = UdopStack(decoder_config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: Tensor | None = None,
+ attention_mask: Tensor | None = None,
+ bbox: dict[str, Any] | None = None,
+ pixel_values: Tensor | None = None,
+ visual_bbox: dict[str, Any] | None = None,
+ decoder_input_ids: Tensor | None = None,
+ decoder_attention_mask: Tensor | None = None,
+ inputs_embeds: Tensor | None = None,
+ encoder_outputs: Tensor | None = None,
+ past_key_values: Cache | None = None,
+ decoder_inputs_embeds: Tensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | Seq2SeqModelOutput:
+ r"""
+ bbox (`torch.LongTensor` of shape `({0}, 4)`, *optional*):
+ Bounding boxes of each input sequence tokens. Selected in the range `[0,
+ config.max_2d_position_embeddings-1]`. Each bounding box should be a normalized version in (x0, y0, x1, y1)
+ format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1,
+ y1) represents the position of the lower right corner.
+
+ Note that `sequence_length = token_sequence_length + patch_sequence_length + 1` where `1` is for [CLS]
+ token. See `pixel_values` for `patch_sequence_length`.
+ visual_bbox (`torch.LongTensor` of shape `(batch_size, patch_sequence_length, 4)`, *optional*):
+ Bounding boxes of each patch in the image. If not provided, bounding boxes are created in the model.
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary. Indices can be obtained using
+ [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details.
+ [What are decoder input IDs?](../glossary#decoder-input-ids) T5 uses the `pad_token_id` as the starting
+ token for `decoder_input_ids` generation. If `past_key_values` is used, optionally only the last
+ `decoder_input_ids` have to be input (see `past_key_values`). To know more on how to prepare
+ `decoder_input_ids` for pretraining take a look at [T5 Training](./t5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+
+ Example:
+
+ ```python
+ >>> from transformers import AutoProcessor, AutoModel
+ >>> from datasets import load_dataset
+ >>> import torch
+
+ >>> # load model and processor
+ >>> # in this case, we already have performed OCR ourselves
+ >>> # so we initialize the processor with `apply_ocr=False`
+ >>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
+ >>> model = AutoModel.from_pretrained("microsoft/udop-large")
+
+ >>> # load an example image, along with the words and coordinates
+ >>> # which were extracted using an OCR engine
+ >>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
+ >>> example = dataset[0]
+ >>> image = example["image"]
+ >>> words = example["tokens"]
+ >>> boxes = example["bboxes"]
+ >>> inputs = processor(image, words, boxes=boxes, return_tensors="pt")
+
+ >>> decoder_input_ids = torch.tensor([[model.config.decoder_start_token_id]])
+
+ >>> # forward pass
+ >>> outputs = model(**inputs, decoder_input_ids=decoder_input_ids)
+ >>> last_hidden_states = outputs.last_hidden_state
+ >>> list(last_hidden_states.shape)
+ [1, 1, 1024]
+ ```"""
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # Encode if needed (training, first prediction pass)
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ bbox=bbox,
+ pixel_values=pixel_values,
+ visual_bbox=visual_bbox,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = encoder_outputs[0]
+ encoder_attention_mask = encoder_outputs.attention_mask if return_dict else encoder_outputs[1]
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if not return_dict:
+ # we filter out the attention mask
+ decoder_outputs = tuple(value for idx, value in enumerate(decoder_outputs) if idx != 1)
+ encoder_outputs = tuple(value for idx, value in enumerate(encoder_outputs) if idx != 1)
+ return decoder_outputs + encoder_outputs
+
+ return Seq2SeqModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ The UDOP encoder-decoder Transformer with a language modeling head on top, enabling to generate text given document
+ images and an optional prompt.
+
+ This class is based on [`T5ForConditionalGeneration`], extended to deal with images and layout (2D) data.
+ """
+)
+class UdopForConditionalGeneration(UdopPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ "encoder.embed_patches.proj.weight": "patch_embed.proj.weight",
+ "encoder.embed_patches.proj.bias": "patch_embed.proj.bias",
+ "encoder.relative_bias.biases.0.relative_attention_bias.weight": "encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight",
+ "decoder.relative_bias.biases.0.relative_attention_bias.weight": "encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight",
+ "lm_head.weight": "shared.weight",
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+
+ # text and image embeddings
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+ self.patch_embed = UdopPatchEmbeddings(config)
+
+ encoder_config = deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = UdopStack(encoder_config)
+
+ decoder_config = deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = UdopStack(decoder_config)
+
+ # The weights of the language modeling head are shared with those of the encoder and decoder
+ self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: Tensor | None = None,
+ attention_mask: Tensor | None = None,
+ bbox: dict[str, Any] | None = None,
+ pixel_values: Tensor | None = None,
+ visual_bbox: dict[str, Any] | None = None,
+ decoder_input_ids: Tensor | None = None,
+ decoder_attention_mask: Tensor | None = None,
+ inputs_embeds: Tensor | None = None,
+ encoder_outputs: Tensor | None = None,
+ past_key_values: Cache | None = None,
+ decoder_inputs_embeds: Tensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ labels: Tensor | None = None,
+ **kwargs,
+ ) -> tuple | Seq2SeqLMOutput:
+ r"""
+ bbox (`torch.LongTensor` of shape `({0}, 4)`, *optional*):
+ Bounding boxes of each input sequence tokens. Selected in the range `[0,
+ config.max_2d_position_embeddings-1]`. Each bounding box should be a normalized version in (x0, y0, x1, y1)
+ format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1,
+ y1) represents the position of the lower right corner.
+
+ Note that `sequence_length = token_sequence_length + patch_sequence_length + 1` where `1` is for [CLS]
+ token. See `pixel_values` for `patch_sequence_length`.
+ visual_bbox (`torch.LongTensor` of shape `(batch_size, patch_sequence_length, 4)`, *optional*):
+ Bounding boxes of each patch in the image. If not provided, bounding boxes are created in the model.
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary. Indices can be obtained using
+ [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details.
+ [What are decoder input IDs?](../glossary#decoder-input-ids) T5 uses the `pad_token_id` as the starting
+ token for `decoder_input_ids` generation. If `past_key_values` is used, optionally only the last
+ `decoder_input_ids` have to be input (see `past_key_values`). To know more on how to prepare
+ `decoder_input_ids` for pretraining take a look at [T5 Training](./t5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the language modeling loss. Indices should be in `[-100, 0, ..., config.vocab_size -
+ 1]`. All labels set to `-100` are ignored (masked), the loss is only computed for labels in `[0, ...,
+ config.vocab_size]`.
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoProcessor, UdopForConditionalGeneration
+ >>> from datasets import load_dataset
+
+ >>> # load model and processor
+ >>> # in this case, we already have performed OCR ourselves
+ >>> # so we initialize the processor with `apply_ocr=False`
+ >>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
+ >>> model = UdopForConditionalGeneration.from_pretrained("microsoft/udop-large")
+
+ >>> # load an example image, along with the words and coordinates
+ >>> # which were extracted using an OCR engine
+ >>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
+ >>> example = dataset[0]
+ >>> image = example["image"]
+ >>> words = example["tokens"]
+ >>> boxes = example["bboxes"]
+
+ >>> # one can use the various task prefixes (prompts) used during pre-training
+ >>> # e.g. the task prefix for DocVQA is "Question answering. "
+ >>> question = "Question answering. What is the date on the form?"
+ >>> encoding = processor(image, question, text_pair=words, boxes=boxes, return_tensors="pt")
+
+ >>> # autoregressive generation
+ >>> predicted_ids = model.generate(**encoding)
+ >>> print(processor.batch_decode(predicted_ids, skip_special_tokens=True)[0])
+ 9/30/92
+ ```"""
+
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if decoder_input_ids is None and labels is not None:
+ decoder_input_ids = self._shift_right(labels)
+
+ # Encode if needed (training, first prediction pass)
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ bbox=bbox,
+ visual_bbox=visual_bbox,
+ pixel_values=pixel_values,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = encoder_outputs[0]
+ encoder_attention_mask = encoder_outputs.attention_mask if return_dict else encoder_outputs[1]
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=encoder_attention_mask,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = decoder_outputs[0]
+
+ if self.config.tie_word_embeddings:
+ sequence_output = sequence_output * (self.config.d_model**-0.5)
+
+ lm_logits = self.lm_head(sequence_output)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss(ignore_index=-100)
+ loss = loss_fct(lm_logits.view(-1, lm_logits.size(-1)), labels.view(-1))
+
+ if not return_dict:
+ output = (lm_logits,) + decoder_outputs[2:] + (encoder_outputs[0],) + encoder_outputs[2:]
+ return ((loss,) + output) if loss is not None else output
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=lm_logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring
+class UdopEncoderModel(UdopPreTrainedModel):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "encoder.embed_patches.proj.weight": "patch_embed.proj.weight",
+ "encoder.embed_patches.proj.bias": "patch_embed.proj.bias",
+ "encoder.relative_bias.biases.0.relative_attention_bias.weight": "encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight",
+ }
+
+ def __init__(self, config: UdopConfig):
+ super().__init__(config)
+
+ # text and image embeddings
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+ self.patch_embed = UdopPatchEmbeddings(config)
+
+ encoder_config = deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ encoder_config.is_encoder_decoder = False
+ self.encoder = UdopStack(encoder_config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.shared
+
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: Tensor | None = None,
+ bbox: dict[str, Any] | None = None,
+ attention_mask: Tensor | None = None,
+ pixel_values: Tensor | None = None,
+ visual_bbox: dict[str, Any] | None = None,
+ inputs_embeds: Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | BaseModelOutputWithAttentionMask:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. T5 is a model with relative position embeddings so you
+ should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [T5 Training](./t5#training).
+ bbox (`torch.LongTensor` of shape `({0}, 4)`, *optional*):
+ Bounding boxes of each input sequence tokens. Selected in the range `[0,
+ config.max_2d_position_embeddings-1]`. Each bounding box should be a normalized version in (x0, y0, x1, y1)
+ format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1,
+ y1) represents the position of the lower right corner.
+
+ Note that `sequence_length = token_sequence_length + patch_sequence_length + 1` where `1` is for [CLS]
+ token. See `pixel_values` for `patch_sequence_length`.
+ visual_bbox (`torch.LongTensor` of shape `(batch_size, patch_sequence_length, 4)`, *optional*):
+ Bounding boxes of each patch in the image. If not provided, bounding boxes are created in the model.
+
+ Example:
+
+ ```python
+ >>> from transformers import AutoProcessor, UdopEncoderModel
+ >>> from huggingface_hub import hf_hub_download
+ >>> from datasets import load_dataset
+
+ >>> # load model and processor
+ >>> # in this case, we already have performed OCR ourselves
+ >>> # so we initialize the processor with `apply_ocr=False`
+ >>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
+ >>> model = UdopEncoderModel.from_pretrained("microsoft/udop-large")
+
+ >>> # load an example image, along with the words and coordinates
+ >>> # which were extracted using an OCR engine
+ >>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
+ >>> example = dataset[0]
+ >>> image = example["image"]
+ >>> words = example["tokens"]
+ >>> boxes = example["bboxes"]
+ >>> encoding = processor(image, words, boxes=boxes, return_tensors="pt")
+
+ >>> outputs = model(**encoding)
+ >>> last_hidden_states = outputs.last_hidden_state
+ ```"""
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ bbox=bbox,
+ visual_bbox=visual_bbox,
+ pixel_values=pixel_values,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ return encoder_outputs
+
+
+__all__ = ["UdopForConditionalGeneration", "UdopPreTrainedModel", "UdopModel", "UdopEncoderModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/udop/processing_udop.py b/lib/python3.11/site-packages/transformers/models/udop/processing_udop.py
new file mode 100644
index 0000000000000000000000000000000000000000..707b5693a2d56ba7b46887a8ceed6e298eb45f8f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/udop/processing_udop.py
@@ -0,0 +1,168 @@
+# Copyright 2024 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.
+"""
+Processor class for UDOP.
+"""
+
+from transformers import logging
+
+from ...image_processing_utils import BatchFeature
+from ...image_utils import ImageInput
+from ...processing_utils import ProcessingKwargs, ProcessorMixin, TextKwargs, Unpack
+from ...tokenization_utils_base import PreTokenizedInput, TextInput
+from ...utils import auto_docstring
+
+
+logger = logging.get_logger(__name__)
+
+
+class UdopTextKwargs(TextKwargs, total=False):
+ word_labels: list[int] | list[list[int]] | None
+ boxes: list[list[int]] | list[list[list[int]]] | None
+
+
+class UdopProcessorKwargs(ProcessingKwargs, total=False):
+ text_kwargs: UdopTextKwargs
+ _defaults = {
+ "text_kwargs": {
+ "add_special_tokens": True,
+ "padding": False,
+ "truncation": False,
+ "stride": 0,
+ "return_overflowing_tokens": False,
+ "return_special_tokens_mask": False,
+ "return_offsets_mapping": False,
+ "return_length": False,
+ "verbose": True,
+ },
+ }
+
+
+@auto_docstring
+class UdopProcessor(ProcessorMixin):
+ r"""
+ Constructs a UDOP processor which combines a LayoutLMv3 image processor and a UDOP tokenizer into a single processor.
+
+ [`UdopProcessor`] offers all the functionalities you need to prepare data for the model.
+
+ It first uses [`LayoutLMv3ImageProcessor`] to resize, rescale and normalize document images, and optionally applies OCR
+ to get words and normalized bounding boxes. These are then provided to [`UdopTokenizer`],
+ which turns the words and bounding boxes into token-level `input_ids`, `attention_mask`, `token_type_ids`, `bbox`.
+ Optionally, one can provide integer `word_labels`, which are turned into token-level `labels` for token
+ classification tasks (such as FUNSD, CORD).
+
+ Additionally, it also supports passing `text_target` and `text_pair_target` to the tokenizer, which can be used to
+ prepare labels for language modeling tasks.
+ """
+
+ def __init__(self, image_processor, tokenizer):
+ super().__init__(image_processor, tokenizer)
+
+ @auto_docstring
+ def __call__(
+ self,
+ images: ImageInput | None = None,
+ text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] = None,
+ **kwargs: Unpack[UdopProcessorKwargs],
+ ) -> BatchFeature:
+ # verify input
+ output_kwargs = self._merge_kwargs(
+ UdopProcessorKwargs,
+ tokenizer_init_kwargs=self.tokenizer.init_kwargs,
+ **kwargs,
+ )
+
+ boxes = output_kwargs["text_kwargs"].pop("boxes", None)
+ word_labels = output_kwargs["text_kwargs"].pop("word_labels", None)
+ text_pair = output_kwargs["text_kwargs"].pop("text_pair", None)
+ return_overflowing_tokens = output_kwargs["text_kwargs"].get("return_overflowing_tokens", False)
+ return_offsets_mapping = output_kwargs["text_kwargs"].get("return_offsets_mapping", False)
+ text_target = output_kwargs["text_kwargs"].get("text_target", None)
+
+ if self.image_processor.apply_ocr and (boxes is not None):
+ raise ValueError(
+ "You cannot provide bounding boxes if you initialized the image processor with apply_ocr set to True."
+ )
+
+ if self.image_processor.apply_ocr and (word_labels is not None):
+ raise ValueError(
+ "You cannot provide word labels if you initialized the image processor with apply_ocr set to True."
+ )
+
+ if return_overflowing_tokens and not return_offsets_mapping:
+ raise ValueError("You cannot return overflowing tokens without returning the offsets mapping.")
+
+ if text_target is not None:
+ # use the processor to prepare the targets of UDOP
+ return self.tokenizer(
+ **output_kwargs["text_kwargs"],
+ )
+
+ else:
+ # use the processor to prepare the inputs of UDOP
+ # first, apply the image processor
+ features = self.image_processor(images=images, **output_kwargs["images_kwargs"])
+ features_words = features.pop("words", None)
+ features_boxes = features.pop("boxes", None)
+
+ output_kwargs["text_kwargs"].pop("text_target", None)
+ output_kwargs["text_kwargs"].pop("text_pair_target", None)
+ output_kwargs["text_kwargs"]["text_pair"] = text_pair
+ output_kwargs["text_kwargs"]["boxes"] = boxes if boxes is not None else features_boxes
+ output_kwargs["text_kwargs"]["word_labels"] = word_labels
+
+ # second, apply the tokenizer
+ if text is not None and self.image_processor.apply_ocr and text_pair is None:
+ if isinstance(text, str):
+ text = [text] # add batch dimension (as the image processor always adds a batch dimension)
+ output_kwargs["text_kwargs"]["text_pair"] = features_words
+
+ encoded_inputs = self.tokenizer(
+ text=text if text is not None else features_words,
+ **output_kwargs["text_kwargs"],
+ )
+
+ # add pixel values
+ if return_overflowing_tokens is True:
+ features["pixel_values"] = self.get_overflowing_images(
+ features["pixel_values"], encoded_inputs["overflow_to_sample_mapping"]
+ )
+ features.update(encoded_inputs)
+
+ return features
+
+ # Copied from transformers.models.layoutlmv3.processing_layoutlmv3.LayoutLMv3Processor.get_overflowing_images
+ def get_overflowing_images(self, images, overflow_to_sample_mapping):
+ # in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image
+ images_with_overflow = []
+ for sample_idx in overflow_to_sample_mapping:
+ images_with_overflow.append(images[sample_idx])
+
+ if len(images_with_overflow) != len(overflow_to_sample_mapping):
+ raise ValueError(
+ "Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got"
+ f" {len(images_with_overflow)} and {len(overflow_to_sample_mapping)}"
+ )
+
+ return images_with_overflow
+
+ @property
+ def model_input_names(self):
+ tokenizer_input_names = self.tokenizer.model_input_names
+ image_processor_input_names = self.image_processor.model_input_names
+
+ return list(tokenizer_input_names + image_processor_input_names + ["bbox"])
+
+
+__all__ = ["UdopProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/udop/tokenization_udop.py b/lib/python3.11/site-packages/transformers/models/udop/tokenization_udop.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf49ebfd7e552b646a789bcc74754269747cbd02
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/udop/tokenization_udop.py
@@ -0,0 +1,1031 @@
+# Copyright 2024 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
+"""Tokenization classes for UDOP model."""
+
+from tokenizers import Tokenizer, decoders, pre_tokenizers, processors
+from tokenizers.models import Unigram
+
+from ...tokenization_utils_base import (
+ BatchEncoding,
+ EncodedInput,
+ PreTokenizedInput,
+ TextInput,
+ TextInputPair,
+ TruncationStrategy,
+)
+from ...tokenization_utils_tokenizers import TokenizersBackend
+from ...utils import PaddingStrategy, TensorType, add_end_docstrings, logging
+
+
+VOCAB_FILES_NAMES = {"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"}
+
+
+logger = logging.get_logger(__name__)
+
+UDOP_ENCODE_KWARGS_DOCSTRING = r"""
+ add_special_tokens (`bool`, *optional*, defaults to `True`):
+ Whether or not to encode the sequences with the special tokens relative to their model.
+ padding (`bool`, `str` or [`~file_utils.PaddingStrategy`], *optional*, defaults to `False`):
+ Activates and controls padding. Accepts the following values:
+
+ - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+ sequence if provided).
+ - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
+ acceptable input length for the model if that argument is not provided.
+ - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
+ lengths).
+ truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):
+ Activates and controls truncation. Accepts the following values:
+
+ - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or
+ to the maximum acceptable input length for the model if that argument is not provided. This will
+ truncate token by token, removing a token from the longest sequence in the pair if a pair of
+ sequences (or a batch of pairs) is provided.
+ - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the
+ maximum acceptable input length for the model if that argument is not provided. This will only
+ truncate the first sequence of a pair if a pair of sequences (or a batch of pairs) is provided.
+ - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the
+ maximum acceptable input length for the model if that argument is not provided. This will only
+ truncate the second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.
+ - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths
+ greater than the model maximum admissible input size).
+ max_length (`int`, *optional*):
+ Controls the maximum length to use by one of the truncation/padding parameters.
+
+ If left unset or set to `None`, this will use the predefined model maximum length if a maximum length
+ is required by one of the truncation/padding parameters. If the model has no specific maximum input
+ length (like XLNet) truncation/padding to a maximum length will be deactivated.
+ stride (`int`, *optional*, defaults to 0):
+ If set to a number along with `max_length`, the overflowing tokens returned when
+ `return_overflowing_tokens=True` will contain some tokens from the end of the truncated sequence
+ returned to provide some overlap between truncated and overflowing sequences. The value of this
+ argument defines the number of overlapping tokens.
+ pad_to_multiple_of (`int`, *optional*):
+ If set will pad the sequence to a multiple of the provided value. This is especially useful to enable
+ the use of Tensor Cores on NVIDIA hardware with compute capability `>= 7.5` (Volta).
+ return_tensors (`str` or [`~file_utils.TensorType`], *optional*):
+ If set, will return tensors instead of list of python integers. Acceptable values are:
+
+ - `'pt'`: Return PyTorch `torch.Tensor` objects.
+ - `'np'`: Return Numpy `np.ndarray` objects.
+ return_token_type_ids (`bool`, *optional*):
+ Whether to return token type IDs. If left to the default, will return the token type IDs according to
+ the specific tokenizer's default, defined by the `return_outputs` attribute.
+
+ [What are token type IDs?](../glossary#token-type-ids)
+ return_attention_mask (`bool`, *optional*):
+ Whether to return the attention mask. If left to the default, will return the attention mask according
+ to the specific tokenizer's default, defined by the `return_outputs` attribute.
+
+ [What are attention masks?](../glossary#attention-mask)
+ return_overflowing_tokens (`bool`, *optional*, defaults to `False`):
+ Whether or not to return overflowing token sequences. If a pair of sequences of input ids (or a batch
+ of pairs) is provided with `truncation_strategy = longest_first` or `True`, an error is raised instead
+ of returning overflowing tokens.
+ return_special_tokens_mask (`bool`, *optional*, defaults to `False`):
+ Whether or not to return special tokens mask information.
+ return_offsets_mapping (`bool`, *optional*, defaults to `False`):
+ Whether or not to return `(char_start, char_end)` for each token.
+
+ This is only available on fast tokenizers inheriting from [`PreTrainedTokenizerFast`], if using
+ Python's tokenizer, this method will raise `NotImplementedError`.
+ return_length (`bool`, *optional*, defaults to `False`):
+ Whether or not to return the lengths of the encoded inputs.
+ verbose (`bool`, *optional*, defaults to `True`):
+ Whether or not to print more information and warnings.
+ **kwargs: passed to the `self.tokenize()` method
+
+ Return:
+ [`BatchEncoding`]: A [`BatchEncoding`] with the following fields:
+
+ - **input_ids** -- List of token ids to be fed to a model.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ - **bbox** -- List of bounding boxes to be fed to a model.
+
+ - **token_type_ids** -- List of token type ids to be fed to a model (when `return_token_type_ids=True` or
+ if *"token_type_ids"* is in `self.model_input_names`).
+
+ [What are token type IDs?](../glossary#token-type-ids)
+
+ - **attention_mask** -- List of indices specifying which tokens should be attended to by the model (when
+ `return_attention_mask=True` or if *"attention_mask"* is in `self.model_input_names`).
+
+ [What are attention masks?](../glossary#attention-mask)
+
+ - **labels** -- List of labels to be fed to a model. (when `word_labels` is specified).
+ - **overflowing_tokens** -- List of overflowing tokens sequences (when a `max_length` is specified and
+ `return_overflowing_tokens=True`).
+ - **num_truncated_tokens** -- Number of tokens truncated (when a `max_length` is specified and
+ `return_overflowing_tokens=True`).
+ - **special_tokens_mask** -- List of 0s and 1s, with 1 specifying added special tokens and 0 specifying
+ regular sequence tokens (when `add_special_tokens=True` and `return_special_tokens_mask=True`).
+ - **length** -- The length of the inputs (when `return_length=True`).
+"""
+
+
+class UdopTokenizer(TokenizersBackend):
+ """
+ Construct a "fast" UDOP tokenizer (backed by HuggingFace's *tokenizers* library). Adapted from
+ [`LayoutXLMTokenizer`] and [`T5Tokenizer`]. Based on
+ [BPE](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=BPE#models).
+
+ This tokenizer inherits from [`TokenizersBackend`] which contains most of the main methods. Users should
+ refer to this superclass for more information regarding those methods.
+
+ Args:
+ eos_token (`str`, *optional*, defaults to `"</s>"`):
+ The end of sequence token.
+
+ <Tip>
+
+ When building a sequence using special tokens, this is not the token that is used for the end of sequence.
+ The token used is the `sep_token`.
+
+ </Tip>
+
+ sep_token (`str`, *optional*, defaults to `"</s>"`):
+ The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for
+ sequence classification or for a text and a question for question answering. It is also used as the last
+ token of a sequence built with special tokens.
+ unk_token (`str`, *optional*, defaults to `"<unk>"`):
+ The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
+ token instead.
+ pad_token (`str`, *optional*, defaults to `"<pad>"`):
+ The token used for padding, for example when batching sequences of different lengths.
+ sep_token_box (`list[int]`, *optional*, defaults to `[1000, 1000, 1000, 1000]`):
+ The bounding box to use for the special [SEP] token.
+ pad_token_box (`list[int]`, *optional*, defaults to `[0, 0, 0, 0]`):
+ The bounding box to use for the special [PAD] token.
+ pad_token_label (`int`, *optional*, defaults to -100):
+ The label to use for padding tokens. Defaults to -100, which is the `ignore_index` of PyTorch's
+ CrossEntropyLoss.
+ only_label_first_subword (`bool`, *optional*, defaults to `True`):
+ Whether or not to only label the first subword, in case word labels are provided.
+ extra_special_tokens (`list[str]`, *optional*, defaults to `["<s>NOTUSED", "</s>NOTUSED"]`):
+ Extra special tokens used by the tokenizer.
+ """
+
+ vocab_files_names = VOCAB_FILES_NAMES
+ model_input_names = ["input_ids", "attention_mask"]
+ model = Unigram
+
+ def __init__(
+ self,
+ vocab: str | list[tuple[str, float]] | None = None,
+ eos_token="</s>",
+ sep_token="</s>",
+ unk_token="<unk>",
+ pad_token="<pad>",
+ sep_token_box=[1000, 1000, 1000, 1000],
+ pad_token_box=[0, 0, 0, 0],
+ pad_token_label=-100,
+ only_label_first_subword=True,
+ extra_special_tokens=None,
+ **kwargs,
+ ):
+ if "additional_special_tokens" in kwargs and "extra_special_tokens" not in kwargs:
+ kwargs["extra_special_tokens"] = kwargs.pop("additional_special_tokens")
+ if extra_special_tokens is not None:
+ kwargs["extra_special_tokens"] = extra_special_tokens
+
+ if vocab is None:
+ vocab = [(str(pad_token), 0.0), (str(eos_token), 0.0), (str(unk_token), 0.0), ("▁", -2.0)]
+
+ unk_id = 2
+ for idx, (token, _) in enumerate(vocab):
+ if token == str(unk_token):
+ unk_id = idx
+ break
+
+ self._tokenizer = Tokenizer(
+ Unigram(
+ vocab,
+ unk_id=unk_id,
+ byte_fallback=False,
+ )
+ )
+
+ self._tokenizer.normalizer = None
+
+ self._tokenizer.pre_tokenizer = pre_tokenizers.Sequence(
+ [
+ pre_tokenizers.WhitespaceSplit(),
+ pre_tokenizers.Metaspace(replacement="▁", prepend_scheme="always", split=True),
+ ]
+ )
+
+ self._tokenizer.decoder = decoders.Metaspace(replacement="▁", prepend_scheme="always", split=True)
+
+ super().__init__(
+ eos_token=eos_token,
+ sep_token=sep_token,
+ unk_token=unk_token,
+ pad_token=pad_token,
+ sep_token_box=sep_token_box,
+ pad_token_box=pad_token_box,
+ pad_token_label=pad_token_label,
+ only_label_first_subword=only_label_first_subword,
+ **kwargs,
+ )
+
+ self._tokenizer.post_processor = processors.TemplateProcessing(
+ single=["$A", "</s>"],
+ pair=["$A", "</s>", "$B", "</s>"],
+ special_tokens=[
+ ("</s>", self.eos_token_id),
+ ],
+ )
+
+ self.sep_token_box = sep_token_box
+ self.pad_token_box = pad_token_box
+ self.pad_token_label = pad_token_label
+ self.only_label_first_subword = only_label_first_subword
+ self.init_kwargs["vocab"] = vocab
+
+ self._tokenizer.encode_special_tokens = self.split_special_tokens
+
+ @add_end_docstrings(UDOP_ENCODE_KWARGS_DOCSTRING)
+ def __call__(
+ self,
+ text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] = None,
+ text_pair: PreTokenizedInput | list[PreTokenizedInput] | None = None,
+ boxes: list[list[int]] | list[list[list[int]]] | None = None,
+ word_labels: list[int] | list[list[int]] | None = None,
+ text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] = None,
+ text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None,
+ **kwargs,
+ ) -> BatchEncoding:
+ if text is None and text_target is None:
+ raise ValueError("You need to specify either `text` or `text_target`.")
+ if text is not None:
+ # The context manager will send the inputs as normal texts and not text_target, but we shouldn't change the
+ # input mode in this case.
+ if not self._in_target_context_manager and hasattr(self, "_switch_to_input_mode"):
+ self._switch_to_input_mode()
+ encodings = self.call_boxes(text=text, text_pair=text_pair, boxes=boxes, word_labels=word_labels, **kwargs)
+ if text_target is not None:
+ if hasattr(self, "_switch_to_target_mode"):
+ self._switch_to_target_mode()
+ target_encodings = self._encode_plus(
+ text=text_target,
+ text_pair=text_pair_target,
+ **kwargs,
+ )
+ # Leave back tokenizer in input mode
+ if hasattr(self, "_switch_to_input_mode"):
+ self._switch_to_input_mode()
+
+ if text_target is None:
+ return encodings
+ elif text is None:
+ return target_encodings
+ else:
+ encodings["labels"] = target_encodings["input_ids"]
+ return encodings
+
+ @add_end_docstrings(UDOP_ENCODE_KWARGS_DOCSTRING)
+ def call_boxes(
+ self,
+ text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput],
+ text_pair: PreTokenizedInput | list[PreTokenizedInput] | None = None,
+ boxes: list[list[int]] | list[list[list[int]]] | None = None,
+ word_labels: list[int] | list[list[int]] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TruncationStrategy = None,
+ max_length: int | None = None,
+ stride: int = 0,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = None,
+ return_attention_mask: bool | None = None,
+ return_overflowing_tokens: bool = False,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ) -> BatchEncoding:
+ """
+ Main method to tokenize and prepare for the model one or several sequence(s) or one or several pair(s) of
+ sequences with word-level normalized bounding boxes and optional labels.
+
+ Args:
+ text (`str`, `list[str]`, `list[list[str]]`):
+ The sequence or batch of sequences to be encoded. Each sequence can be a string, a list of strings
+ (words of a single example or questions of a batch of examples) or a list of list of strings (batch of
+ words).
+ text_pair (`list[str]`, `list[list[str]]`):
+ The sequence or batch of sequences to be encoded. Each sequence should be a list of strings
+ (pretokenized string).
+ boxes (`list[list[int]]`, `list[list[list[int]]]`):
+ Word-level bounding boxes. Each bounding box should be normalized to be on a 0-1000 scale.
+ word_labels (`list[int]`, `list[list[int]]`, *optional*):
+ Word-level integer labels (for token classification tasks such as FUNSD, CORD).
+ """
+
+ # Input type checking for clearer error
+ def _is_valid_text_input(t):
+ if isinstance(t, str):
+ # Strings are fine
+ return True
+ elif isinstance(t, (list, tuple)):
+ # List are fine as long as they are...
+ if len(t) == 0:
+ # ... empty
+ return True
+ elif isinstance(t[0], str):
+ # ... list of strings
+ return True
+ elif isinstance(t[0], (list, tuple)):
+ # ... list with an empty list or with a list of strings
+ return len(t[0]) == 0 or isinstance(t[0][0], str)
+ else:
+ return False
+ else:
+ return False
+
+ if text_pair is not None:
+ # in case text + text_pair are provided, text = questions, text_pair = words
+ if not _is_valid_text_input(text):
+ raise ValueError("text input must of type `str` (single example) or `list[str]` (batch of examples). ")
+ if not isinstance(text_pair, (list, tuple)):
+ raise ValueError(
+ "words must of type `list[str]` (single pretokenized example), "
+ "or `list[list[str]]` (batch of pretokenized examples)."
+ )
+ else:
+ # in case only text is provided => must be words
+ if not isinstance(text, (list, tuple)):
+ raise ValueError(
+ "Words must of type `list[str]` (single pretokenized example), "
+ "or `list[list[str]]` (batch of pretokenized examples)."
+ )
+
+ if text_pair is not None:
+ is_batched = isinstance(text, (list, tuple))
+ else:
+ is_batched = isinstance(text, (list, tuple)) and text and isinstance(text[0], (list, tuple))
+
+ words = text if text_pair is None else text_pair
+ if boxes is None:
+ raise ValueError("You must provide corresponding bounding boxes")
+ if is_batched:
+ if len(words) != len(boxes):
+ raise ValueError("You must provide words and boxes for an equal amount of examples")
+ for words_example, boxes_example in zip(words, boxes):
+ if len(words_example) != len(boxes_example):
+ raise ValueError("You must provide as many words as there are bounding boxes")
+ else:
+ if len(words) != len(boxes):
+ raise ValueError("You must provide as many words as there are bounding boxes")
+
+ if is_batched:
+ if text_pair is not None and len(text) != len(text_pair):
+ raise ValueError(
+ f"batch length of `text`: {len(text)} does not match batch length of `text_pair`:"
+ f" {len(text_pair)}."
+ )
+ batch_text_or_text_pairs = list(zip(text, text_pair)) if text_pair is not None else text
+ is_pair = bool(text_pair is not None)
+ return self.batch_encode_plus_boxes(
+ batch_text_or_text_pairs=batch_text_or_text_pairs,
+ is_pair=is_pair,
+ boxes=boxes,
+ word_labels=word_labels,
+ add_special_tokens=add_special_tokens,
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ stride=stride,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=return_offsets_mapping,
+ return_length=return_length,
+ verbose=verbose,
+ **kwargs,
+ )
+ else:
+ return self.encode_plus_boxes(
+ text=text,
+ text_pair=text_pair,
+ boxes=boxes,
+ word_labels=word_labels,
+ add_special_tokens=add_special_tokens,
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ stride=stride,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=return_offsets_mapping,
+ return_length=return_length,
+ verbose=verbose,
+ **kwargs,
+ )
+
+ def tokenize(self, text: str, pair: str | None = None, add_special_tokens: bool = False, **kwargs) -> list[str]:
+ batched_input = [(text, pair)] if pair else [text]
+
+ self._tokenizer.encode_special_tokens = kwargs.pop("split_special_tokens", self.split_special_tokens)
+
+ encodings = self._tokenizer.encode_batch(
+ batched_input, add_special_tokens=add_special_tokens, is_pretokenized=False, **kwargs
+ )
+
+ return encodings[0].tokens
+
+ def batch_encode_plus_boxes(
+ self,
+ batch_text_or_text_pairs: list[TextInput] | list[TextInputPair] | list[PreTokenizedInput],
+ is_pair: bool | None = None,
+ boxes: list[list[list[int]]] | None = None,
+ word_labels: list[list[int]] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TruncationStrategy = None,
+ max_length: int | None = None,
+ stride: int = 0,
+ is_split_into_words: bool = False,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = None,
+ return_attention_mask: bool | None = None,
+ return_overflowing_tokens: bool = False,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ) -> BatchEncoding:
+ """
+ Tokenize and prepare for the model a list of sequences or a list of pairs of sequences.
+
+ <Tip warning={true}>
+
+ This method is deprecated, `__call__` should be used instead.
+
+ </Tip>
+
+ Args:
+ batch_text_or_text_pairs (`list[str]`, `list[tuple[str, str]]`, `list[list[str]]`, `list[tuple[list[str], list[str]]]`, and for not-fast tokenizers, also `list[list[int]]`, `list[tuple[list[int], list[int]]]`):
+ Batch of sequences or pair of sequences to be encoded. This can be a list of
+ string/string-sequences/int-sequences or a list of pair of string/string-sequences/int-sequence (see
+ details in `encode_plus`).
+ """
+
+ # Backward compatibility for 'truncation_strategy', 'pad_to_max_length'
+ padding_strategy, truncation_strategy, max_length, kwargs = self._get_padding_truncation_strategies(
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ pad_to_multiple_of=pad_to_multiple_of,
+ verbose=verbose,
+ **kwargs,
+ )
+
+ return self._batch_encode_plus_boxes(
+ batch_text_or_text_pairs=batch_text_or_text_pairs,
+ is_pair=is_pair,
+ boxes=boxes,
+ word_labels=word_labels,
+ add_special_tokens=add_special_tokens,
+ padding_strategy=padding_strategy,
+ truncation_strategy=truncation_strategy,
+ max_length=max_length,
+ stride=stride,
+ is_split_into_words=is_split_into_words,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=return_offsets_mapping,
+ return_length=return_length,
+ verbose=verbose,
+ **kwargs,
+ )
+
+ def _batch_encode_plus_boxes(
+ self,
+ batch_text_or_text_pairs: list[TextInput] | list[TextInputPair] | list[PreTokenizedInput],
+ is_pair: bool | None = None,
+ boxes: list[list[list[int]]] | None = None,
+ word_labels: list[list[int]] | None = None,
+ add_special_tokens: bool = True,
+ padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,
+ truncation_strategy: TruncationStrategy = TruncationStrategy.DO_NOT_TRUNCATE,
+ max_length: int | None = None,
+ stride: int = 0,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | None = None,
+ return_token_type_ids: bool | None = None,
+ return_attention_mask: bool | None = None,
+ return_overflowing_tokens: bool = False,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ) -> BatchEncoding:
+ if not isinstance(batch_text_or_text_pairs, list):
+ raise TypeError(f"batch_text_or_text_pairs has to be a list (got {type(batch_text_or_text_pairs)})")
+
+ # Set the truncation and padding strategy and restore the initial configuration
+ self.set_truncation_and_padding(
+ padding_strategy=padding_strategy,
+ truncation_strategy=truncation_strategy,
+ max_length=max_length,
+ stride=stride,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ )
+
+ if is_pair:
+ batch_text_or_text_pairs = [(text.split(), text_pair) for text, text_pair in batch_text_or_text_pairs]
+
+ encodings = self._tokenizer.encode_batch(
+ batch_text_or_text_pairs,
+ add_special_tokens=add_special_tokens,
+ is_pretokenized=True, # we set this to True as LayoutLMv2 always expects pretokenized inputs
+ )
+
+ # Convert encoding to dict
+ # `Tokens` has type: tuple[
+ # list[dict[str, list[list[int]]]] or list[dict[str, 2D-Tensor]],
+ # list[EncodingFast]
+ # ]
+ # with nested dimensions corresponding to batch, overflows, sequence length
+ tokens_and_encodings = [
+ self._convert_encoding(
+ encoding=encoding,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=True
+ if word_labels is not None
+ else return_offsets_mapping, # we use offsets to create the labels
+ return_length=return_length,
+ verbose=verbose,
+ )
+ for encoding in encodings
+ ]
+
+ # Convert the output to have dict[list] from list[dict] and remove the additional overflows dimension
+ # From (variable) shape (batch, overflows, sequence length) to ~ (batch * overflows, sequence length)
+ # (we say ~ because the number of overflow varies with the example in the batch)
+ #
+ # To match each overflowing sample with the original sample in the batch
+ # we add an overflow_to_sample_mapping array (see below)
+ sanitized_tokens = {}
+ for key in tokens_and_encodings[0][0]:
+ stack = [e for item, _ in tokens_and_encodings for e in item[key]]
+ sanitized_tokens[key] = stack
+ sanitized_encodings = [e for _, item in tokens_and_encodings for e in item]
+
+ # If returning overflowing tokens, we need to return a mapping
+ # from the batch idx to the original sample
+ if return_overflowing_tokens:
+ overflow_to_sample_mapping = []
+ for i, (toks, _) in enumerate(tokens_and_encodings):
+ overflow_to_sample_mapping += [i] * len(toks["input_ids"])
+ sanitized_tokens["overflow_to_sample_mapping"] = overflow_to_sample_mapping
+
+ for input_ids in sanitized_tokens["input_ids"]:
+ self._eventual_warn_about_too_long_sequence(input_ids, max_length, verbose)
+
+ # create the token boxes
+ token_boxes = []
+ for batch_index in range(len(sanitized_tokens["input_ids"])):
+ if return_overflowing_tokens:
+ original_index = sanitized_tokens["overflow_to_sample_mapping"][batch_index]
+ else:
+ original_index = batch_index
+ token_boxes_example = []
+ for id, sequence_id, word_id in zip(
+ sanitized_tokens["input_ids"][batch_index],
+ sanitized_encodings[batch_index].sequence_ids,
+ sanitized_encodings[batch_index].word_ids,
+ ):
+ if word_id is not None:
+ if is_pair and sequence_id == 0:
+ token_boxes_example.append(self.pad_token_box)
+ else:
+ token_boxes_example.append(boxes[original_index][word_id])
+ else:
+ if id == self.sep_token_id:
+ token_boxes_example.append(self.sep_token_box)
+ elif id == self.pad_token_id:
+ token_boxes_example.append(self.pad_token_box)
+ else:
+ raise ValueError("Id not recognized")
+ token_boxes.append(token_boxes_example)
+
+ sanitized_tokens["bbox"] = token_boxes
+
+ # optionally, create the labels
+ if word_labels is not None:
+ labels = []
+ for batch_index in range(len(sanitized_tokens["input_ids"])):
+ if return_overflowing_tokens:
+ original_index = sanitized_tokens["overflow_to_sample_mapping"][batch_index]
+ else:
+ original_index = batch_index
+ labels_example = []
+ previous_token_empty = False
+ for id, offset, word_id in zip(
+ sanitized_tokens["input_ids"][batch_index],
+ sanitized_tokens["offset_mapping"][batch_index],
+ sanitized_encodings[batch_index].word_ids,
+ ):
+ if word_id is not None:
+ if self.only_label_first_subword:
+ if offset[0] == 0 and not previous_token_empty:
+ # Use the real label id for the first token of the word, and padding ids for the remaining tokens
+ labels_example.append(word_labels[original_index][word_id])
+ else:
+ labels_example.append(self.pad_token_label)
+ else:
+ labels_example.append(word_labels[original_index][word_id])
+ if self.decode(id) == "":
+ previous_token_empty = True
+ else:
+ previous_token_empty = False
+ else:
+ labels_example.append(self.pad_token_label)
+ labels.append(labels_example)
+
+ sanitized_tokens["labels"] = labels
+ # finally, remove offsets if the user didn't want them
+ if not return_offsets_mapping:
+ del sanitized_tokens["offset_mapping"]
+
+ return BatchEncoding(sanitized_tokens, sanitized_encodings, tensor_type=return_tensors)
+
+ def _encode_plus_boxes(
+ self,
+ text: TextInput | PreTokenizedInput,
+ text_pair: PreTokenizedInput | None = None,
+ boxes: list[list[int]] | None = None,
+ word_labels: list[int] | None = None,
+ add_special_tokens: bool = True,
+ padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,
+ truncation_strategy: TruncationStrategy = TruncationStrategy.DO_NOT_TRUNCATE,
+ max_length: int | None = None,
+ stride: int = 0,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: bool | None = None,
+ return_token_type_ids: bool | None = None,
+ return_attention_mask: bool | None = None,
+ return_overflowing_tokens: bool = False,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ) -> BatchEncoding:
+ # make it a batched input
+ # 2 options:
+ # 1) only text, in case text must be a list of str
+ # 2) text + text_pair, in which case text = str and text_pair a list of str
+ batched_input = [(text, text_pair)] if text_pair else [text]
+ batched_boxes = [boxes]
+ batched_word_labels = [word_labels] if word_labels is not None else None
+ batched_output = self._batch_encode_plus_boxes(
+ batched_input,
+ is_pair=bool(text_pair is not None),
+ boxes=batched_boxes,
+ word_labels=batched_word_labels,
+ add_special_tokens=add_special_tokens,
+ padding_strategy=padding_strategy,
+ truncation_strategy=truncation_strategy,
+ max_length=max_length,
+ stride=stride,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=return_offsets_mapping,
+ return_length=return_length,
+ verbose=verbose,
+ **kwargs,
+ )
+
+ # Return tensor is None, then we can remove the leading batch axis
+ # Overflowing tokens are returned as a batch of output so we keep them in this case
+ if return_tensors is None and not return_overflowing_tokens:
+ batched_output = BatchEncoding(
+ {
+ key: value[0] if len(value) > 0 and isinstance(value[0], list) else value
+ for key, value in batched_output.items()
+ },
+ batched_output.encodings,
+ )
+
+ self._eventual_warn_about_too_long_sequence(batched_output["input_ids"], max_length, verbose)
+
+ return batched_output
+
+ def encode_boxes(
+ self,
+ text: TextInput | PreTokenizedInput | EncodedInput,
+ text_pair: TextInput | PreTokenizedInput | EncodedInput | None = None,
+ boxes: list[list[int]] | None = None,
+ word_labels: list[list[int]] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TruncationStrategy = None,
+ max_length: int | None = None,
+ stride: int = 0,
+ return_tensors: str | TensorType | None = None,
+ **kwargs,
+ ) -> list[int]:
+ """
+ Args:
+ Converts a string to a sequence of ids (integer), using the tokenizer and vocabulary. Same as doing
+ `self.convert_tokens_to_ids(self.tokenize(text))`.
+ text (`str`, `list[str]` or `list[int]`):
+ The first sequence to be encoded. This can be a string, a list of strings (tokenized string using the
+ `tokenize` method) or a list of integers (tokenized string ids using the `convert_tokens_to_ids`
+ method).
+ text_pair (`str`, `list[str]` or `list[int]`, *optional*):
+ Optional second sequence to be encoded. This can be a string, a list of strings (tokenized string using
+ the `tokenize` method) or a list of integers (tokenized string ids using the `convert_tokens_to_ids`
+ method).
+ """
+ encoded_inputs = self.encode_plus_boxes(
+ text,
+ text_pair=text_pair,
+ boxes=boxes,
+ word_labels=word_labels,
+ add_special_tokens=add_special_tokens,
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ stride=stride,
+ return_tensors=return_tensors,
+ **kwargs,
+ )
+
+ return encoded_inputs["input_ids"]
+
+ def encode_plus_boxes(
+ self,
+ text: TextInput | PreTokenizedInput,
+ text_pair: PreTokenizedInput | None = None,
+ boxes: list[list[int]] | None = None,
+ word_labels: list[list[int]] | None = None,
+ add_special_tokens: bool = True,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TruncationStrategy = None,
+ max_length: int | None = None,
+ stride: int = 0,
+ is_split_into_words: bool = False,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_tensors: str | TensorType | None = None,
+ return_token_type_ids: bool | None = None,
+ return_attention_mask: bool | None = None,
+ return_overflowing_tokens: bool = False,
+ return_special_tokens_mask: bool = False,
+ return_offsets_mapping: bool = False,
+ return_length: bool = False,
+ verbose: bool = True,
+ **kwargs,
+ ) -> BatchEncoding:
+ """
+ Tokenize and prepare for the model a sequence or a pair of sequences.
+
+ <Tip warning={true}>
+
+ This method is deprecated, `__call__` should be used instead.
+
+ </Tip>
+
+ Args:
+ text (`str`, `list[str]` or (for non-fast tokenizers) `list[int]`):
+ The first sequence to be encoded. This can be a string, a list of strings (tokenized string using the
+ `tokenize` method) or a list of integers (tokenized string ids using the `convert_tokens_to_ids`
+ method).
+ text_pair (`str`, `list[str]` or `list[int]`, *optional*):
+ Optional second sequence to be encoded. This can be a string, a list of strings (tokenized string using
+ the `tokenize` method) or a list of integers (tokenized string ids using the `convert_tokens_to_ids`
+ method).
+ """
+
+ # Backward compatibility for 'truncation_strategy', 'pad_to_max_length'
+ padding_strategy, truncation_strategy, max_length, kwargs = self._get_padding_truncation_strategies(
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ pad_to_multiple_of=pad_to_multiple_of,
+ verbose=verbose,
+ **kwargs,
+ )
+
+ return self._encode_plus_boxes(
+ text=text,
+ text_pair=text_pair,
+ boxes=boxes,
+ word_labels=word_labels,
+ add_special_tokens=add_special_tokens,
+ padding_strategy=padding_strategy,
+ truncation_strategy=truncation_strategy,
+ max_length=max_length,
+ stride=stride,
+ is_split_into_words=is_split_into_words,
+ pad_to_multiple_of=pad_to_multiple_of,
+ padding_side=padding_side,
+ return_tensors=return_tensors,
+ return_token_type_ids=return_token_type_ids,
+ return_attention_mask=return_attention_mask,
+ return_overflowing_tokens=return_overflowing_tokens,
+ return_special_tokens_mask=return_special_tokens_mask,
+ return_offsets_mapping=return_offsets_mapping,
+ return_length=return_length,
+ verbose=verbose,
+ **kwargs,
+ )
+
+ def _pad(
+ self,
+ encoded_inputs: dict[str, EncodedInput] | BatchEncoding,
+ max_length: int | None = None,
+ padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,
+ pad_to_multiple_of: int | None = None,
+ padding_side: str | None = None,
+ return_attention_mask: bool | None = None,
+ ) -> dict:
+ """
+ Pad encoded inputs (on left/right and up to predefined length or max length in the batch)
+
+ Args:
+ encoded_inputs:
+ Dictionary of tokenized inputs (`list[int]`) or batch of tokenized inputs (`list[list[int]]`).
+ max_length: maximum length of the returned list and optionally padding length (see below).
+ Will truncate by taking into account the special tokens.
+ padding_strategy: PaddingStrategy to use for padding.
+
+ - PaddingStrategy.LONGEST Pad to the longest sequence in the batch
+ - PaddingStrategy.MAX_LENGTH: Pad to the max length (default)
+ - PaddingStrategy.DO_NOT_PAD: Do not pad
+ The tokenizer padding sides are defined in self.padding_side:
+
+ - 'left': pads on the left of the sequences
+ - 'right': pads on the right of the sequences
+ pad_to_multiple_of: (optional) Integer if set will pad the sequence to a multiple of the provided value.
+ This is especially useful to enable the use of Tensor Core on NVIDIA hardware with compute capability
+ `>= 7.5` (Volta).
+ padding_side (`str`, *optional*):
+ The side on which the model should have padding applied. Should be selected between ['right', 'left'].
+ Default value is picked from the class attribute of the same name.
+ return_attention_mask:
+ (optional) Set to False to avoid returning attention mask (default: set to model specifics)
+ """
+ # Load from model defaults
+ if return_attention_mask is None:
+ return_attention_mask = "attention_mask" in self.model_input_names
+
+ required_input = encoded_inputs[self.model_input_names[0]]
+
+ if padding_strategy == PaddingStrategy.LONGEST:
+ max_length = len(required_input)
+
+ if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
+ max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of
+
+ needs_to_be_padded = padding_strategy != PaddingStrategy.DO_NOT_PAD and len(required_input) != max_length
+
+ # Initialize attention mask if not present.
+ if return_attention_mask and "attention_mask" not in encoded_inputs:
+ encoded_inputs["attention_mask"] = [1] * len(required_input)
+
+ if needs_to_be_padded:
+ difference = max_length - len(required_input)
+ padding_side = padding_side if padding_side is not None else self.padding_side
+ if padding_side == "right":
+ if return_attention_mask:
+ encoded_inputs["attention_mask"] = encoded_inputs["attention_mask"] + [0] * difference
+ if "token_type_ids" in encoded_inputs:
+ encoded_inputs["token_type_ids"] = (
+ encoded_inputs["token_type_ids"] + [self.pad_token_type_id] * difference
+ )
+ if "bbox" in encoded_inputs:
+ encoded_inputs["bbox"] = encoded_inputs["bbox"] + [self.pad_token_box] * difference
+ if "labels" in encoded_inputs:
+ encoded_inputs["labels"] = encoded_inputs["labels"] + [self.pad_token_label] * difference
+ if "special_tokens_mask" in encoded_inputs:
+ encoded_inputs["special_tokens_mask"] = encoded_inputs["special_tokens_mask"] + [1] * difference
+ encoded_inputs[self.model_input_names[0]] = required_input + [self.pad_token_id] * difference
+ elif padding_side == "left":
+ if return_attention_mask:
+ encoded_inputs["attention_mask"] = [0] * difference + encoded_inputs["attention_mask"]
+ if "token_type_ids" in encoded_inputs:
+ encoded_inputs["token_type_ids"] = [self.pad_token_type_id] * difference + encoded_inputs[
+ "token_type_ids"
+ ]
+ if "bbox" in encoded_inputs:
+ encoded_inputs["bbox"] = [self.pad_token_box] * difference + encoded_inputs["bbox"]
+ if "labels" in encoded_inputs:
+ encoded_inputs["labels"] = [self.pad_token_label] * difference + encoded_inputs["labels"]
+ if "special_tokens_mask" in encoded_inputs:
+ encoded_inputs["special_tokens_mask"] = [1] * difference + encoded_inputs["special_tokens_mask"]
+ encoded_inputs[self.model_input_names[0]] = [self.pad_token_id] * difference + required_input
+ else:
+ raise ValueError("Invalid padding strategy:" + str(padding_side))
+
+ return encoded_inputs
+
+ def build_inputs_with_special_tokens(
+ self, token_ids_0: list[int], token_ids_1: list[int] | None = None
+ ) -> list[int]:
+ """
+ Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
+ adding special tokens. An XLM-RoBERTa sequence has the following format:
+
+ - single sequence: `<s> X </s>`
+ - pair of sequences: `<s> A </s></s> B </s>`
+
+ Args:
+ token_ids_0 (`list[int]`):
+ List of IDs to which the special tokens will be added.
+ token_ids_1 (`list[int]`, *optional*):
+ Optional second list of IDs for sequence pairs.
+
+ Returns:
+ `list[int]`: List of [input IDs](../glossary#input-ids) with the appropriate special tokens.
+ """
+
+ if token_ids_1 is None:
+ return token_ids_0 + [self.sep_token_id]
+ sep = [self.sep_token_id]
+ return token_ids_0 + sep + token_ids_1 + sep
+
+ def create_token_type_ids_from_sequences(
+ self, token_ids_0: list[int], token_ids_1: list[int] | None = None
+ ) -> list[int]:
+ """
+ Create a mask from the two sequences passed to be used in a sequence-pair classification task. XLM-RoBERTa does
+ not make use of token type ids, therefore a list of zeros is returned.
+
+ Args:
+ token_ids_0 (`list[int]`):
+ List of IDs.
+ token_ids_1 (`list[int]`, *optional*):
+ Optional second list of IDs for sequence pairs.
+
+ Returns:
+ `list[int]`: List of zeros.
+
+ """
+
+ sep = [self.sep_token_id]
+
+ if token_ids_1 is None:
+ return len(token_ids_0 + sep) * [0]
+ return len(token_ids_0 + sep + token_ids_1 + sep) * [0]
+
+ def save_vocabulary(self, save_directory: str, filename_prefix: str | None = None) -> tuple[str]:
+ """
+ Save the tokenizer vocabulary files. For TokenizersBackend, the tokenizer.json file is saved
+ by the base class. This method returns an empty tuple since we only use tokenizer.json.
+ """
+ # The base class handles saving tokenizer.json in _save_pretrained
+ # We don't need to save vocab_file since we only use tokenizer.json
+ return ()
+
+
+__all__ = ["UdopTokenizer"]
diff --git a/lib/python3.11/site-packages/transformers/models/umt5/__init__.py b/lib/python3.11/site-packages/transformers/models/umt5/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5dc2e041359770eca293bd2cce968e1b19d22bc2
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/umt5/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_umt5 import *
+ from .modeling_umt5 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/umt5/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/umt5/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..59809ff05460fbb244120cf7169ff55c78924def
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/umt5/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/umt5/__pycache__/configuration_umt5.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/umt5/__pycache__/configuration_umt5.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5fd4343ac52adf7d9df459ecad9c7a8b82eae07
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/umt5/__pycache__/configuration_umt5.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/umt5/__pycache__/modeling_umt5.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/umt5/__pycache__/modeling_umt5.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a5a83684d16075236b3069004004b10115cbece
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/umt5/__pycache__/modeling_umt5.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/umt5/configuration_umt5.py b/lib/python3.11/site-packages/transformers/models/umt5/configuration_umt5.py
new file mode 100644
index 0000000000000000000000000000000000000000..db298c0ea0012c69e26cb350c5c9aac272948201
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/umt5/configuration_umt5.py
@@ -0,0 +1,91 @@
+# Copyright 2023, The T5 Authors and HuggingFace Inc.
+#
+# 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.
+"""UMT5 model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="google/umt5-small")
+@strict
+class UMT5Config(PreTrainedConfig):
+ r"""
+ relative_attention_num_buckets (`int`, *optional*, defaults to 32):
+ The number of buckets to use for each attention layer.
+ relative_attention_max_distance (`int`, *optional*, defaults to 128):
+ The maximum distance of the longer sequences for the bucket separation.
+ feed_forward_proj (`str`, *optional*, defaults to `"gated-gelu"`):
+ Type of feed forward layer to be used. Should be one of `"relu"` or `"gated-gelu"`.
+ """
+
+ model_type = "umt5"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ attribute_map = {
+ "hidden_size": "d_model",
+ "num_attention_heads": "num_heads",
+ "num_hidden_layers": "num_layers",
+ "head_dim": "d_kv",
+ }
+
+ vocab_size: int = 250112
+ d_model: int = 512
+ d_kv: int = 64
+ d_ff: int = 1024
+ num_layers: int = 8
+ num_decoder_layers: int | None = None
+ num_heads: int = 6
+ relative_attention_num_buckets: int = 32
+ relative_attention_max_distance: int = 128
+ dropout_rate: float | int = 0.1
+ layer_norm_epsilon: float = 1e-6
+ initializer_factor: float = 1.0
+ feed_forward_proj: str = "gated-gelu"
+ is_encoder_decoder: bool = True
+ use_cache: bool = True
+ pad_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 1
+ decoder_start_token_id: int | None = 0
+ classifier_dropout: float | int = 0.0
+ is_decoder: bool = False
+
+ def __post_init__(self, **kwargs):
+ self.num_decoder_layers = (
+ self.num_decoder_layers if self.num_decoder_layers is not None else self.num_layers
+ ) # default = symmetry
+ act_info = self.feed_forward_proj.split("-")
+ self.dense_act_fn = act_info[-1]
+ self.is_gated_act = act_info[0] == "gated"
+
+ if self.feed_forward_proj == "gated-gelu":
+ self.dense_act_fn = "gelu_new"
+
+ kwargs.pop("tie_word_embeddings", None)
+ self.tie_word_embeddings = True # force it for T5 family
+
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ act_info = self.feed_forward_proj.split("-")
+ if len(act_info) > 1 and act_info[0] != "gated" or len(act_info) > 2:
+ raise ValueError(
+ f"`feed_forward_proj`: {self.feed_forward_proj} is not a valid activation function of the dense layer. "
+ "Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. "
+ "'gated-gelu' or 'relu'"
+ )
+
+
+__all__ = ["UMT5Config"]
diff --git a/lib/python3.11/site-packages/transformers/models/umt5/modeling_umt5.py b/lib/python3.11/site-packages/transformers/models/umt5/modeling_umt5.py
new file mode 100644
index 0000000000000000000000000000000000000000..709bb3b312f8c2a22044fe9969248ff950991aeb
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/umt5/modeling_umt5.py
@@ -0,0 +1,1629 @@
+# Copyright 2023 Mesh TensorFlow authors, T5 Authors and 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.
+"""PyTorch UMT5 model."""
+
+import copy
+import math
+
+import torch
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ BaseModelOutputWithPastAndCrossAttentions,
+ Seq2SeqLMOutput,
+ Seq2SeqModelOutput,
+ Seq2SeqQuestionAnsweringModelOutput,
+ Seq2SeqSequenceClassifierOutput,
+ TokenClassifierOutput,
+)
+from ...modeling_utils import PreTrainedModel
+from ...utils import (
+ DUMMY_INPUTS,
+ DUMMY_MASK,
+ auto_docstring,
+ is_torchdynamo_compiling,
+ logging,
+ torch_compilable_check,
+)
+from .configuration_umt5 import UMT5Config
+
+
+logger = logging.get_logger(__name__)
+
+
+# Copied from transformers.models.t5.modeling_t5.T5LayerNorm with T5->UMT5
+class UMT5LayerNorm(nn.Module):
+ def __init__(self, hidden_size, eps=1e-6):
+ """
+ Construct a layernorm module in the UMT5 style. No bias and no subtraction of mean.
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states):
+ # UMT5 uses a layer_norm which only scales and doesn't shift, which is also known as Root Mean
+ # Square Layer Normalization https://huggingface.co/papers/1910.07467 thus variance is calculated
+ # w/o mean and there is no bias. Additionally we want to make sure that the accumulation for
+ # half-precision inputs is done in fp32
+
+ variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+
+ # convert into half-precision if necessary
+ if self.weight.dtype in [torch.float16, torch.bfloat16]:
+ hidden_states = hidden_states.to(self.weight.dtype)
+
+ return self.weight * hidden_states
+
+
+# Copied from transformers.models.t5.modeling_t5.T5DenseActDense with T5->UMT5
+class UMT5DenseActDense(nn.Module):
+ def __init__(self, config: UMT5Config):
+ super().__init__()
+ self.wi = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.act = ACT2FN[config.dense_act_fn]
+
+ def forward(self, hidden_states):
+ hidden_states = self.wi(hidden_states)
+ hidden_states = self.act(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ if (
+ isinstance(self.wo.weight, torch.Tensor)
+ and hidden_states.dtype != self.wo.weight.dtype
+ and self.wo.weight.dtype != torch.int8
+ ):
+ hidden_states = hidden_states.to(self.wo.weight.dtype)
+ hidden_states = self.wo(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.t5.modeling_t5.T5DenseGatedActDense with T5->UMT5
+class UMT5DenseGatedActDense(nn.Module):
+ def __init__(self, config: UMT5Config):
+ super().__init__()
+ self.wi_0 = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wi_1 = nn.Linear(config.d_model, config.d_ff, bias=False)
+ self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
+ self.dropout = nn.Dropout(config.dropout_rate)
+ self.act = ACT2FN[config.dense_act_fn]
+
+ def forward(self, hidden_states):
+ hidden_gelu = self.act(self.wi_0(hidden_states))
+ hidden_linear = self.wi_1(hidden_states)
+ hidden_states = hidden_gelu * hidden_linear
+ hidden_states = self.dropout(hidden_states)
+
+ # To make 8bit quantization work for google/flan-t5-xxl, self.wo is kept in float32.
+ # See https://github.com/huggingface/transformers/issues/20287
+ # we also make sure the weights are not in `int8` in case users will force `_keep_in_fp32_modules` to be `None``
+ if (
+ isinstance(self.wo.weight, torch.Tensor)
+ and hidden_states.dtype != self.wo.weight.dtype
+ and self.wo.weight.dtype != torch.int8
+ ):
+ hidden_states = hidden_states.to(self.wo.weight.dtype)
+
+ hidden_states = self.wo(hidden_states)
+ return hidden_states
+
+
+# Copied from transformers.models.t5.modeling_t5.T5LayerFF with T5->UMT5
+class UMT5LayerFF(nn.Module):
+ def __init__(self, config: UMT5Config):
+ super().__init__()
+ if config.is_gated_act:
+ self.DenseReluDense = UMT5DenseGatedActDense(config)
+ else:
+ self.DenseReluDense = UMT5DenseActDense(config)
+
+ self.layer_norm = UMT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(self, hidden_states):
+ forwarded_states = self.layer_norm(hidden_states)
+ forwarded_states = self.DenseReluDense(forwarded_states)
+ hidden_states = hidden_states + self.dropout(forwarded_states)
+ return hidden_states
+
+
+class UMT5Attention(nn.Module):
+ """
+ T5's attention using relative_attention_bias.
+ """
+
+ def __init__(self, config, has_relative_attention_bias=False, layer_idx: int | None = None):
+ super().__init__()
+ self.is_decoder = config.is_decoder
+ self.has_relative_attention_bias = has_relative_attention_bias
+ self.relative_attention_num_buckets = config.relative_attention_num_buckets
+ self.relative_attention_max_distance = config.relative_attention_max_distance
+ self.d_model = config.d_model
+ self.key_value_proj_dim = config.d_kv
+ self.n_heads = config.num_heads
+ self.dropout = config.dropout_rate
+ self.inner_dim = self.n_heads * self.key_value_proj_dim
+ self.layer_idx = layer_idx
+ if layer_idx is None and self.is_decoder:
+ logger.warning_once(
+ f"Instantiating a decoder {self.__class__.__name__} without passing `layer_idx` is not recommended and "
+ "will to errors during the forward call, if caching is used. Please make sure to provide a `layer_idx` "
+ "when creating this class."
+ )
+
+ self.q = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.k = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.v = nn.Linear(self.d_model, self.inner_dim, bias=False)
+ self.o = nn.Linear(self.inner_dim, self.d_model, bias=False)
+
+ if self.has_relative_attention_bias:
+ self.relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets, self.n_heads)
+
+ def _shape(self, projection: torch.Tensor) -> torch.Tensor:
+ new_projection_shape = projection.size()[:-1] + (self.n_heads, self.key_value_proj_dim)
+ # move heads to 2nd position (B, T, H * D) -> (B, T, H, D) -> (B, H, T, D)
+ new_projection = projection.view(new_projection_shape).permute(0, 2, 1, 3)
+ return new_projection
+
+ def _relative_position_bucket(self, relative_position):
+ """
+ Adapted from Mesh Tensorflow:
+ https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593
+
+ Translate relative position to a bucket number for relative attention. The relative position is defined as
+ memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to
+ position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for
+ small absolute relative_position and larger buckets for larger absolute relative_positions. All relative
+ positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket.
+ This should allow for more graceful generalization to longer sequences than the model has been trained on
+
+ Args:
+ relative_position: an int32 Tensor
+ bidirectional: a boolean - whether the attention is bidirectional
+ num_buckets: an integer
+ max_distance: an integer
+
+ Returns:
+ a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets)
+ """
+ relative_buckets = 0
+ num_buckets = self.relative_attention_num_buckets
+ max_distance = self.relative_attention_max_distance
+ if not self.is_decoder:
+ num_buckets //= 2
+ relative_buckets += (relative_position > 0).to(torch.long) * num_buckets
+ relative_position = torch.abs(relative_position)
+ else:
+ relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
+ # now relative_position is in the range [0, inf)
+
+ # half of the buckets are for exact increments in positions
+ max_exact = num_buckets // 2
+ is_small = relative_position < max_exact
+
+ # The other half of the buckets are for logarithmically bigger bins in positions up to max_distance
+ log_ratio = torch.log(relative_position.float() / max_exact) / math.log(max_distance / max_exact)
+ log_ratio = log_ratio * (num_buckets - max_exact)
+ relative_position_if_large = max_exact + log_ratio.to(torch.long)
+ relative_position_if_large = torch.min(
+ relative_position_if_large, torch.full_like(relative_position_if_large, num_buckets - 1)
+ )
+
+ relative_buckets += torch.where(is_small, relative_position, relative_position_if_large)
+ return relative_buckets
+
+ def compute_bias(self, query_length, key_length, device=None, past_seen_tokens=0):
+ """Compute binned relative position bias"""
+ if device is None:
+ device = self.relative_attention_bias.weight.device
+ context_position = torch.arange(query_length, dtype=torch.long, device=device)[:, None] + past_seen_tokens
+ memory_position = torch.arange(key_length, dtype=torch.long, device=device)[None, :]
+ relative_position = memory_position - context_position # shape (query_length, key_length)
+ relative_position_bucket = self._relative_position_bucket(relative_position)
+ values = self.relative_attention_bias(relative_position_bucket) # shape (query_length, key_length, num_heads)
+ values = values.permute([2, 0, 1]).unsqueeze(0) # shape (1, num_heads, query_length, key_length)
+ return values
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ encoder_hidden_states: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ attention_mask: torch.Tensor | None = None,
+ **kwargs,
+ ):
+ batch_size, seq_length = hidden_states.shape[:2]
+ past_seen_tokens = past_key_values.get_seq_length(self.layer_idx) if past_key_values is not None else 0
+ # We clone here for StaticCache, as we get the value before updating it, but use it after and it's the same ref
+ past_seen_tokens = past_seen_tokens.clone() if isinstance(past_seen_tokens, torch.Tensor) else past_seen_tokens
+
+ # if encoder_hidden_states are provided this layer is used as a cross-attention layer for the decoder
+ is_cross_attention = encoder_hidden_states is not None
+
+ query_states = self.q(hidden_states)
+ query_states = query_states.view(batch_size, -1, self.n_heads, self.key_value_proj_dim).transpose(1, 2)
+
+ # Check is encoder-decoder model is being used. Otherwise we'll get `DynamicCache`
+ is_updated = False
+ if past_key_values is not None and isinstance(past_key_values, EncoderDecoderCache):
+ is_updated = past_key_values.is_updated.get(self.layer_idx)
+ if is_cross_attention:
+ # after the first generated id, we can subsequently re-use all key/value_states from cache
+ curr_past_key_values = past_key_values.cross_attention_cache
+ else:
+ curr_past_key_values = past_key_values.self_attention_cache
+ else:
+ curr_past_key_values = past_key_values
+
+ current_states = encoder_hidden_states if is_cross_attention else hidden_states
+ if is_cross_attention and past_key_values is not None and is_updated:
+ # reuse k,v, cross_attentions
+ key_states = curr_past_key_values.layers[self.layer_idx].keys
+ value_states = curr_past_key_values.layers[self.layer_idx].values
+ else:
+ key_states = self.k(current_states)
+ value_states = self.v(current_states)
+ key_states = key_states.view(batch_size, -1, self.n_heads, self.key_value_proj_dim).transpose(1, 2)
+ value_states = value_states.view(batch_size, -1, self.n_heads, self.key_value_proj_dim).transpose(1, 2)
+
+ if past_key_values is not None:
+ # save all key/value_states to cache to be re-used for fast auto-regressive generation
+ key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+ # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+ if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+ past_key_values.is_updated[self.layer_idx] = True
+
+ # compute scores, equivalent of torch.einsum("bnqd,bnkd->bnqk", query_states, key_states), compatible with onnx op>9
+ scores = torch.matmul(query_states, key_states.transpose(3, 2))
+
+ key_length = key_states.shape[-2]
+ if not self.has_relative_attention_bias:
+ position_bias = torch.zeros(
+ (1, self.n_heads, seq_length, key_length), device=scores.device, dtype=scores.dtype
+ )
+ else:
+ position_bias = self.compute_bias(
+ seq_length, key_length, device=scores.device, past_seen_tokens=past_seen_tokens
+ )
+
+ if attention_mask is not None:
+ position_bias = position_bias + attention_mask
+
+ position_bias_masked = position_bias
+ scores += position_bias_masked
+
+ # (batch_size, n_heads, seq_length, key_length)
+ attn_weights = nn.functional.softmax(scores.float(), dim=-1).type_as(scores)
+ attn_weights = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+ attn_output = torch.matmul(attn_weights, value_states)
+
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ attn_output = attn_output.view(batch_size, seq_length, -1)
+
+ attn_output = self.o(attn_output)
+ return attn_output, attn_weights
+
+
+class UMT5LayerSelfAttention(nn.Module):
+ def __init__(self, config, layer_idx: int | None = None):
+ super().__init__()
+ self.SelfAttention = UMT5Attention(config, has_relative_attention_bias=True, layer_idx=layer_idx)
+ self.layer_norm = UMT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ past_key_values=None,
+ **kwargs,
+ ):
+ normed_hidden_states = self.layer_norm(hidden_states)
+ attention_output = self.SelfAttention(
+ normed_hidden_states,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+ hidden_states = hidden_states + self.dropout(attention_output[0])
+ outputs = (hidden_states,) + attention_output[1:] # add attentions if we output them
+ return outputs
+
+
+class UMT5LayerCrossAttention(nn.Module):
+ def __init__(self, config, layer_idx: int | None = None):
+ super().__init__()
+ self.EncDecAttention = UMT5Attention(config, has_relative_attention_bias=False, layer_idx=layer_idx)
+ self.layer_norm = UMT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ def forward(
+ self,
+ hidden_states,
+ encoder_hidden_states=None,
+ attention_mask=None,
+ past_key_values=None,
+ **kwargs,
+ ):
+ normed_hidden_states = self.layer_norm(hidden_states)
+ attention_output = self.EncDecAttention(
+ normed_hidden_states,
+ encoder_hidden_states=encoder_hidden_states,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+ layer_output = hidden_states + self.dropout(attention_output[0])
+ outputs = (layer_output,) + attention_output[1:] # add attentions if we output them
+ return outputs
+
+
+class UMT5Block(GradientCheckpointingLayer):
+ def __init__(self, config, layer_idx: int | None = None):
+ super().__init__()
+ self.is_decoder = config.is_decoder
+ self.layer = nn.ModuleList()
+ self.layer.append(UMT5LayerSelfAttention(config, layer_idx=layer_idx))
+ if self.is_decoder:
+ self.layer.append(UMT5LayerCrossAttention(config, layer_idx=layer_idx))
+
+ self.layer.append(UMT5LayerFF(config))
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ past_key_values=None,
+ use_cache=False,
+ output_attentions=False,
+ **kwargs,
+ ):
+ hidden_states, self_attn_weights = self.layer[0](
+ hidden_states,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16:
+ max_dtype = torch.finfo(hidden_states.dtype).max
+ clamp_value = torch.where(torch.isinf(hidden_states).any(), max_dtype - 1000, max_dtype)
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ # Cross-Attention Block
+ cross_attn_weights = None
+ do_cross_attention = self.is_decoder and encoder_hidden_states is not None
+ if do_cross_attention:
+ hidden_states, cross_attn_weights = self.layer[1](
+ hidden_states,
+ encoder_hidden_states=encoder_hidden_states,
+ attention_mask=encoder_attention_mask,
+ past_key_values=past_key_values,
+ )
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16:
+ max_dtype = torch.finfo(hidden_states.dtype).max
+ clamp_value = torch.where(torch.isinf(hidden_states).any(), max_dtype - 1000, max_dtype)
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ # Apply Feed Forward layer
+ hidden_states = self.layer[-1](hidden_states)
+
+ # clamp inf values to enable fp16 training
+ if hidden_states.dtype == torch.float16:
+ max_dtype = torch.finfo(hidden_states.dtype).max
+ clamp_value = torch.where(torch.isinf(hidden_states).any(), max_dtype - 1000, max_dtype)
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (self_attn_weights, cross_attn_weights)
+
+ return outputs
+
+
+# Copied from transformers.models.t5.modeling_t5.T5ClassificationHead with T5->UMT5
+class UMT5ClassificationHead(nn.Module):
+ """Head for sentence-level classification tasks."""
+
+ def __init__(self, config: UMT5Config):
+ super().__init__()
+ self.dense = nn.Linear(config.d_model, config.d_model)
+ self.dropout = nn.Dropout(p=config.classifier_dropout)
+ self.out_proj = nn.Linear(config.d_model, config.num_labels)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.dense(hidden_states)
+ hidden_states = torch.tanh(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.out_proj(hidden_states)
+ return hidden_states
+
+
+@auto_docstring
+class UMT5PreTrainedModel(PreTrainedModel):
+ config: UMT5Config
+ base_model_prefix = "transformer"
+ supports_gradient_checkpointing = True
+
+ _can_compile_fullgraph = True
+ _no_split_modules = ["UMT5Block"]
+ _keep_in_fp32_modules = ["wo"]
+
+ @property
+ def dummy_inputs(self):
+ input_ids = torch.tensor(DUMMY_INPUTS)
+ input_mask = torch.tensor(DUMMY_MASK)
+ dummy_inputs = {
+ "decoder_input_ids": input_ids,
+ "input_ids": input_ids,
+ "decoder_attention_mask": input_mask,
+ }
+ return dummy_inputs
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ factor = self.config.initializer_factor # Used for testing weights initialization
+ if isinstance(module, UMT5LayerNorm):
+ init.constant_(module.weight, factor * 1.0)
+ elif isinstance(
+ module,
+ (
+ UMT5Model,
+ UMT5ForConditionalGeneration,
+ UMT5EncoderModel,
+ UMT5ForQuestionAnswering,
+ ),
+ ):
+ # Mesh TensorFlow embeddings initialization
+ # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L1624
+ init.normal_(module.shared.weight, mean=0.0, std=factor * 1.0)
+ if hasattr(module, "lm_head") and not self.config.tie_word_embeddings:
+ init.normal_(module.lm_head.weight, mean=0.0, std=factor * 1.0)
+ if hasattr(module, "qa_outputs"):
+ init.normal_(module.qa_outputs.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ init.zeros_(module.qa_outputs.bias)
+ elif isinstance(module, UMT5ForTokenClassification):
+ if hasattr(module, "classifier"):
+ init.normal_(module.classifier.weight, mean=0.0, std=factor * 1.0)
+ init.zeros_(module.classifier.bias)
+ elif isinstance(module, UMT5ClassificationHead):
+ init.normal_(module.dense.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.dense, "bias") and module.dense.bias is not None:
+ init.zeros_(module.dense.bias)
+ init.normal_(module.out_proj.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.out_proj, "bias") and module.out_proj.bias is not None:
+ init.zeros_(module.out_proj.bias)
+ elif isinstance(module, UMT5DenseActDense):
+ # Mesh TensorFlow FF initialization
+ # See https://github.com/tensorflow/mesh/blob/master/mesh_tensorflow/transformer/transformer_layers.py#L56
+ # and https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L89
+ init.normal_(module.wi.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi, "bias") and module.wi.bias is not None:
+ init.zeros_(module.wi.bias)
+ init.normal_(module.wo.weight, mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
+ if hasattr(module.wo, "bias") and module.wo.bias is not None:
+ init.zeros_(module.wo.bias)
+ elif isinstance(module, UMT5DenseGatedActDense):
+ init.normal_(module.wi_0.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi_0, "bias") and module.wi_0.bias is not None:
+ init.zeros_(module.wi_0.bias)
+ init.normal_(module.wi_1.weight, mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
+ if hasattr(module.wi_1, "bias") and module.wi_1.bias is not None:
+ init.zeros_(module.wi_1.bias)
+ init.normal_(module.wo.weight, mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
+ if hasattr(module.wo, "bias") and module.wo.bias is not None:
+ init.zeros_(module.wo.bias)
+ elif isinstance(module, UMT5Attention):
+ # Mesh TensorFlow attention initialization to avoid scaling before softmax
+ # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/attention.py#L136
+ d_model = self.config.d_model
+ key_value_proj_dim = self.config.d_kv
+ n_heads = self.config.num_heads
+ init.normal_(module.q.weight, mean=0.0, std=factor * ((d_model * key_value_proj_dim) ** -0.5))
+ init.normal_(module.k.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.v.weight, mean=0.0, std=factor * (d_model**-0.5))
+ init.normal_(module.o.weight, mean=0.0, std=factor * ((n_heads * key_value_proj_dim) ** -0.5))
+ if module.has_relative_attention_bias:
+ init.normal_(module.relative_attention_bias.weight, mean=0.0, std=factor * ((d_model) ** -0.5))
+
+ def _shift_right(self, input_ids):
+ decoder_start_token_id = self.config.decoder_start_token_id
+ pad_token_id = self.config.pad_token_id
+
+ if decoder_start_token_id is None:
+ raise ValueError(
+ "self.model.config.decoder_start_token_id has to be defined. In UMT5 it is usually set to the pad_token_id. "
+ "See UMT5 docs for more information."
+ )
+
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+ shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
+ shifted_input_ids[..., 0] = decoder_start_token_id
+
+ if pad_token_id is None:
+ raise ValueError("self.model.config.pad_token_id has to be defined.")
+ # replace possible -100 values in labels by `pad_token_id`
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+ return shifted_input_ids
+
+
+class UMT5Stack(UMT5PreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.embed_tokens = nn.Embedding(config.vocab_size, config.d_model)
+ self.is_decoder = config.is_decoder
+ self.block = nn.ModuleList([UMT5Block(config, layer_idx=i) for i in range(config.num_layers)])
+ self.final_layer_norm = UMT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+ self.dropout = nn.Dropout(config.dropout_rate)
+
+ # Initialize weights and apply final processing
+ self.gradient_checkpointing = False
+ self.post_init()
+
+ def set_input_embeddings(self, new_embeddings):
+ self.embed_tokens = new_embeddings
+
+ def forward(
+ self,
+ input_ids=None,
+ attention_mask=None,
+ encoder_hidden_states=None,
+ encoder_attention_mask=None,
+ inputs_embeds=None,
+ past_key_values=None,
+ use_cache=None,
+ output_attentions=None,
+ output_hidden_states=None,
+ return_dict=None,
+ **kwargs,
+ ):
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if input_ids is not None and inputs_embeds is not None:
+ err_msg_prefix = "decoder_" if self.is_decoder else ""
+ raise ValueError(
+ f"You cannot specify both {err_msg_prefix}input_ids and {err_msg_prefix}inputs_embeds at the same time"
+ )
+ elif input_ids is not None:
+ input_shape = input_ids.size()
+ input_ids = input_ids.view(-1, input_shape[-1])
+ elif inputs_embeds is not None:
+ input_shape = inputs_embeds.size()[:-1]
+ else:
+ err_msg_prefix = "decoder_" if self.is_decoder else ""
+ raise ValueError(f"You have to specify either {err_msg_prefix}input_ids or {err_msg_prefix}inputs_embeds")
+
+ if self.gradient_checkpointing and self.training:
+ if use_cache:
+ logger.warning_once(
+ "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+ )
+ use_cache = False
+
+ if inputs_embeds is None:
+ if self.embed_tokens is None:
+ raise ValueError("You have to initialize the model with valid token embeddings")
+ inputs_embeds = self.embed_tokens(input_ids)
+
+ batch_size, seq_length = input_shape
+
+ if use_cache is True:
+ if not self.is_decoder:
+ raise ValueError(f"`use_cache` can only be set to `True` if {self} is used as a decoder")
+
+ # initialize past_key_values
+ if self.is_decoder:
+ if use_cache and past_key_values is None:
+ if self.config.is_encoder_decoder:
+ past_key_values = EncoderDecoderCache(
+ DynamicCache(config=self.config), DynamicCache(config=self.config)
+ )
+ else:
+ past_key_values = DynamicCache(config=self.config)
+ elif not self.is_decoder:
+ # do not pass cache object down the line for encoder stack
+ # it messes indexing later in decoder-stack because cache object is modified in-place
+ past_key_values = None
+
+ past_key_values_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+ if attention_mask is None and not is_torchdynamo_compiling():
+ # required mask seq length can be calculated via length of past cache
+ mask_seq_length = past_key_values_length + seq_length
+ attention_mask = torch.ones(batch_size, mask_seq_length, device=inputs_embeds.device)
+
+ if self.is_decoder:
+ causal_mask = create_causal_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ )
+ elif attention_mask is not None:
+ causal_mask = attention_mask[:, None, None, :]
+ causal_mask = causal_mask.to(dtype=inputs_embeds.dtype)
+ causal_mask = (1.0 - causal_mask) * torch.finfo(inputs_embeds.dtype).min
+ else:
+ causal_mask = None
+
+ if self.is_decoder and encoder_attention_mask is not None:
+ encoder_extended_attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=encoder_attention_mask,
+ encoder_hidden_states=encoder_hidden_states,
+ )
+ else:
+ encoder_extended_attention_mask = None
+
+ all_hidden_states = () if output_hidden_states else None
+ all_attentions = () if output_attentions else None
+ all_cross_attentions = () if output_attentions and self.is_decoder else None
+
+ hidden_states = self.dropout(inputs_embeds)
+
+ for i, layer_module in enumerate(self.block):
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ layer_outputs = layer_module(
+ hidden_states,
+ causal_mask,
+ encoder_hidden_states, # as a positional argument for gradient checkpointing
+ encoder_attention_mask=encoder_extended_attention_mask,
+ past_key_values=past_key_values,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ )
+
+ hidden_states = layer_outputs[0]
+
+ if output_attentions:
+ all_attentions += (layer_outputs[1],)
+ if self.is_decoder:
+ all_cross_attentions += (layer_outputs[2],)
+
+ hidden_states = self.final_layer_norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ # Add last layer
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(
+ v
+ for v in [
+ hidden_states,
+ past_key_values,
+ all_hidden_states,
+ all_attentions,
+ all_cross_attentions,
+ ]
+ if v is not None
+ )
+ return BaseModelOutputWithPastAndCrossAttentions(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ hidden_states=all_hidden_states,
+ attentions=all_attentions,
+ cross_attentions=all_cross_attentions,
+ )
+
+
+@auto_docstring
+class UMT5Model(UMT5PreTrainedModel):
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import UMT5Model, AutoTokenizer
+
+ >>> model = UMT5Model.from_pretrained("google/umt5-small")
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
+ >>> noisy_text = "UN Offizier sagt, dass weiter <extra_id_0> werden muss in Syrien."
+ >>> label = "<extra_id_0> verhandelt"
+ >>> inputs = tokenizer(inputs, return_tensors="pt")
+ >>> labels = tokenizer(label=label, return_tensors="pt")
+
+ >>> outputs = model(input_ids=inputs["input_ids"], decoder_input_ids=labels["input_ids"])
+ >>> hidden_states = outputs.last_hidden_state
+ ```"""
+
+ model_type = "umt5"
+ config: UMT5Config
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = UMT5Stack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = UMT5Stack(decoder_config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ # Copied from transformers.models.t5.modeling_t5.T5Model.get_input_embeddings
+ def get_input_embeddings(self):
+ return self.shared
+
+ # Copied from transformers.models.t5.modeling_t5.T5Model.set_input_embeddings
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ decoder_inputs_embeds: torch.Tensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | Seq2SeqModelOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. UMT5 is a model with relative position embeddings so
+ you should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [UMT5 Training](./umt5#training).
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ UMT5 uses the `pad_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+ is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+ To know more on how to prepare `decoder_input_ids` for pretraining take a look at [UMT5
+ Training](./umt5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, UMT5Model
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
+ >>> model = UMT5Model.from_pretrained("google/umt5-small")
+
+ >>> input_ids = tokenizer(
+ ... "Studies have been shown that owning a dog is good for you", return_tensors="pt"
+ ... ).input_ids # Batch size 1
+ >>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1
+
+ >>> # preprocess: Prepend decoder_input_ids with start token which is pad token for UMT5Model.
+ >>> # This is not needed for torch's UMT5ForConditionalGeneration as it does this internally using labels arg.
+ >>> decoder_input_ids = model._shift_right(decoder_input_ids)
+
+ >>> # forward pass
+ >>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
+ >>> last_hidden_states = outputs.last_hidden_state
+ ```"""
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # Encode if needed (training, first prediction pass)
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if not return_dict:
+ return decoder_outputs + encoder_outputs
+
+ return Seq2SeqModelOutput(
+ last_hidden_state=decoder_outputs.last_hidden_state,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ UMT5 Model with a `language modeling` head on top.
+ """
+)
+class UMT5ForConditionalGeneration(UMT5PreTrainedModel, GenerationMixin):
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import UMT5ForConditionalGeneration, AutoTokenizer
+
+ >>> model = UMT5ForConditionalGeneration.from_pretrained("google/umt5-small")
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
+ >>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
+ >>> summary = "Weiter Verhandlung in Syrien."
+ >>> inputs = tokenizer(article, text_target=summary, return_tensors="pt")
+
+ >>> outputs = model(**inputs)
+ >>> loss = outputs.loss
+ ```"""
+
+ model_type = "umt5"
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ "lm_head.weight": "shared.weight",
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.model_dim = config.d_model
+
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = UMT5Stack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = UMT5Stack(decoder_config)
+
+ self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ # Copied from transformers.models.t5.modeling_t5.T5ForConditionalGeneration.get_input_embeddings
+ def get_input_embeddings(self):
+ return self.shared
+
+ # Copied from transformers.models.t5.modeling_t5.T5ForConditionalGeneration.set_input_embeddings
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.Tensor]] | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | Seq2SeqLMOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. UMT5 is a model with relative position embeddings so
+ you should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [UMT5 Training](./umt5#training).
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ UMT5 uses the `pad_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+ is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+ To know more on how to prepare `decoder_input_ids` for pretraining take a look at [UMT5
+ Training](./umt5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[-100, 0, ...,
+ config.vocab_size - 1]`. All labels set to `-100` are ignored (masked), the loss is only computed for
+ labels in `[0, ..., config.vocab_size]`
+
+ Examples:
+
+ ```python
+ >>> from transformers import AutoTokenizer, UMT5ForConditionalGeneration
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
+ >>> model = UMT5ForConditionalGeneration.from_pretrained("google/umt5-small")
+
+ >>> # training
+ >>> input_ids = tokenizer("The <extra_id_0> walks in <extra_id_1> park", return_tensors="pt").input_ids
+ >>> labels = tokenizer("<extra_id_0> cute dog <extra_id_1> the <extra_id_2>", return_tensors="pt").input_ids
+ >>> outputs = model(input_ids=input_ids, labels=labels)
+ >>> loss = outputs.loss
+ >>> logits = outputs.logits
+
+ >>> # inference
+ >>> input_ids = tokenizer("Studies have shown that <extra_id_0> good for you", return_tensors="pt").input_ids
+ >>> outputs = model.generate(input_ids)
+ >>> tokenizer.decode(outputs[0], skip_special_tokens=True)
+ ```"""
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # Encode if needed (training, first prediction pass)
+ if encoder_outputs is None:
+ # Convert encoder inputs in embeddings if needed
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
+ # get decoder inputs from shifting lm labels to the right
+ decoder_input_ids = self._shift_right(labels)
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=past_key_values,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = decoder_outputs[0]
+
+ if self.config.tie_word_embeddings:
+ # Rescale output before projecting on vocab
+ # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/transformer.py#L586
+ sequence_output = sequence_output * (self.model_dim**-0.5)
+
+ lm_logits = self.lm_head(sequence_output)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss(ignore_index=-100)
+ # move labels to correct device to enable PP
+ labels = labels.to(lm_logits.device)
+ loss = loss_fct(lm_logits.view(-1, lm_logits.size(-1)), labels.view(-1))
+
+ if not return_dict:
+ output = (lm_logits,) + decoder_outputs[1:] + encoder_outputs
+ return ((loss,) + output) if loss is not None else output
+
+ return Seq2SeqLMOutput(
+ loss=loss,
+ logits=lm_logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+ # Copied from transformers.models.t5.modeling_t5.T5ForConditionalGeneration.prepare_decoder_input_ids_from_labels
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+ return self._shift_right(labels)
+
+
+@auto_docstring
+class UMT5EncoderModel(UMT5PreTrainedModel):
+ r"""
+ Examples:
+
+ ```python
+ >>> from transformers import UMT5EncoderModel, AutoTokenizer
+
+ >>> model = UMT5EncoderModel.from_pretrained("google/umt5-small")
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
+ >>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
+ >>> input_ids = tokenizer(article, return_tensors="pt").input_ids
+ >>> outputs = model(input_ids)
+ >>> hidden_state = outputs.last_hidden_state
+ ```"""
+
+ model_type = "umt5"
+ # config_class = UMT5Config
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.use_cache = False
+ encoder_config.is_encoder_decoder = False
+ self.encoder = UMT5Stack(encoder_config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ # Copied from transformers.models.t5.modeling_t5.T5EncoderModel.get_input_embeddings
+ def get_input_embeddings(self):
+ return self.shared
+
+ # Copied from transformers.models.t5.modeling_t5.T5EncoderModel.set_input_embeddings
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ # Copied from transformers.models.t5.modeling_t5.T5EncoderModel.forward with T5->UMT5, google-t5/t5-small->google/umt5-small, t5#training->umt5#training
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | BaseModelOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. UMT5 is a model with relative position embeddings so you
+ should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [UMT5 Training](./umt5#training).
+
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, UMT5EncoderModel
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
+ >>> model = UMT5EncoderModel.from_pretrained("google/umt5-small")
+ >>> input_ids = tokenizer(
+ ... "Studies have been shown that owning a dog is good for you", return_tensors="pt"
+ ... ).input_ids # Batch size 1
+ >>> outputs = model(input_ids=input_ids)
+ >>> last_hidden_states = outputs.last_hidden_state
+ ```"""
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ return encoder_outputs
+
+
+@auto_docstring(
+ custom_intro="""
+ UMT5 model with a sequence classification/head on top (a linear layer on top of the pooled output) e.g. for GLUE
+ tasks.
+ """
+)
+class UMT5ForSequenceClassification(UMT5PreTrainedModel):
+ _keys_to_ignore_on_load_unexpected = ["decoder.block.0.layer.1.EncDecAttention.relative_attention_bias.weight"]
+
+ # Copied from transformers.models.t5.modeling_t5.T5ForSequenceClassification.__init__ with T5->UMT5
+ def __init__(self, config: UMT5Config):
+ super().__init__(config)
+ self.transformer = UMT5Model(config)
+ self.classification_head = UMT5ClassificationHead(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.LongTensor | None = None,
+ encoder_outputs: list[torch.FloatTensor] | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | Seq2SeqSequenceClassifierOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. UMT5 is a model with relative position embeddings so
+ you should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [UMT5 Training](./umt5#training).
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ UMT5 uses the `pad_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+ is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+ To know more on how to prepare `decoder_input_ids` for pretraining take a look at [UMT5
+ Training](./umt5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ if labels is not None:
+ use_cache = False
+
+ if input_ids is None and inputs_embeds is not None:
+ raise NotImplementedError(
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__}"
+ )
+
+ # Copied from models.bart.modeling_bart.BartModel.forward different to other models, T5 automatically creates
+ # decoder_input_ids from input_ids if no decoder_input_ids are provided
+ if decoder_input_ids is None and decoder_inputs_embeds is None:
+ if input_ids is None:
+ raise ValueError(
+ "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+ "passed, `input_ids` cannot be `None`. Please pass either "
+ "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+ )
+ decoder_input_ids = self._shift_right(input_ids)
+
+ outputs = self.transformer(
+ input_ids,
+ attention_mask=attention_mask,
+ decoder_input_ids=decoder_input_ids,
+ decoder_attention_mask=decoder_attention_mask,
+ encoder_outputs=encoder_outputs,
+ inputs_embeds=inputs_embeds,
+ decoder_inputs_embeds=decoder_inputs_embeds,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ sequence_output = outputs[0]
+
+ eos_mask = input_ids.eq(self.config.eos_token_id).to(sequence_output.device)
+
+ torch_compilable_check(
+ torch.unique_consecutive(eos_mask.sum(1)).numel() == 1,
+ "All examples must have the same number of <eos> tokens.",
+ )
+ batch_size, _, hidden_size = sequence_output.shape
+ sentence_representation = sequence_output[eos_mask, :].view(batch_size, -1, hidden_size)[:, -1, :]
+ logits = self.classification_head(sentence_representation)
+
+ loss = None
+ if labels is not None:
+ labels = labels.to(logits.device)
+ if self.config.problem_type is None:
+ if self.config.num_labels == 1:
+ self.config.problem_type = "regression"
+ elif self.config.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+ self.config.problem_type = "single_label_classification"
+ else:
+ self.config.problem_type = "multi_label_classification"
+
+ if self.config.problem_type == "regression":
+ loss_fct = MSELoss()
+ if self.config.num_labels == 1:
+ loss = loss_fct(logits.squeeze(), labels.squeeze())
+ else:
+ loss = loss_fct(logits, labels)
+ elif self.config.problem_type == "single_label_classification":
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.config.num_labels), labels.view(-1))
+ elif self.config.problem_type == "multi_label_classification":
+ loss_fct = BCEWithLogitsLoss()
+ loss = loss_fct(logits, labels)
+ if not return_dict:
+ output = (logits,) + outputs[1:]
+ return ((loss,) + output) if loss is not None else output
+
+ return Seq2SeqSequenceClassifierOutput(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ decoder_hidden_states=outputs.decoder_hidden_states,
+ decoder_attentions=outputs.decoder_attentions,
+ cross_attentions=outputs.cross_attentions,
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+ encoder_hidden_states=outputs.encoder_hidden_states,
+ encoder_attentions=outputs.encoder_attentions,
+ )
+
+
+@auto_docstring
+class UMT5ForTokenClassification(UMT5PreTrainedModel):
+ _keys_to_ignore_on_load_unexpected = ["decoder.block.0.layer.1.EncDecAttention.relative_attention_bias.weight"]
+
+ # Copied from transformers.models.t5.modeling_t5.T5ForTokenClassification.__init__ with T5->UMT5
+ def __init__(self, config: UMT5Config):
+ super().__init__(config)
+ self.num_labels = config.num_labels
+
+ self.transformer = UMT5EncoderModel(config)
+ self.dropout = nn.Dropout(config.classifier_dropout)
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ # Copied from transformers.models.t5.modeling_t5.T5ForTokenClassification.forward with T5->UMT5, t5->umt5
+ def forward(
+ self,
+ input_ids: torch.Tensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ inputs_embeds: torch.Tensor | None = None,
+ labels: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.Tensor] | TokenClassifierOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. UMT5 is a model with relative position embeddings so you
+ should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [UMT5 Training](./umt5#training).
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.transformer(
+ input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = outputs[0]
+ hidden_states = self.dropout(hidden_states)
+ logits = self.classifier(hidden_states)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+ if not return_dict:
+ output = (logits, outputs[2:-1])
+ return ((loss,) + output) if loss is not None else output
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@auto_docstring
+class UMT5ForQuestionAnswering(UMT5PreTrainedModel):
+ _tied_weights_keys = {
+ "encoder.embed_tokens.weight": "shared.weight",
+ "decoder.embed_tokens.weight": "shared.weight",
+ }
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.model_dim = config.d_model
+
+ self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+ encoder_config = copy.deepcopy(config)
+ encoder_config.is_decoder = False
+ encoder_config.use_cache = False
+ self.encoder = UMT5Stack(encoder_config)
+
+ decoder_config = copy.deepcopy(config)
+ decoder_config.is_decoder = True
+ decoder_config.num_layers = config.num_decoder_layers
+ self.decoder = UMT5Stack(decoder_config)
+
+ self.num_labels = config.num_labels
+ self.qa_outputs = nn.Linear(config.d_model, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ # Copied from transformers.models.t5.modeling_t5.T5ForQuestionAnswering.get_input_embeddings
+ def get_input_embeddings(self):
+ return self.shared
+
+ # Copied from transformers.models.t5.modeling_t5.T5ForQuestionAnswering.set_input_embeddings
+ def set_input_embeddings(self, new_embeddings):
+ self.shared = new_embeddings
+ self.encoder.set_input_embeddings(new_embeddings)
+ self.decoder.set_input_embeddings(new_embeddings)
+
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.FloatTensor | None = None,
+ decoder_input_ids: torch.LongTensor | None = None,
+ decoder_attention_mask: torch.BoolTensor | None = None,
+ encoder_outputs: tuple[tuple[torch.Tensor]] | None = None,
+ start_positions: torch.LongTensor | None = None,
+ end_positions: torch.LongTensor | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ decoder_inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | Seq2SeqQuestionAnsweringModelOutput:
+ r"""
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary. UMT5 is a model with relative position embeddings so
+ you should be able to pad the inputs on both the right and the left.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for detail.
+
+ [What are input IDs?](../glossary#input-ids)
+
+ To know more on how to prepare `input_ids` for pretraining take a look a [UMT5 Training](./umt5#training).
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+ UMT5 uses the `pad_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+ is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+ To know more on how to prepare `decoder_input_ids` for pretraining take a look at [UMT5
+ Training](./umt5#training).
+ decoder_attention_mask (`torch.BoolTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+ be used by default.
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ if start_positions is not None and end_positions is not None:
+ use_cache = False
+
+ # Copied from models.bart.modeling_bart.BartModel.forward
+ # different to other models, T5 automatically creates decoder_input_ids from
+ # input_ids if no decoder_input_ids are provided
+ if decoder_input_ids is None and decoder_inputs_embeds is None:
+ if input_ids is None:
+ raise ValueError(
+ "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+ "passed, `input_ids` cannot be `None`. Please pass either "
+ "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+ )
+ decoder_input_ids = self._shift_right(input_ids)
+
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # Encode if needed (training, first prediction pass)
+ if encoder_outputs is None:
+ encoder_outputs = self.encoder(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+ encoder_outputs = BaseModelOutput(
+ last_hidden_state=encoder_outputs[0],
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ # Decode
+ decoder_outputs = self.decoder(
+ input_ids=decoder_input_ids,
+ attention_mask=decoder_attention_mask,
+ inputs_embeds=decoder_inputs_embeds,
+ past_key_values=None,
+ encoder_hidden_states=hidden_states,
+ encoder_attention_mask=attention_mask,
+ use_cache=use_cache,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ sequence_output = decoder_outputs[0]
+
+ logits = self.qa_outputs(sequence_output)
+ start_logits, end_logits = logits.split(1, dim=-1)
+ start_logits = start_logits.squeeze(-1).contiguous()
+ end_logits = end_logits.squeeze(-1).contiguous()
+
+ total_loss = None
+ if start_positions is not None and end_positions is not None:
+ # If we are on multi-GPU, split add a dimension
+ if len(start_positions.size()) > 1:
+ start_positions = start_positions.squeeze(-1).to(start_logits.device)
+ if len(end_positions.size()) > 1:
+ end_positions = end_positions.squeeze(-1).to(end_logits.device)
+ # sometimes the start/end positions are outside our model inputs, we ignore these terms
+ ignored_index = start_logits.size(1)
+ start_positions = start_positions.clamp(0, ignored_index)
+ end_positions = end_positions.clamp(0, ignored_index)
+
+ loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
+ start_loss = loss_fct(start_logits, start_positions)
+ end_loss = loss_fct(end_logits, end_positions)
+ total_loss = (start_loss + end_loss) / 2
+
+ if not return_dict:
+ output = (start_logits, end_logits) + decoder_outputs[1:] + encoder_outputs
+ return ((total_loss,) + output) if total_loss is not None else output
+
+ return Seq2SeqQuestionAnsweringModelOutput(
+ loss=total_loss,
+ start_logits=start_logits,
+ end_logits=end_logits,
+ past_key_values=decoder_outputs.past_key_values,
+ decoder_hidden_states=decoder_outputs.hidden_states,
+ decoder_attentions=decoder_outputs.attentions,
+ cross_attentions=decoder_outputs.cross_attentions,
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+ encoder_hidden_states=encoder_outputs.hidden_states,
+ encoder_attentions=encoder_outputs.attentions,
+ )
+
+
+__all__ = [
+ "UMT5EncoderModel",
+ "UMT5ForConditionalGeneration",
+ "UMT5ForQuestionAnswering",
+ "UMT5ForSequenceClassification",
+ "UMT5ForTokenClassification",
+ "UMT5Model",
+ "UMT5PreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech/__init__.py b/lib/python3.11/site-packages/transformers/models/unispeech/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a03daae25f4535c96c32e20dc4b13a817518bc06
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/unispeech/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_unispeech import *
+ from .modeling_unispeech import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d73fb7c7c2961ba410bf8cc5aa8f5a42e740ecee
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/configuration_unispeech.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/configuration_unispeech.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23fdb4b87d54cbd34898df71e0b264c3082df99e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/configuration_unispeech.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/modeling_unispeech.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/modeling_unispeech.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..057d1af187292155cdc3b50688e1a612b42467c7
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/modeling_unispeech.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/modular_unispeech.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/modular_unispeech.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63a5e9b00c92206b9b147846dd3d598391a061c0
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/unispeech/__pycache__/modular_unispeech.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech/configuration_unispeech.py b/lib/python3.11/site-packages/transformers/models/unispeech/configuration_unispeech.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4819e2d384195a009ac6700dde55a7658f2d265
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/unispeech/configuration_unispeech.py
@@ -0,0 +1,209 @@
+# Copyright 2021 The Fairseq Authors and The HuggingFace Inc. 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.
+"""UniSpeech model configuration"""
+
+import functools
+import operator
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="microsoft/unispeech-large-1500h-cv")
+@strict
+class UniSpeechConfig(PreTrainedConfig):
+ r"""
+ feat_proj_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout probability for output of the feature encoder.
+ feat_quantizer_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout probability for the output of the feature encoder that's used by the quantizer.
+ final_dropout (`float`, *optional*, defaults to 0.1):
+ The dropout probability for the final projection layer of [`UniSpeechForCTC`].
+ feat_extract_norm (`str`, *optional*, defaults to `"group"`):
+ The norm to be applied to 1D convolutional layers in feature encoder. One of `"group"` for group
+ normalization of only the first 1D convolutional layer or `"layer"` for layer normalization of all 1D
+ convolutional layers.
+ feat_extract_activation (`str, *optional*, defaults to `"gelu"`):
+ The non-linear activation function (function or string) in the 1D convolutional layers of the feature
+ extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported.
+ conv_dim (`tuple[int]` or `list[int]`, *optional*, defaults to `(512, 512, 512, 512, 512, 512, 512)`):
+ A tuple of integers defining the number of input and output channels of each 1D convolutional layer in the
+ feature encoder. The length of *conv_dim* defines the number of 1D convolutional layers.
+ conv_stride (`tuple[int]` or `list[int]`, *optional*, defaults to `(5, 2, 2, 2, 2, 2, 2)`):
+ A tuple of integers defining the stride of each 1D convolutional layer in the feature encoder. The length
+ of *conv_stride* defines the number of convolutional layers and has to match the length of *conv_dim*.
+ conv_kernel (`tuple[int]` or `list[int]`, *optional*, defaults to `(10, 3, 3, 3, 3, 2, 2)`):
+ A tuple of integers defining the kernel size of each 1D convolutional layer in the feature encoder. The
+ length of *conv_kernel* defines the number of convolutional layers and has to match the length of
+ *conv_dim*.
+ conv_bias (`bool`, *optional*, defaults to `False`):
+ Whether the 1D convolutional layers have a bias.
+ num_conv_pos_embeddings (`int`, *optional*, defaults to 128):
+ Number of convolutional positional embeddings. Defines the kernel size of 1D convolutional positional
+ embeddings layer.
+ num_conv_pos_embedding_groups (`int`, *optional*, defaults to 16):
+ Number of groups of 1D convolutional positional embeddings layer.
+ do_stable_layer_norm (`bool`, *optional*, defaults to `False`):
+ Whether to apply *stable* layer norm architecture of the Transformer encoder. `do_stable_layer_norm is
+ True` corresponds to applying layer norm before the attention layer, whereas `do_stable_layer_norm is
+ False` corresponds to applying layer norm after the attention layer.
+ apply_spec_augment (`bool`, *optional*, defaults to `True`):
+ Whether to apply *SpecAugment* data augmentation to the outputs of the feature encoder. For reference see
+ [SpecAugment: A Simple Data Augmentation Method for Automatic Speech
+ Recognition](https://huggingface.co/papers/1904.08779).
+ mask_time_prob (`float`, *optional*, defaults to 0.05):
+ Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking
+ procedure generates ''mask_time_prob*len(time_axis)/mask_time_length'' independent masks over the axis. If
+ reasoning from the probability of each feature vector to be chosen as the start of the vector span to be
+ masked, *mask_time_prob* should be `prob_vector_start*mask_time_length`. Note that overlap may decrease the
+ actual percentage of masked vectors. This is only relevant if `apply_spec_augment is True`.
+ mask_time_length (`int`, *optional*, defaults to 10):
+ Length of vector span along the time axis.
+ mask_time_min_masks (`int`, *optional*, defaults to 2):
+ The minimum number of masks of length `mask_feature_length` generated along the time axis, each time step,
+ irrespectively of `mask_feature_prob`. Only relevant if ''mask_time_prob*len(time_axis)/mask_time_length <
+ mask_time_min_masks''
+ mask_feature_prob (`float`, *optional*, defaults to 0.0):
+ Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The
+ masking procedure generates ''mask_feature_prob*len(feature_axis)/mask_time_length'' independent masks over
+ the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector
+ span to be masked, *mask_feature_prob* should be `prob_vector_start*mask_feature_length`. Note that overlap
+ may decrease the actual percentage of masked vectors. This is only relevant if `apply_spec_augment is
+ True`.
+ mask_feature_length (`int`, *optional*, defaults to 10):
+ Length of vector span along the feature axis.
+ mask_feature_min_masks (`int`, *optional*, defaults to 0):
+ The minimum number of masks of length `mask_feature_length` generated along the feature axis, each time
+ step, irrespectively of `mask_feature_prob`. Only relevant if
+ ''mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks''
+ num_codevectors_per_group (`int`, *optional*, defaults to 320):
+ Number of entries in each quantization codebook (group).
+ num_codevector_groups (`int`, *optional*, defaults to 2):
+ Number of codevector groups for product codevector quantization.
+ contrastive_logits_temperature (`float`, *optional*, defaults to 0.1):
+ The temperature *kappa* in the contrastive loss.
+ num_negatives (`int`, *optional*, defaults to 100):
+ Number of negative samples for the contrastive loss.
+ codevector_dim (`int`, *optional*, defaults to 256):
+ Dimensionality of the quantized feature vectors.
+ proj_codevector_dim (`int`, *optional*, defaults to 256):
+ Dimensionality of the final projection of both the quantized and the transformer features.
+ diversity_loss_weight (`int`, *optional*, defaults to 0.1):
+ The weight of the codebook diversity loss component.
+ ctc_zero_infinity (`bool`, *optional*, defaults to `False`):
+ Whether to zero infinite losses and the associated gradients of `torch.nn.CTCLoss`. Infinite losses mainly
+ occur when the inputs are too short to be aligned to the targets. Only relevant when training an instance
+ of [`UniSpeechForCTC`].
+ use_weighted_layer_sum (`bool`, *optional*, defaults to `False`):
+ Whether to use a weighted average of layer outputs with learned weights. Only relevant when using an
+ instance of [`UniSpeechForSequenceClassification`].
+ classifier_proj_size (`int`, *optional*, defaults to 256):
+ Dimensionality of the projection before token mean-pooling for classification.
+ num_ctc_classes (`int`, *optional*, defaults to 80):
+ Specifies the number of classes (phoneme tokens and blank token) for phoneme-level CTC loss. Only relevant
+ when using an instance of [`UniSpeechForPreTraining`].
+ replace_prob (`float`, *optional*, defaults to 0.5):
+ Probability that transformer feature is replaced by quantized feature for pretraining.
+
+ Example:
+
+ ```python
+ >>> from transformers import UniSpeechConfig, UniSpeechModel
+
+ >>> # Initializing a UniSpeech facebook/unispeech-base-960h style configuration
+ >>> configuration = UniSpeechConfig()
+
+ >>> # Initializing a model (with random weights) from the facebook/unispeech-base-960h style configuration
+ >>> model = UniSpeechModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "unispeech"
+
+ vocab_size: int = 32
+ hidden_size: int = 768
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ intermediate_size: int = 3072
+ hidden_act: str = "gelu"
+ hidden_dropout: float | int = 0.1
+ activation_dropout: float | int = 0.1
+ attention_dropout: float | int = 0.1
+ feat_proj_dropout: float | int = 0.0
+ feat_quantizer_dropout: float | int = 0.0
+ final_dropout: float | int = 0.1
+ layerdrop: float | int = 0.1
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-5
+ feat_extract_norm: str = "group"
+ feat_extract_activation: str = "gelu"
+ conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)
+ conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)
+ conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)
+ conv_bias: bool = False
+ num_conv_pos_embeddings: int = 128
+ num_conv_pos_embedding_groups: int = 16
+ do_stable_layer_norm: bool = False
+ apply_spec_augment: bool = True
+ mask_time_prob: float | int = 0.05
+ mask_time_length: int = 10
+ mask_time_min_masks: int = 2
+ mask_feature_prob: float | int = 0.0
+ mask_feature_length: int = 10
+ mask_feature_min_masks: int = 0
+ num_codevectors_per_group: int = 320
+ num_codevector_groups: int = 2
+ contrastive_logits_temperature: float = 0.1
+ num_negatives: int = 100
+ codevector_dim: int = 256
+ proj_codevector_dim: int = 256
+ diversity_loss_weight: float = 0.1
+ ctc_loss_reduction: str = "mean"
+ ctc_zero_infinity: bool = False
+ use_weighted_layer_sum: bool = False
+ classifier_proj_size: int = 256
+ num_ctc_classes: int = 80
+ pad_token_id: int | None = 0
+ bos_token_id: int | None = 1
+ eos_token_id: int | list[int] | None = 2
+ replace_prob: float | int = 0.5
+
+ def __post_init__(self, **kwargs):
+ self.num_feat_extract_layers = len(self.conv_dim)
+ return super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if (
+ (len(self.conv_stride) != self.num_feat_extract_layers)
+ or (len(self.conv_kernel) != self.num_feat_extract_layers)
+ or (len(self.conv_dim) != self.num_feat_extract_layers)
+ ):
+ raise ValueError(
+ "Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="
+ " `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="
+ f" {len(self.conv_dim)}`, `len(config.conv_stride) = {len(self.conv_stride)}`,"
+ f" `len(config.conv_kernel) = {len(self.conv_kernel)}`."
+ )
+
+ @property
+ def inputs_to_logits_ratio(self):
+ return functools.reduce(operator.mul, self.conv_stride, 1)
+
+
+__all__ = ["UniSpeechConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech/modeling_unispeech.py b/lib/python3.11/site-packages/transformers/models/unispeech/modeling_unispeech.py
new file mode 100644
index 0000000000000000000000000000000000000000..03103760140cec029b7b05df423cd17d73950ad2
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/unispeech/modeling_unispeech.py
@@ -0,0 +1,1439 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/unispeech/modular_unispeech.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_unispeech.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2021 The Fairseq Authors and the HuggingFace Inc. 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 math
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.nn import CrossEntropyLoss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...integrations.deepspeed import is_deepspeed_zero3_enabled
+from ...integrations.fsdp import is_fsdp_managed_module
+from ...masking_utils import create_bidirectional_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ CausalLMOutput,
+ ModelOutput,
+ SequenceClassifierOutput,
+ Wav2Vec2BaseModelOutput,
+)
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel, get_torch_context_manager_or_global_device
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, logging
+from .configuration_unispeech import UniSpeechConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(
+ custom_intro="""
+ Output type of [`UniSpeechForPreTrainingOutput`], with potential hidden states and attentions.
+ """
+)
+@dataclass
+class UniSpeechForPreTrainingOutput(ModelOutput):
+ r"""
+ loss (*optional*, returned when model is in train mode, `torch.FloatTensor` of shape `(1,)`):
+ Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the [official
+ paper](https://huggingface.co/papers/2006.11477).
+ projected_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`):
+ Hidden-states of the model projected to *config.proj_codevector_dim* that can be used to predict the masked
+ projected quantized states.
+ projected_quantized_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`):
+ Quantized extracted feature vectors projected to *config.proj_codevector_dim* representing the positive
+ target vectors for contrastive loss.
+ codevector_perplexity (`torch.FloatTensor` of shape `(1,)`):
+ The perplexity of the codevector distribution, used to measure the diversity of the codebook.
+ """
+
+ loss: torch.FloatTensor | None = None
+ projected_states: torch.FloatTensor | None = None
+ projected_quantized_states: torch.FloatTensor | None = None
+ codevector_perplexity: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+class UniSpeechSamePadLayer(nn.Module):
+ def __init__(self, num_conv_pos_embeddings):
+ super().__init__()
+ self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else 0
+
+ def forward(self, hidden_states):
+ if self.num_pad_remove > 0:
+ hidden_states = hidden_states[:, :, : -self.num_pad_remove]
+ return hidden_states
+
+
+class UniSpeechPositionalConvEmbedding(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.conv = nn.Conv1d(
+ config.hidden_size,
+ config.hidden_size,
+ kernel_size=config.num_conv_pos_embeddings,
+ padding=config.num_conv_pos_embeddings // 2,
+ groups=config.num_conv_pos_embedding_groups,
+ )
+
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ if is_deepspeed_zero3_enabled():
+ import deepspeed
+
+ with deepspeed.zero.GatheredParameters(self.conv.weight, modifier_rank=0):
+ self.conv = weight_norm(self.conv, name="weight", dim=2)
+ if hasattr(self.conv, "parametrizations"):
+ weight_g = self.conv.parametrizations.weight.original0
+ weight_v = self.conv.parametrizations.weight.original1
+ else:
+ weight_g = self.conv.weight_g
+ weight_v = self.conv.weight_v
+ deepspeed.zero.register_external_parameter(self, weight_v)
+ deepspeed.zero.register_external_parameter(self, weight_g)
+ else:
+ self.conv = weight_norm(self.conv, name="weight", dim=2)
+
+ self.padding = UniSpeechSamePadLayer(config.num_conv_pos_embeddings)
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ def forward(self, hidden_states):
+ hidden_states = hidden_states.transpose(1, 2)
+
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.padding(hidden_states)
+ hidden_states = self.activation(hidden_states)
+
+ hidden_states = hidden_states.transpose(1, 2)
+ return hidden_states
+
+
+class UniSpeechNoLayerNormConvLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.conv_dim[layer_id - 1] if layer_id > 0 else 1
+ self.out_conv_dim = config.conv_dim[layer_id]
+
+ self.conv = nn.Conv1d(
+ self.in_conv_dim,
+ self.out_conv_dim,
+ kernel_size=config.conv_kernel[layer_id],
+ stride=config.conv_stride[layer_id],
+ bias=config.conv_bias,
+ )
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+class UniSpeechLayerNormConvLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.conv_dim[layer_id - 1] if layer_id > 0 else 1
+ self.out_conv_dim = config.conv_dim[layer_id]
+
+ self.conv = nn.Conv1d(
+ self.in_conv_dim,
+ self.out_conv_dim,
+ kernel_size=config.conv_kernel[layer_id],
+ stride=config.conv_stride[layer_id],
+ bias=config.conv_bias,
+ )
+ self.layer_norm = nn.LayerNorm(self.out_conv_dim, elementwise_affine=True)
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+
+ hidden_states = hidden_states.transpose(-2, -1)
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = hidden_states.transpose(-2, -1)
+
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+class UniSpeechGroupNormConvLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.conv_dim[layer_id - 1] if layer_id > 0 else 1
+ self.out_conv_dim = config.conv_dim[layer_id]
+
+ self.conv = nn.Conv1d(
+ self.in_conv_dim,
+ self.out_conv_dim,
+ kernel_size=config.conv_kernel[layer_id],
+ stride=config.conv_stride[layer_id],
+ bias=config.conv_bias,
+ )
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ self.layer_norm = nn.GroupNorm(num_groups=self.out_conv_dim, num_channels=self.out_conv_dim, affine=True)
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+class UniSpeechFeatureEncoder(nn.Module):
+ """Construct the features from raw audio waveform"""
+
+ def __init__(self, config):
+ super().__init__()
+
+ if config.feat_extract_norm == "group":
+ conv_layers = [UniSpeechGroupNormConvLayer(config, layer_id=0)] + [
+ UniSpeechNoLayerNormConvLayer(config, layer_id=i + 1)
+ for i in range(config.num_feat_extract_layers - 1)
+ ]
+ elif config.feat_extract_norm == "layer":
+ conv_layers = [
+ UniSpeechLayerNormConvLayer(config, layer_id=i) for i in range(config.num_feat_extract_layers)
+ ]
+ else:
+ raise ValueError(
+ f"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group', 'layer']"
+ )
+ self.conv_layers = nn.ModuleList(conv_layers)
+ self.gradient_checkpointing = False
+ self._requires_grad = True
+
+ def _freeze_parameters(self):
+ for param in self.parameters():
+ param.requires_grad = False
+ self._requires_grad = False
+
+ def forward(self, input_values):
+ hidden_states = input_values[:, None]
+
+ # make sure hidden_states require grad for gradient_checkpointing
+ if self._requires_grad and self.training:
+ hidden_states.requires_grad = True
+
+ for conv_layer in self.conv_layers:
+ hidden_states = conv_layer(hidden_states)
+
+ return hidden_states
+
+
+class UniSpeechFeatureProjection(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.layer_norm = nn.LayerNorm(config.conv_dim[-1], eps=config.layer_norm_eps)
+ self.projection = nn.Linear(config.conv_dim[-1], config.hidden_size)
+ self.dropout = nn.Dropout(config.feat_proj_dropout)
+
+ def forward(self, hidden_states):
+ # non-projected hidden states are needed for quantization
+ norm_hidden_states = self.layer_norm(hidden_states)
+ hidden_states = self.projection(norm_hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return hidden_states, norm_hidden_states
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float | None = None,
+ dropout: float = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ if scaling is None:
+ scaling = query.size(-1) ** -0.5
+
+ # Take the dot product between "query" and "key" to get the raw attention scores.
+ attn_weights = torch.matmul(query, key.transpose(2, 3)) * scaling
+
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+class UniSpeechAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(
+ self,
+ embed_dim: int,
+ num_heads: int,
+ dropout: float = 0.0,
+ is_decoder: bool = False,
+ bias: bool = True,
+ is_causal: bool = False,
+ config: UniSpeechConfig | None = None,
+ ):
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.num_heads = num_heads
+ self.dropout = dropout
+ self.head_dim = embed_dim // num_heads
+ self.config = config
+
+ if (self.head_dim * num_heads) != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}"
+ f" and `num_heads`: {num_heads})."
+ )
+ self.scaling = self.head_dim**-0.5
+ self.is_decoder = is_decoder
+ self.is_causal = is_causal
+
+ self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ key_value_states: torch.Tensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = False,
+ # TODO: we need a refactor so that the different attention modules can get their specific kwargs
+ # ATM, we have mixed things encoder, decoder, and encoder-decoder attn
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ """Input shape: Batch x Time x Channel"""
+
+ # if key_value_states are provided this layer is used as a cross-attention layer
+ # for the decoder
+ is_cross_attention = key_value_states is not None
+
+ # determine input shapes
+ input_shape = hidden_states.shape[:-1]
+
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ # get query proj
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ current_states = key_value_states if is_cross_attention else hidden_states
+ kv_shape = (*current_states.shape[:-1], -1, self.head_dim)
+ key_states = self.k_proj(current_states).view(kv_shape).transpose(1, 2)
+ value_states = self.v_proj(current_states).view(kv_shape).transpose(1, 2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=0.0 if not self.training else self.dropout,
+ scaling=self.scaling,
+ output_attentions=output_attentions,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights, None
+
+
+class UniSpeechFeedForward(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.intermediate_dropout = nn.Dropout(config.activation_dropout)
+
+ self.intermediate_dense = nn.Linear(config.hidden_size, config.intermediate_size)
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ self.output_dense = nn.Linear(config.intermediate_size, config.hidden_size)
+ self.output_dropout = nn.Dropout(config.hidden_dropout)
+
+ def forward(self, hidden_states):
+ hidden_states = self.intermediate_dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ hidden_states = self.intermediate_dropout(hidden_states)
+
+ hidden_states = self.output_dense(hidden_states)
+ hidden_states = self.output_dropout(hidden_states)
+ return hidden_states
+
+
+class UniSpeechEncoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config):
+ super().__init__()
+ self.attention = UniSpeechAttention(
+ embed_dim=config.hidden_size,
+ num_heads=config.num_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=False,
+ config=config,
+ )
+
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.feed_forward = UniSpeechFeedForward(config)
+ self.final_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ def forward(self, hidden_states, attention_mask=None, output_attentions=False):
+ attn_residual = hidden_states
+ hidden_states, attn_weights, _ = self.attention(
+ hidden_states, attention_mask=attention_mask, output_attentions=output_attentions
+ )
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = attn_residual + hidden_states
+
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = hidden_states + self.feed_forward(hidden_states)
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (attn_weights,)
+
+ return outputs
+
+
+class UniSpeechEncoder(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.pos_conv_embed = UniSpeechPositionalConvEmbedding(config)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layers = nn.ModuleList([UniSpeechEncoderLayer(config) for _ in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states: torch.tensor,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ output_hidden_states: bool = False,
+ return_dict: bool = True,
+ ):
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ if attention_mask is not None:
+ # make sure padded tokens output 0
+ expand_attention_mask = attention_mask.unsqueeze(-1).repeat(1, 1, hidden_states.shape[2])
+ hidden_states[~expand_attention_mask] = 0
+
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ )
+
+ position_embeddings = self.pos_conv_embed(hidden_states)
+ hidden_states = hidden_states + position_embeddings.to(hidden_states.device)
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ synced_gpus = is_deepspeed_zero3_enabled() or is_fsdp_managed_module(self)
+
+ for layer in self.layers:
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ dropout_probability = torch.rand([])
+
+ skip_the_layer = self.training and dropout_probability < self.config.layerdrop
+ if not skip_the_layer or synced_gpus:
+ # under fsdp or deepspeed zero3 all gpus must run in sync
+ layer_outputs = layer(
+ hidden_states, attention_mask=attention_mask, output_attentions=output_attentions
+ )
+ hidden_states = layer_outputs[0]
+
+ if skip_the_layer:
+ layer_outputs = (None, None)
+
+ if output_attentions:
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+
+class UniSpeechAttnAdapterLayer(nn.Module):
+ def __init__(self, config):
+ """
+ Implements adapter modules directly with 3D tensor weight as parameters and without using ModuleList to speed
+ up training throughput.
+ """
+ super().__init__()
+ self.input_dim = config.adapter_attn_dim
+ self.hidden_dim = config.hidden_size
+
+ self.norm = nn.LayerNorm(self.hidden_dim)
+ self.linear_1 = nn.Linear(self.hidden_dim, self.input_dim)
+ self.act_fn = nn.ReLU()
+ self.linear_2 = nn.Linear(self.input_dim, self.hidden_dim)
+
+ def forward(self, hidden_states: torch.FloatTensor):
+ hidden_states = self.norm(hidden_states)
+
+ hidden_states = self.linear_1(hidden_states)
+ hidden_states = self.act_fn(hidden_states)
+ hidden_states = self.linear_2(hidden_states)
+
+ return hidden_states
+
+
+class UniSpeechEncoderLayerStableLayerNorm(GradientCheckpointingLayer):
+ def __init__(self, config):
+ super().__init__()
+ self.attention = UniSpeechAttention(
+ embed_dim=config.hidden_size,
+ num_heads=config.num_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=False,
+ config=config,
+ )
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.feed_forward = UniSpeechFeedForward(config)
+ self.final_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ if getattr(config, "adapter_attn_dim", None) is not None:
+ self.adapter_layer = UniSpeechAttnAdapterLayer(config)
+ else:
+ self.adapter_layer = None
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ ):
+ attn_residual = hidden_states
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states, attn_weights, _ = self.attention(
+ hidden_states, attention_mask=attention_mask, output_attentions=output_attentions
+ )
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = attn_residual + hidden_states
+ hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states))
+
+ if self.adapter_layer is not None:
+ hidden_states = hidden_states + self.adapter_layer(hidden_states)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (attn_weights,)
+
+ return outputs
+
+
+class UniSpeechEncoderStableLayerNorm(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.pos_conv_embed = UniSpeechPositionalConvEmbedding(config)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layers = nn.ModuleList(
+ [UniSpeechEncoderLayerStableLayerNorm(config) for _ in range(config.num_hidden_layers)]
+ )
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ output_attentions=False,
+ output_hidden_states=False,
+ return_dict=True,
+ ):
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ if attention_mask is not None:
+ # make sure padded tokens output 0
+ expand_attention_mask = attention_mask.unsqueeze(-1).repeat(1, 1, hidden_states.shape[2])
+ hidden_states[~expand_attention_mask] = 0
+
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ )
+
+ position_embeddings = self.pos_conv_embed(hidden_states)
+ hidden_states = hidden_states + position_embeddings
+ hidden_states = self.dropout(hidden_states)
+
+ synced_gpus = is_deepspeed_zero3_enabled() or is_fsdp_managed_module(self)
+
+ for layer in self.layers:
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ dropout_probability = torch.rand([])
+
+ skip_the_layer = self.training and dropout_probability < self.config.layerdrop
+ if not skip_the_layer or synced_gpus:
+ # under fsdp or deepspeed zero3 all gpus must run in sync
+ # XXX: could optimize this like synced_gpus in generate_utils but not sure if it's worth the code complication
+ layer_outputs = layer(
+ hidden_states, attention_mask=attention_mask, output_attentions=output_attentions
+ )
+ hidden_states = layer_outputs[0]
+
+ if skip_the_layer:
+ layer_outputs = (None, None)
+
+ if output_attentions:
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+ hidden_states = self.layer_norm(hidden_states)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+
+class UniSpeechGumbelVectorQuantizer(nn.Module):
+ """
+ Vector quantization using gumbel softmax. See `[CATEGORICAL REPARAMETERIZATION WITH
+ GUMBEL-SOFTMAX](https://huggingface.co/papers/1611.01144) for more information.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ self.num_groups = config.num_codevector_groups
+ self.num_vars = config.num_codevectors_per_group
+
+ if config.codevector_dim % self.num_groups != 0:
+ raise ValueError(
+ f"`config.codevector_dim {config.codevector_dim} must be divisible "
+ f"by `config.num_codevector_groups` {self.num_groups} for concatenation"
+ )
+
+ # storage for codebook variables (codewords)
+ self.codevectors = nn.Parameter(
+ torch.FloatTensor(1, self.num_groups * self.num_vars, config.codevector_dim // self.num_groups)
+ )
+ self.weight_proj = nn.Linear(config.conv_dim[-1], self.num_groups * self.num_vars)
+
+ # can be decayed for training
+ self.temperature = 2
+
+ @staticmethod
+ def _compute_perplexity(probs):
+ marginal_probs = probs.mean(dim=0)
+ perplexity = torch.exp(-torch.sum(torch.xlogy(marginal_probs, marginal_probs), dim=-1)).sum()
+ return perplexity
+
+ def forward(self, hidden_states):
+ batch_size, sequence_length, hidden_size = hidden_states.shape
+
+ # project to codevector dim
+ hidden_states = self.weight_proj(hidden_states)
+ hidden_states = hidden_states.view(batch_size * sequence_length * self.num_groups, -1)
+
+ if self.training:
+ # sample code vector probs via gumbel in differentiateable way
+ codevector_probs = nn.functional.gumbel_softmax(
+ hidden_states.float(), tau=self.temperature, hard=True
+ ).type_as(hidden_states)
+
+ # compute perplexity
+ codevector_soft_dist = torch.softmax(
+ hidden_states.view(batch_size * sequence_length, self.num_groups, -1).float(), dim=-1
+ )
+ perplexity = self._compute_perplexity(codevector_soft_dist)
+ else:
+ # take argmax in non-differentiable way
+ # comptute hard codevector distribution (one hot)
+ codevector_idx = hidden_states.argmax(dim=-1)
+ codevector_probs = hidden_states.new_zeros(*hidden_states.shape).scatter_(
+ -1, codevector_idx.view(-1, 1), 1.0
+ )
+ codevector_probs = codevector_probs.view(batch_size * sequence_length, self.num_groups, -1)
+
+ perplexity = self._compute_perplexity(codevector_probs)
+
+ codevector_probs = codevector_probs.view(batch_size * sequence_length, -1)
+ # use probs to retrieve codevectors
+ codevectors_per_group = codevector_probs.unsqueeze(-1) * self.codevectors
+ codevectors = codevectors_per_group.view(batch_size * sequence_length, self.num_groups, self.num_vars, -1)
+ codevectors = codevectors.sum(-2).view(batch_size, sequence_length, -1)
+
+ return codevectors, perplexity
+
+
+@auto_docstring
+class UniSpeechPreTrainedModel(PreTrainedModel):
+ config: UniSpeechConfig
+ base_model_prefix = "unispeech"
+ main_input_name = "input_values"
+ input_modalities = "audio"
+ supports_gradient_checkpointing = True
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ # gumbel softmax requires special init
+ if isinstance(module, UniSpeechGumbelVectorQuantizer):
+ init.normal_(module.weight_proj.weight, mean=0.0, std=1)
+ init.zeros_(module.weight_proj.bias)
+ init.uniform_(module.codevectors)
+ elif isinstance(module, UniSpeechPositionalConvEmbedding):
+ init.normal_(
+ module.conv.weight,
+ mean=0,
+ std=2 * math.sqrt(1 / (module.conv.kernel_size[0] * module.conv.in_channels)),
+ )
+ init.constant_(module.conv.bias, 0)
+ elif isinstance(module, UniSpeechFeatureProjection):
+ k = math.sqrt(1 / module.projection.in_features)
+ init.uniform_(module.projection.weight, a=-k, b=k)
+ init.uniform_(module.projection.bias, a=-k, b=k)
+ elif isinstance(module, nn.Linear):
+ init.normal_(module.weight, mean=0.0, std=self.config.initializer_range)
+
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, (nn.LayerNorm, nn.GroupNorm)):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ elif isinstance(module, nn.Conv1d):
+ init.kaiming_normal_(module.weight)
+
+ if module.bias is not None:
+ k = math.sqrt(module.groups / (module.in_channels * module.kernel_size[0]))
+ init.uniform_(module.bias, a=-k, b=k)
+
+ def _get_feat_extract_output_lengths(self, input_lengths: torch.LongTensor | int):
+ """
+ Computes the output length of the convolutional layers
+ """
+
+ def _conv_out_length(input_length, kernel_size, stride):
+ # 1D convolutional layer output length formula taken
+ # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html
+ return torch.div(input_length - kernel_size, stride, rounding_mode="floor") + 1
+
+ for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride):
+ input_lengths = _conv_out_length(input_lengths, kernel_size, stride)
+
+ return input_lengths
+
+ def _get_feature_vector_attention_mask(self, feature_vector_length: int, attention_mask: torch.LongTensor):
+ # Effectively attention_mask.sum(-1), but not inplace to be able to run
+ # on inference mode.
+ non_padded_lengths = attention_mask.cumsum(dim=-1)[:, -1]
+ output_lengths = self._get_feat_extract_output_lengths(non_padded_lengths).to(torch.long)
+ batch_size = attention_mask.shape[0]
+
+ attention_mask = torch.zeros(
+ (batch_size, feature_vector_length), dtype=attention_mask.dtype, device=attention_mask.device
+ )
+ # these two operations makes sure that all values before the output lengths idxs are attended to
+ attention_mask[(torch.arange(attention_mask.shape[0], device=attention_mask.device), output_lengths - 1)] = 1
+ attention_mask = attention_mask.flip([-1]).cumsum(-1).flip([-1]).bool()
+ return attention_mask
+
+
+def _compute_mask_indices(
+ shape: tuple[int, int],
+ mask_prob: float,
+ mask_length: int,
+ attention_mask: torch.LongTensor | None = None,
+ min_masks: int = 0,
+) -> np.ndarray:
+ """
+ Computes random mask spans for a given shape. Used to implement [SpecAugment: A Simple Data Augmentation Method for
+ ASR](https://huggingface.co/papers/1904.08779). Note that this method is not optimized to run on TPU and should be run on
+ CPU as part of the preprocessing during training.
+
+ Args:
+ shape: The shape for which to compute masks. This should be of a tuple of size 2 where
+ the first element is the batch size and the second element is the length of the axis to span.
+ mask_prob: The percentage of the whole axis (between 0 and 1) which will be masked. The number of
+ independently generated mask spans of length `mask_length` is computed by
+ `mask_prob*shape[1]/mask_length`. Note that due to overlaps, `mask_prob` is an upper bound and the
+ actual percentage will be smaller.
+ mask_length: size of the mask
+ min_masks: minimum number of masked spans
+ attention_mask: A (right-padded) attention mask which independently shortens the feature axis of
+ each batch dimension.
+ """
+ batch_size, sequence_length = shape
+
+ if mask_length < 1:
+ raise ValueError("`mask_length` has to be bigger than 0.")
+
+ if mask_length > sequence_length:
+ raise ValueError(
+ f"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length}"
+ f" and `sequence_length`: {sequence_length}`"
+ )
+
+ # epsilon is used for probabilistic rounding
+ epsilon = np.random.rand(1).item()
+
+ def compute_num_masked_span(input_length):
+ """Given input length, compute how many spans should be masked"""
+ num_masked_span = int(mask_prob * input_length / mask_length + epsilon)
+ num_masked_span = max(num_masked_span, min_masks)
+
+ # make sure num masked span <= sequence_length
+ if num_masked_span * mask_length > sequence_length:
+ num_masked_span = sequence_length // mask_length
+
+ # make sure num_masked span is also <= input_length - (mask_length - 1)
+ if input_length - (mask_length - 1) < num_masked_span:
+ num_masked_span = max(input_length - (mask_length - 1), 0)
+
+ return num_masked_span
+
+ # compute number of masked spans in batch
+ input_lengths = (
+ attention_mask.detach().sum(-1).tolist()
+ if attention_mask is not None
+ else [sequence_length for _ in range(batch_size)]
+ )
+
+ # SpecAugment mask to fill
+ spec_aug_mask = np.zeros((batch_size, sequence_length), dtype=bool)
+ spec_aug_mask_idxs = []
+
+ max_num_masked_span = compute_num_masked_span(sequence_length)
+
+ if max_num_masked_span == 0:
+ return spec_aug_mask
+
+ for input_length in input_lengths:
+ # compute num of masked spans for this input
+ num_masked_span = compute_num_masked_span(input_length)
+
+ # get random indices to mask
+ spec_aug_mask_idx = np.random.choice(
+ np.arange(input_length - (mask_length - 1)), num_masked_span, replace=False
+ )
+
+ # pick first sampled index that will serve as a dummy index to pad vector
+ # to ensure same dimension for all batches due to probabilistic rounding
+ # Picking first sample just pads those vectors twice.
+ if len(spec_aug_mask_idx) == 0:
+ # this case can only happen if `input_length` is strictly smaller then
+ # `sequence_length` in which case the last token has to be a padding
+ # token which we can use as a dummy mask id
+ dummy_mask_idx = sequence_length - 1
+ else:
+ dummy_mask_idx = spec_aug_mask_idx[0]
+
+ spec_aug_mask_idx = np.concatenate(
+ [spec_aug_mask_idx, np.ones(max_num_masked_span - num_masked_span, dtype=np.int32) * dummy_mask_idx]
+ )
+ spec_aug_mask_idxs.append(spec_aug_mask_idx)
+
+ spec_aug_mask_idxs = np.array(spec_aug_mask_idxs)
+
+ # expand masked indices to masked spans
+ spec_aug_mask_idxs = np.broadcast_to(
+ spec_aug_mask_idxs[:, :, None], (batch_size, max_num_masked_span, mask_length)
+ )
+ spec_aug_mask_idxs = spec_aug_mask_idxs.reshape(batch_size, max_num_masked_span * mask_length)
+
+ # add offset to the starting indexes so that indexes now create a span
+ offsets = np.arange(mask_length)[None, None, :]
+ offsets = np.broadcast_to(offsets, (batch_size, max_num_masked_span, mask_length)).reshape(
+ batch_size, max_num_masked_span * mask_length
+ )
+ spec_aug_mask_idxs = spec_aug_mask_idxs + offsets
+
+ # ensure that we cannot have indices larger than sequence_length
+ if spec_aug_mask_idxs.max() > sequence_length - 1:
+ spec_aug_mask_idxs[spec_aug_mask_idxs > sequence_length - 1] = sequence_length - 1
+
+ # scatter indices to mask
+ np.put_along_axis(spec_aug_mask, spec_aug_mask_idxs, 1, -1)
+
+ return spec_aug_mask
+
+
+UniSpeechBaseModelOutput = Wav2Vec2BaseModelOutput
+
+
+@auto_docstring
+class UniSpeechModel(UniSpeechPreTrainedModel):
+ def __init__(self, config: UniSpeechConfig):
+ super().__init__(config)
+ self.config = config
+ self.feature_extractor = UniSpeechFeatureEncoder(config)
+ self.feature_projection = UniSpeechFeatureProjection(config)
+
+ if config.mask_time_prob > 0.0 or config.mask_feature_prob > 0.0:
+ self.masked_spec_embed = nn.Parameter(torch.Tensor(config.hidden_size).uniform_())
+
+ if config.do_stable_layer_norm:
+ self.encoder = UniSpeechEncoderStableLayerNorm(config)
+ else:
+ self.encoder = UniSpeechEncoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _mask_hidden_states(
+ self,
+ hidden_states: torch.FloatTensor,
+ mask_time_indices: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ ):
+ """
+ Masks extracted features along time axis and/or along feature axis according to
+ [SpecAugment](https://huggingface.co/papers/1904.08779).
+ """
+
+ # `config.apply_spec_augment` can set masking to False
+ if not getattr(self.config, "apply_spec_augment", True):
+ return hidden_states
+
+ # generate indices & apply SpecAugment along time axis
+ batch_size, sequence_length, hidden_size = hidden_states.size()
+
+ if mask_time_indices is not None:
+ # apply SpecAugment along time axis with given mask_time_indices
+ hidden_states[mask_time_indices] = self.masked_spec_embed.to(hidden_states.dtype)
+ elif self.config.mask_time_prob > 0 and self.training:
+ mask_time_indices = _compute_mask_indices(
+ (batch_size, sequence_length),
+ mask_prob=self.config.mask_time_prob,
+ mask_length=self.config.mask_time_length,
+ attention_mask=attention_mask,
+ min_masks=self.config.mask_time_min_masks,
+ )
+ mask_time_indices = torch.tensor(mask_time_indices, device=hidden_states.device, dtype=torch.bool)
+ hidden_states[mask_time_indices] = self.masked_spec_embed.to(hidden_states.dtype)
+
+ if self.config.mask_feature_prob > 0 and self.training:
+ # generate indices & apply SpecAugment along feature axis
+ mask_feature_indices = _compute_mask_indices(
+ (batch_size, hidden_size),
+ mask_prob=self.config.mask_feature_prob,
+ mask_length=self.config.mask_feature_length,
+ min_masks=self.config.mask_feature_min_masks,
+ )
+ mask_feature_indices = torch.tensor(mask_feature_indices, device=hidden_states.device, dtype=torch.bool)
+ mask_feature_indices = mask_feature_indices[:, None].expand(-1, sequence_length, -1)
+ hidden_states[mask_feature_indices] = 0
+
+ return hidden_states
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ mask_time_indices: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | UniSpeechBaseModelOutput:
+ r"""
+ mask_time_indices (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices to mask extracted features for contrastive loss. When in training mode, model learns to predict
+ masked extracted features in *config.proj_codevector_dim* space.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ extract_features = self.feature_extractor(input_values)
+ extract_features = extract_features.transpose(1, 2)
+
+ if attention_mask is not None:
+ # compute reduced attention_mask corresponding to feature vectors
+ attention_mask = self._get_feature_vector_attention_mask(extract_features.shape[1], attention_mask)
+
+ hidden_states, extract_features = self.feature_projection(extract_features)
+ hidden_states = self._mask_hidden_states(
+ hidden_states, mask_time_indices=mask_time_indices, attention_mask=attention_mask
+ )
+
+ encoder_outputs = self.encoder(
+ hidden_states,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ if not return_dict:
+ return (hidden_states, extract_features) + encoder_outputs[1:]
+
+ return UniSpeechBaseModelOutput(
+ last_hidden_state=hidden_states,
+ extract_features=extract_features,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ UniSpeech Model with a vector-quantization module and ctc loss for pre-training.
+ """
+)
+class UniSpeechForPreTraining(UniSpeechPreTrainedModel):
+ def __init__(self, config: UniSpeechConfig):
+ super().__init__(config)
+ self.unispeech = UniSpeechModel(config)
+ self.dropout_features = nn.Dropout(config.feat_quantizer_dropout)
+
+ self.quantizer = UniSpeechGumbelVectorQuantizer(config)
+ self.project_q = nn.Linear(config.codevector_dim, config.proj_codevector_dim)
+ self.project_hid = nn.Linear(config.proj_codevector_dim, config.hidden_size)
+
+ self.ctc_proj = nn.Linear(config.hidden_size, config.num_ctc_classes)
+ self.dropout = nn.Dropout(config.final_dropout)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def set_gumbel_temperature(self, temperature: int):
+ """
+ Set the Gumbel softmax temperature to a given value. Only necessary for training
+ """
+ self.quantizer.temperature = temperature
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech.feature_extractor._freeze_parameters()
+
+ @staticmethod
+ def compute_contrastive_logits(
+ target_features: torch.FloatTensor,
+ negative_features: torch.FloatTensor,
+ predicted_features: torch.FloatTensor,
+ temperature: int = 1,
+ ):
+ """
+ Compute logits for contrastive loss based using cosine similarity as the distance measure between
+ `[positive_feature, negative_features]` and `[predicted_features]`. Additionally, temperature can be applied.
+ """
+ target_features = torch.cat([target_features, negative_features], dim=0)
+
+ logits = torch.cosine_similarity(predicted_features.float(), target_features.float(), dim=-1)
+ logits = logits.type_as(target_features)
+
+ # apply temperature
+ logits = logits / temperature
+ return logits
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | UniSpeechForPreTrainingOutput:
+ r"""
+ Example:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoFeatureExtractor, UniSpeechForPreTraining
+
+ >>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-large-1500h-cv")
+ >>> model = UniSpeechForPreTraining.from_pretrained("microsoft/unispeech-large-1500h-cv")
+ >>> # TODO: Add full pretraining example
+ ```"""
+
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.unispeech(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ transformer_features = outputs[0]
+
+ # quantize all (unmasked) extracted features and project to final vq dim
+ extract_features = self.dropout_features(outputs[1])
+ quantized_features, codevector_perplexity = self.quantizer(extract_features)
+
+ # project quantized features twice
+ quantized_features = self.project_q(quantized_features.to(self.project_q.weight.dtype))
+ quantized_features = self.project_hid(quantized_features)
+
+ prob_replace_matrix = torch.empty(transformer_features.size(0), transformer_features.size(1)).fill_(
+ self.config.replace_prob
+ )
+ prob_replace_matrix = prob_replace_matrix.transpose(0, 1)
+ sampled_replace_matrix = torch.bernoulli(prob_replace_matrix).bool().to(transformer_features.device)
+ sampled_replace_matrix = sampled_replace_matrix.transpose(0, 1)
+ sampled_replace_matrix = sampled_replace_matrix.unsqueeze(-1)
+ logits = transformer_features.masked_fill(sampled_replace_matrix, 0.0) + (
+ quantized_features.masked_fill(~sampled_replace_matrix, 0.0)
+ )
+
+ # project to ctc units
+ logits = self.dropout(logits)
+ logits = self.ctc_proj(logits)
+
+ # TODO(PVP) - add negative sampling & loss computation
+ loss = None
+ if not return_dict:
+ if loss is not None:
+ return (loss, transformer_features, quantized_features, codevector_perplexity) + outputs[2:]
+ return (transformer_features, quantized_features, codevector_perplexity) + outputs[2:]
+
+ return UniSpeechForPreTrainingOutput(
+ loss=loss,
+ projected_states=transformer_features,
+ projected_quantized_states=quantized_features,
+ codevector_perplexity=codevector_perplexity,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+_HIDDEN_STATES_START_POSITION = 2
+
+
+@auto_docstring(
+ custom_intro="""
+ UniSpeech Model with a `language modeling` head on top for Connectionist Temporal Classification (CTC).
+ """
+)
+class UniSpeechForCTC(UniSpeechPreTrainedModel):
+ def __init__(self, config, target_lang: str | None = None):
+ r"""
+ target_lang (`str`, *optional*):
+ Language id of adapter weights. Adapter weights are stored in the format adapter.<lang>.safetensors or
+ adapter.<lang>.bin. Only relevant when using an instance of [`UniSpeechForCTC`] with adapters. Uses 'eng' by
+ default.
+ """
+ super().__init__(config)
+
+ self.unispeech = UniSpeechModel(config)
+ self.dropout = nn.Dropout(config.final_dropout)
+
+ self.target_lang = target_lang
+
+ if config.vocab_size is None:
+ raise ValueError(
+ f"You are trying to instantiate {self.__class__} with a configuration that "
+ "does not define the vocabulary size of the language model head. Please "
+ "instantiate the model as follows: `UniSpeechForCTC.from_pretrained(..., vocab_size=vocab_size)`. "
+ "or define `vocab_size` of your model's configuration."
+ )
+ output_hidden_size = (
+ config.output_hidden_size if hasattr(config, "add_adapter") and config.add_adapter else config.hidden_size
+ )
+ self.lm_head = nn.Linear(output_hidden_size, config.vocab_size)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def tie_weights(self, **kwargs):
+ """
+ This method overwrites [`~PreTrainedModel.tie_weights`] so that adapter weights can be correctly loaded when
+ passing `target_lang=...` to `from_pretrained(...)`.
+
+ This method is **not** supposed to be called by the user and is prone to be changed in the future.
+ """
+
+ if get_torch_context_manager_or_global_device() == torch.device("meta"):
+ return
+
+ # Note that `tie_weights` is usually used to tie input and output embedding weights. The method is re-purposed to
+ # correctly load adapter layers for UniSpeech so that we do not have to introduce a new API to
+ # [`PreTrainedModel`]. While slightly hacky, UniSpeech never has to tie input and output embeddings, so that it is
+ # ok to repurpose this function here.
+ target_lang = self.target_lang
+
+ if target_lang is not None and getattr(self.config, "adapter_attn_dim", None) is None:
+ raise ValueError(f"Cannot pass `target_lang`: {target_lang} if `config.adapter_attn_dim` is not defined.")
+ elif target_lang is None and getattr(self.config, "adapter_attn_dim", None) is not None:
+ logger.info("By default `target_lang` is set to 'eng'.")
+ elif target_lang is not None:
+ self.load_adapter(target_lang, force_load=True)
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech.feature_extractor._freeze_parameters()
+
+ def freeze_base_model(self):
+ """
+ Calling this function will disable the gradient computation for the base model so that its parameters will not
+ be updated during training. Only the classification head will be updated.
+ """
+ for param in self.unispeech.parameters():
+ param.requires_grad = False
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ labels: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple | CausalLMOutput:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, target_length)`, *optional*):
+ Labels for connectionist temporal classification. Note that `target_length` has to be smaller or equal to
+ the sequence length of the output logits. Indices are selected in `[-100, 0, ..., config.vocab_size - 1]`.
+ All labels set to `-100` are ignored (masked), the loss is only computed for labels in `[0, ...,
+ config.vocab_size - 1]`.
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if labels is not None and labels.max() >= self.config.vocab_size:
+ raise ValueError(f"Label values must be <= vocab_size: {self.config.vocab_size}")
+
+ outputs = self.unispeech(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = outputs[0]
+ hidden_states = self.dropout(hidden_states)
+
+ logits = self.lm_head(hidden_states)
+
+ loss = None
+ if labels is not None:
+ # retrieve loss input_lengths from attention_mask
+ attention_mask = (
+ attention_mask if attention_mask is not None else torch.ones_like(input_values, dtype=torch.long)
+ )
+ input_lengths = self._get_feat_extract_output_lengths(attention_mask.sum(-1)).to(torch.long)
+
+ # assuming that padded tokens are filled with -100
+ # when not being attended to
+ labels_mask = labels >= 0
+ target_lengths = labels_mask.sum(-1)
+ flattened_targets = labels.masked_select(labels_mask)
+
+ # ctc_loss doesn't support fp16
+ log_probs = nn.functional.log_softmax(logits, dim=-1, dtype=torch.float32).transpose(0, 1)
+
+ with torch.backends.cudnn.flags(enabled=False):
+ loss = nn.functional.ctc_loss(
+ log_probs,
+ flattened_targets,
+ input_lengths,
+ target_lengths,
+ blank=self.config.pad_token_id,
+ reduction=self.config.ctc_loss_reduction,
+ zero_infinity=self.config.ctc_zero_infinity,
+ )
+
+ if not return_dict:
+ output = (logits,) + outputs[_HIDDEN_STATES_START_POSITION:]
+ return ((loss,) + output) if loss is not None else output
+
+ return CausalLMOutput(
+ loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ UniSpeech Model with a sequence classification head on top (a linear layer over the pooled output) for tasks like
+ SUPERB Keyword Spotting.
+ """
+)
+class UniSpeechForSequenceClassification(UniSpeechPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ if hasattr(config, "add_adapter") and config.add_adapter:
+ raise ValueError(
+ "Sequence classification does not support the use of UniSpeech adapters (config.add_adapter=True)"
+ )
+ self.unispeech = UniSpeechModel(config)
+ num_layers = config.num_hidden_layers + 1 # transformer layers + input embeddings
+ if config.use_weighted_layer_sum:
+ self.layer_weights = nn.Parameter(torch.ones(num_layers) / num_layers)
+ self.projector = nn.Linear(config.hidden_size, config.classifier_proj_size)
+ self.classifier = nn.Linear(config.classifier_proj_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech.feature_extractor._freeze_parameters()
+
+ def freeze_base_model(self):
+ """
+ Calling this function will disable the gradient computation for the base model so that its parameters will not
+ be updated during training. Only the classification head will be updated.
+ """
+ for param in self.unispeech.parameters():
+ param.requires_grad = False
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ labels: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple | SequenceClassifierOutput:
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Float values of input raw speech waveform. Values can be obtained by loading a `.flac` or `.wav` audio file
+ into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library
+ (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
+ To prepare the array into `input_values`, the [`AutoProcessor`] should be used for padding and conversion
+ into a tensor of type `torch.FloatTensor`. See [`UniSpeechProcessor.__call__`] for details.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = True if self.config.use_weighted_layer_sum else output_hidden_states
+
+ outputs = self.unispeech(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if self.config.use_weighted_layer_sum:
+ hidden_states = outputs[_HIDDEN_STATES_START_POSITION]
+ hidden_states = torch.stack(hidden_states, dim=1)
+ norm_weights = nn.functional.softmax(self.layer_weights, dim=-1)
+ hidden_states = (hidden_states * norm_weights.view(-1, 1, 1)).sum(dim=1)
+ else:
+ hidden_states = outputs[0]
+
+ hidden_states = self.projector(hidden_states)
+ if attention_mask is None:
+ pooled_output = hidden_states.mean(dim=1)
+ else:
+ padding_mask = self._get_feature_vector_attention_mask(hidden_states.shape[1], attention_mask)
+ expand_padding_mask = padding_mask.unsqueeze(-1).repeat(1, 1, hidden_states.shape[2])
+ hidden_states[~expand_padding_mask] = 0.0
+ pooled_output = hidden_states.sum(dim=1) / padding_mask.sum(dim=1).view(-1, 1)
+
+ logits = self.classifier(pooled_output)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.config.num_labels), labels.view(-1))
+
+ if not return_dict:
+ output = (logits,) + outputs[_HIDDEN_STATES_START_POSITION:]
+ return ((loss,) + output) if loss is not None else output
+
+ return SequenceClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "UniSpeechForCTC",
+ "UniSpeechForPreTraining",
+ "UniSpeechForSequenceClassification",
+ "UniSpeechModel",
+ "UniSpeechPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech/modular_unispeech.py b/lib/python3.11/site-packages/transformers/models/unispeech/modular_unispeech.py
new file mode 100644
index 0000000000000000000000000000000000000000..fce518d13a652f10a75a96f92f55d03823bcc6a6
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/unispeech/modular_unispeech.py
@@ -0,0 +1,432 @@
+# Copyright 2021 The Fairseq Authors and the HuggingFace Inc. 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.
+"""PyTorch UniSpeech model."""
+
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+
+from ... import initialization as init
+from ...modeling_outputs import ModelOutput, Wav2Vec2BaseModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring, logging
+from ..wav2vec2.modeling_wav2vec2 import (
+ Wav2Vec2Encoder,
+ Wav2Vec2EncoderStableLayerNorm,
+ Wav2Vec2FeatureEncoder,
+ Wav2Vec2FeatureProjection,
+ Wav2Vec2ForCTC,
+ Wav2Vec2ForSequenceClassification,
+ Wav2Vec2GumbelVectorQuantizer,
+ Wav2Vec2Model,
+ Wav2Vec2PositionalConvEmbedding,
+)
+from .configuration_unispeech import UniSpeechConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(
+ custom_intro="""
+ Output type of [`UniSpeechForPreTrainingOutput`], with potential hidden states and attentions.
+ """
+)
+@dataclass
+class UniSpeechForPreTrainingOutput(ModelOutput):
+ r"""
+ loss (*optional*, returned when model is in train mode, `torch.FloatTensor` of shape `(1,)`):
+ Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the [official
+ paper](https://huggingface.co/papers/2006.11477).
+ projected_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`):
+ Hidden-states of the model projected to *config.proj_codevector_dim* that can be used to predict the masked
+ projected quantized states.
+ projected_quantized_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`):
+ Quantized extracted feature vectors projected to *config.proj_codevector_dim* representing the positive
+ target vectors for contrastive loss.
+ codevector_perplexity (`torch.FloatTensor` of shape `(1,)`):
+ The perplexity of the codevector distribution, used to measure the diversity of the codebook.
+ """
+
+ loss: torch.FloatTensor | None = None
+ projected_states: torch.FloatTensor | None = None
+ projected_quantized_states: torch.FloatTensor | None = None
+ codevector_perplexity: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+class UniSpeechPositionalConvEmbedding(Wav2Vec2PositionalConvEmbedding):
+ pass
+
+
+class UniSpeechFeatureEncoder(Wav2Vec2FeatureEncoder):
+ pass
+
+
+class UniSpeechFeatureProjection(Wav2Vec2FeatureProjection):
+ pass
+
+
+class UniSpeechEncoder(Wav2Vec2Encoder):
+ pass
+
+
+class UniSpeechEncoderStableLayerNorm(Wav2Vec2EncoderStableLayerNorm):
+ pass
+
+
+class UniSpeechGumbelVectorQuantizer(Wav2Vec2GumbelVectorQuantizer):
+ @staticmethod
+ def _compute_perplexity(probs):
+ marginal_probs = probs.mean(dim=0)
+ perplexity = torch.exp(-torch.sum(torch.xlogy(marginal_probs, marginal_probs), dim=-1)).sum()
+ return perplexity
+
+ def forward(self, hidden_states):
+ batch_size, sequence_length, hidden_size = hidden_states.shape
+
+ # project to codevector dim
+ hidden_states = self.weight_proj(hidden_states)
+ hidden_states = hidden_states.view(batch_size * sequence_length * self.num_groups, -1)
+
+ if self.training:
+ # sample code vector probs via gumbel in differentiateable way
+ codevector_probs = nn.functional.gumbel_softmax(
+ hidden_states.float(), tau=self.temperature, hard=True
+ ).type_as(hidden_states)
+
+ # compute perplexity
+ codevector_soft_dist = torch.softmax(
+ hidden_states.view(batch_size * sequence_length, self.num_groups, -1).float(), dim=-1
+ )
+ perplexity = self._compute_perplexity(codevector_soft_dist)
+ else:
+ # take argmax in non-differentiable way
+ # comptute hard codevector distribution (one hot)
+ codevector_idx = hidden_states.argmax(dim=-1)
+ codevector_probs = hidden_states.new_zeros(*hidden_states.shape).scatter_(
+ -1, codevector_idx.view(-1, 1), 1.0
+ )
+ codevector_probs = codevector_probs.view(batch_size * sequence_length, self.num_groups, -1)
+
+ perplexity = self._compute_perplexity(codevector_probs)
+
+ codevector_probs = codevector_probs.view(batch_size * sequence_length, -1)
+ # use probs to retrieve codevectors
+ codevectors_per_group = codevector_probs.unsqueeze(-1) * self.codevectors
+ codevectors = codevectors_per_group.view(batch_size * sequence_length, self.num_groups, self.num_vars, -1)
+ codevectors = codevectors.sum(-2).view(batch_size, sequence_length, -1)
+
+ return codevectors, perplexity
+
+
+@auto_docstring
+class UniSpeechPreTrainedModel(PreTrainedModel):
+ config: UniSpeechConfig
+ base_model_prefix = "unispeech"
+ main_input_name = "input_values"
+ input_modalities = "audio"
+ supports_gradient_checkpointing = True
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ # gumbel softmax requires special init
+ if isinstance(module, UniSpeechGumbelVectorQuantizer):
+ init.normal_(module.weight_proj.weight, mean=0.0, std=1)
+ init.zeros_(module.weight_proj.bias)
+ init.uniform_(module.codevectors)
+ elif isinstance(module, UniSpeechPositionalConvEmbedding):
+ init.normal_(
+ module.conv.weight,
+ mean=0,
+ std=2 * math.sqrt(1 / (module.conv.kernel_size[0] * module.conv.in_channels)),
+ )
+ init.constant_(module.conv.bias, 0)
+ elif isinstance(module, UniSpeechFeatureProjection):
+ k = math.sqrt(1 / module.projection.in_features)
+ init.uniform_(module.projection.weight, a=-k, b=k)
+ init.uniform_(module.projection.bias, a=-k, b=k)
+ elif isinstance(module, nn.Linear):
+ init.normal_(module.weight, mean=0.0, std=self.config.initializer_range)
+
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, (nn.LayerNorm, nn.GroupNorm)):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ elif isinstance(module, nn.Conv1d):
+ init.kaiming_normal_(module.weight)
+
+ if module.bias is not None:
+ k = math.sqrt(module.groups / (module.in_channels * module.kernel_size[0]))
+ init.uniform_(module.bias, a=-k, b=k)
+
+ def _get_feat_extract_output_lengths(self, input_lengths: torch.LongTensor | int):
+ """
+ Computes the output length of the convolutional layers
+ """
+
+ def _conv_out_length(input_length, kernel_size, stride):
+ # 1D convolutional layer output length formula taken
+ # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html
+ return torch.div(input_length - kernel_size, stride, rounding_mode="floor") + 1
+
+ for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride):
+ input_lengths = _conv_out_length(input_lengths, kernel_size, stride)
+
+ return input_lengths
+
+ def _get_feature_vector_attention_mask(self, feature_vector_length: int, attention_mask: torch.LongTensor):
+ # Effectively attention_mask.sum(-1), but not inplace to be able to run
+ # on inference mode.
+ non_padded_lengths = attention_mask.cumsum(dim=-1)[:, -1]
+ output_lengths = self._get_feat_extract_output_lengths(non_padded_lengths).to(torch.long)
+ batch_size = attention_mask.shape[0]
+
+ attention_mask = torch.zeros(
+ (batch_size, feature_vector_length), dtype=attention_mask.dtype, device=attention_mask.device
+ )
+ # these two operations makes sure that all values before the output lengths idxs are attended to
+ attention_mask[(torch.arange(attention_mask.shape[0], device=attention_mask.device), output_lengths - 1)] = 1
+ attention_mask = attention_mask.flip([-1]).cumsum(-1).flip([-1]).bool()
+ return attention_mask
+
+
+UniSpeechBaseModelOutput = Wav2Vec2BaseModelOutput
+
+
+class UniSpeechModel(UniSpeechPreTrainedModel, Wav2Vec2Model):
+ def __init__(self, config: UniSpeechConfig):
+ UniSpeechPreTrainedModel.__init__(self, config)
+ self.config = config
+ self.feature_extractor = UniSpeechFeatureEncoder(config)
+ self.feature_projection = UniSpeechFeatureProjection(config)
+
+ if config.mask_time_prob > 0.0 or config.mask_feature_prob > 0.0:
+ self.masked_spec_embed = nn.Parameter(torch.Tensor(config.hidden_size).uniform_())
+
+ if config.do_stable_layer_norm:
+ self.encoder = UniSpeechEncoderStableLayerNorm(config)
+ else:
+ self.encoder = UniSpeechEncoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def freeze_feature_encoder(self):
+ raise AttributeError("Not needed for UniSpeech")
+
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ mask_time_indices: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | UniSpeechBaseModelOutput:
+ r"""
+ mask_time_indices (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices to mask extracted features for contrastive loss. When in training mode, model learns to predict
+ masked extracted features in *config.proj_codevector_dim* space.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ extract_features = self.feature_extractor(input_values)
+ extract_features = extract_features.transpose(1, 2)
+
+ if attention_mask is not None:
+ # compute reduced attention_mask corresponding to feature vectors
+ attention_mask = self._get_feature_vector_attention_mask(extract_features.shape[1], attention_mask)
+
+ hidden_states, extract_features = self.feature_projection(extract_features)
+ hidden_states = self._mask_hidden_states(
+ hidden_states, mask_time_indices=mask_time_indices, attention_mask=attention_mask
+ )
+
+ encoder_outputs = self.encoder(
+ hidden_states,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ if not return_dict:
+ return (hidden_states, extract_features) + encoder_outputs[1:]
+
+ return UniSpeechBaseModelOutput(
+ last_hidden_state=hidden_states,
+ extract_features=extract_features,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ UniSpeech Model with a vector-quantization module and ctc loss for pre-training.
+ """
+)
+class UniSpeechForPreTraining(UniSpeechPreTrainedModel):
+ def __init__(self, config: UniSpeechConfig):
+ super().__init__(config)
+ self.unispeech = UniSpeechModel(config)
+ self.dropout_features = nn.Dropout(config.feat_quantizer_dropout)
+
+ self.quantizer = UniSpeechGumbelVectorQuantizer(config)
+ self.project_q = nn.Linear(config.codevector_dim, config.proj_codevector_dim)
+ self.project_hid = nn.Linear(config.proj_codevector_dim, config.hidden_size)
+
+ self.ctc_proj = nn.Linear(config.hidden_size, config.num_ctc_classes)
+ self.dropout = nn.Dropout(config.final_dropout)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def set_gumbel_temperature(self, temperature: int):
+ """
+ Set the Gumbel softmax temperature to a given value. Only necessary for training
+ """
+ self.quantizer.temperature = temperature
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech.feature_extractor._freeze_parameters()
+
+ @staticmethod
+ def compute_contrastive_logits(
+ target_features: torch.FloatTensor,
+ negative_features: torch.FloatTensor,
+ predicted_features: torch.FloatTensor,
+ temperature: int = 1,
+ ):
+ """
+ Compute logits for contrastive loss based using cosine similarity as the distance measure between
+ `[positive_feature, negative_features]` and `[predicted_features]`. Additionally, temperature can be applied.
+ """
+ target_features = torch.cat([target_features, negative_features], dim=0)
+
+ logits = torch.cosine_similarity(predicted_features.float(), target_features.float(), dim=-1)
+ logits = logits.type_as(target_features)
+
+ # apply temperature
+ logits = logits / temperature
+ return logits
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | UniSpeechForPreTrainingOutput:
+ r"""
+ Example:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoFeatureExtractor, UniSpeechForPreTraining
+
+ >>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-large-1500h-cv")
+ >>> model = UniSpeechForPreTraining.from_pretrained("microsoft/unispeech-large-1500h-cv")
+ >>> # TODO: Add full pretraining example
+ ```"""
+
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.unispeech(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ transformer_features = outputs[0]
+
+ # quantize all (unmasked) extracted features and project to final vq dim
+ extract_features = self.dropout_features(outputs[1])
+ quantized_features, codevector_perplexity = self.quantizer(extract_features)
+
+ # project quantized features twice
+ quantized_features = self.project_q(quantized_features.to(self.project_q.weight.dtype))
+ quantized_features = self.project_hid(quantized_features)
+
+ prob_replace_matrix = torch.empty(transformer_features.size(0), transformer_features.size(1)).fill_(
+ self.config.replace_prob
+ )
+ prob_replace_matrix = prob_replace_matrix.transpose(0, 1)
+ sampled_replace_matrix = torch.bernoulli(prob_replace_matrix).bool().to(transformer_features.device)
+ sampled_replace_matrix = sampled_replace_matrix.transpose(0, 1)
+ sampled_replace_matrix = sampled_replace_matrix.unsqueeze(-1)
+ logits = transformer_features.masked_fill(sampled_replace_matrix, 0.0) + (
+ quantized_features.masked_fill(~sampled_replace_matrix, 0.0)
+ )
+
+ # project to ctc units
+ logits = self.dropout(logits)
+ logits = self.ctc_proj(logits)
+
+ # TODO(PVP) - add negative sampling & loss computation
+ loss = None
+ if not return_dict:
+ if loss is not None:
+ return (loss, transformer_features, quantized_features, codevector_perplexity) + outputs[2:]
+ return (transformer_features, quantized_features, codevector_perplexity) + outputs[2:]
+
+ return UniSpeechForPreTrainingOutput(
+ loss=loss,
+ projected_states=transformer_features,
+ projected_quantized_states=quantized_features,
+ codevector_perplexity=codevector_perplexity,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+class UniSpeechForCTC(Wav2Vec2ForCTC):
+ pass
+
+
+class UniSpeechForSequenceClassification(Wav2Vec2ForSequenceClassification):
+ pass
+
+
+__all__ = [
+ "UniSpeechForCTC",
+ "UniSpeechForPreTraining",
+ "UniSpeechForSequenceClassification",
+ "UniSpeechModel",
+ "UniSpeechPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech_sat/__init__.py b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc3144ed17d14cd7db2b93b05d21d0a0e3ffe3d0
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_unispeech_sat import *
+ from .modeling_unispeech_sat import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8ca5932c69d0cdf02f1aa98ce84da7c0b96da01b
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/configuration_unispeech_sat.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/configuration_unispeech_sat.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf2bde893338f4d649a9693aef8305f1344f5059
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/configuration_unispeech_sat.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/modeling_unispeech_sat.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/modeling_unispeech_sat.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e3602e875a527edf0cbdc762fdcc1428733f63d8
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/modeling_unispeech_sat.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/modular_unispeech_sat.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/modular_unispeech_sat.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c248ef29a10fd8873269b0d60af29f3252957e1
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/unispeech_sat/__pycache__/modular_unispeech_sat.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech_sat/configuration_unispeech_sat.py b/lib/python3.11/site-packages/transformers/models/unispeech_sat/configuration_unispeech_sat.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba0caffc3297224cd18564a8f51a28809c9d8d3c
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/unispeech_sat/configuration_unispeech_sat.py
@@ -0,0 +1,221 @@
+# Copyright 2021 The Fairseq Authors and The HuggingFace Inc. 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.
+"""UniSpeechSat model configuration"""
+
+import functools
+import operator
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="microsoft/unispeech-sat-base-100h-libri-ft")
+@strict
+class UniSpeechSatConfig(PreTrainedConfig):
+ r"""
+ feat_proj_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout probability for output of the feature encoder.
+ feat_quantizer_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout probability for the output of the feature encoder that's used by the quantizer.
+ final_dropout (`float`, *optional*, defaults to 0.1):
+ The dropout probability for the final projection layer of [`UniSpeechSatForCTC`].
+ feat_extract_norm (`str`, *optional*, defaults to `"group"`):
+ The norm to be applied to 1D convolutional layers in feature encoder. One of `"group"` for group
+ normalization of only the first 1D convolutional layer or `"layer"` for layer normalization of all 1D
+ convolutional layers.
+ feat_extract_activation (`str, *optional*, defaults to `"gelu"`):
+ The non-linear activation function (function or string) in the 1D convolutional layers of the feature
+ extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported.
+ conv_dim (`tuple[int]` or `list[int]`, *optional*, defaults to `(512, 512, 512, 512, 512, 512, 512)`):
+ A tuple of integers defining the number of input and output channels of each 1D convolutional layer in the
+ feature encoder. The length of *conv_dim* defines the number of 1D convolutional layers.
+ conv_stride (`tuple[int]` or `list[int]`, *optional*, defaults to `(5, 2, 2, 2, 2, 2, 2)`):
+ A tuple of integers defining the stride of each 1D convolutional layer in the feature encoder. The length
+ of *conv_stride* defines the number of convolutional layers and has to match the length of *conv_dim*.
+ conv_kernel (`tuple[int]` or `list[int]`, *optional*, defaults to `(10, 3, 3, 3, 3, 2, 2)`):
+ A tuple of integers defining the kernel size of each 1D convolutional layer in the feature encoder. The
+ length of *conv_kernel* defines the number of convolutional layers and has to match the length of
+ *conv_dim*.
+ conv_bias (`bool`, *optional*, defaults to `False`):
+ Whether the 1D convolutional layers have a bias.
+ num_conv_pos_embeddings (`int`, *optional*, defaults to 128):
+ Number of convolutional positional embeddings. Defines the kernel size of 1D convolutional positional
+ embeddings layer.
+ num_conv_pos_embedding_groups (`int`, *optional*, defaults to 16):
+ Number of groups of 1D convolutional positional embeddings layer.
+ do_stable_layer_norm (`bool`, *optional*, defaults to `False`):
+ Whether to apply *stable* layer norm architecture of the Transformer encoder. `do_stable_layer_norm is
+ True` corresponds to applying layer norm before the attention layer, whereas `do_stable_layer_norm is
+ False` corresponds to applying layer norm after the attention layer.
+ apply_spec_augment (`bool`, *optional*, defaults to `True`):
+ Whether to apply *SpecAugment* data augmentation to the outputs of the feature encoder. For reference see
+ [SpecAugment: A Simple Data Augmentation Method for Automatic Speech
+ Recognition](https://huggingface.co/papers/1904.08779).
+ mask_time_prob (`float`, *optional*, defaults to 0.05):
+ Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking
+ procedure generates ''mask_time_prob*len(time_axis)/mask_time_length'' independent masks over the axis. If
+ reasoning from the probability of each feature vector to be chosen as the start of the vector span to be
+ masked, *mask_time_prob* should be `prob_vector_start*mask_time_length`. Note that overlap may decrease the
+ actual percentage of masked vectors. This is only relevant if `apply_spec_augment is True`.
+ mask_time_length (`int`, *optional*, defaults to 10):
+ Length of vector span along the time axis.
+ mask_time_min_masks (`int`, *optional*, defaults to 2):
+ The minimum number of masks of length `mask_feature_length` generated along the time axis, each time step,
+ irrespectively of `mask_feature_prob`. Only relevant if ''mask_time_prob*len(time_axis)/mask_time_length <
+ mask_time_min_masks''
+ mask_feature_prob (`float`, *optional*, defaults to 0.0):
+ Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The
+ masking procedure generates ''mask_feature_prob*len(feature_axis)/mask_time_length'' independent masks over
+ the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector
+ span to be masked, *mask_feature_prob* should be `prob_vector_start*mask_feature_length`. Note that overlap
+ may decrease the actual percentage of masked vectors. This is only relevant if `apply_spec_augment is
+ True`.
+ mask_feature_length (`int`, *optional*, defaults to 10):
+ Length of vector span along the feature axis.
+ mask_feature_min_masks (`int`, *optional*, defaults to 0):
+ The minimum number of masks of length `mask_feature_length` generated along the feature axis, each time
+ step, irrespectively of `mask_feature_prob`. Only relevant if
+ ''mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks''
+ num_codevectors_per_group (`int`, *optional*, defaults to 320):
+ Number of entries in each quantization codebook (group).
+ num_codevector_groups (`int`, *optional*, defaults to 2):
+ Number of codevector groups for product codevector quantization.
+ contrastive_logits_temperature (`float`, *optional*, defaults to 0.1):
+ The temperature *kappa* in the contrastive loss.
+ num_negatives (`int`, *optional*, defaults to 100):
+ Number of negative samples for the contrastive loss.
+ codevector_dim (`int`, *optional*, defaults to 256):
+ Dimensionality of the quantized feature vectors.
+ proj_codevector_dim (`int`, *optional*, defaults to 256):
+ Dimensionality of the final projection of both the quantized and the transformer features.
+ diversity_loss_weight (`int`, *optional*, defaults to 0.1):
+ The weight of the codebook diversity loss component.
+ ctc_zero_infinity (`bool`, *optional*, defaults to `False`):
+ Whether to zero infinite losses and the associated gradients of `torch.nn.CTCLoss`. Infinite losses mainly
+ occur when the inputs are too short to be aligned to the targets. Only relevant when training an instance
+ of [`UniSpeechSatForCTC`].
+ use_weighted_layer_sum (`bool`, *optional*, defaults to `False`):
+ Whether to use a weighted average of layer outputs with learned weights. Only relevant when using an
+ instance of [`UniSpeechSatForSequenceClassification`].
+ classifier_proj_size (`int`, *optional*, defaults to 256):
+ Dimensionality of the projection before token mean-pooling for classification.
+ tdnn_dim (`tuple[int]` or `list[int]`, *optional*, defaults to `(512, 512, 512, 512, 1500)`):
+ A tuple of integers defining the number of output channels of each 1D convolutional layer in the *TDNN*
+ module of the *XVector* model. The length of *tdnn_dim* defines the number of *TDNN* layers.
+ tdnn_kernel (`tuple[int]` or `list[int]`, *optional*, defaults to `(5, 3, 3, 1, 1)`):
+ A tuple of integers defining the kernel size of each 1D convolutional layer in the *TDNN* module of the
+ *XVector* model. The length of *tdnn_kernel* has to match the length of *tdnn_dim*.
+ tdnn_dilation (`tuple[int]` or `list[int]`, *optional*, defaults to `(1, 2, 3, 1, 1)`):
+ A tuple of integers defining the dilation factor of each 1D convolutional layer in *TDNN* module of the
+ *XVector* model. The length of *tdnn_dilation* has to match the length of *tdnn_dim*.
+ xvector_output_dim (`int`, *optional*, defaults to 512):
+ Dimensionality of the *XVector* embedding vectors.
+ num_clusters (`int`, *optional*, defaults to 504):
+ Number of clusters for weak labeling. Only relevant when using an instance of
+ [`UniSpeechSatForPreTraining`].
+
+ Example:
+
+ ```python
+ >>> from transformers import UniSpeechSatModel, UniSpeechSatConfig
+
+ >>> # Initializing a UniSpeechSat microsoft/unispeech-sat-base-100h-libri-ft style configuration
+ >>> configuration = UniSpeechSatConfig()
+
+ >>> # Initializing a model from the microsoft/unispeech-sat-base-100h-libri-ft style configuration
+ >>> model = UniSpeechSatModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "unispeech-sat"
+
+ vocab_size: int = 32
+ hidden_size: int = 768
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ intermediate_size: int = 3072
+ hidden_act: str = "gelu"
+ hidden_dropout: float | int = 0.1
+ activation_dropout: float | int = 0.1
+ attention_dropout: float | int = 0.1
+ feat_proj_dropout: float | int = 0.0
+ feat_quantizer_dropout: float | int = 0.0
+ final_dropout: float | int = 0.1
+ layerdrop: float | int = 0.1
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-5
+ feat_extract_norm: str = "group"
+ feat_extract_activation: str = "gelu"
+ conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)
+ conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)
+ conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)
+ conv_bias: bool = False
+ num_conv_pos_embeddings: int = 128
+ num_conv_pos_embedding_groups: int = 16
+ do_stable_layer_norm: bool = False
+ apply_spec_augment: bool = True
+ mask_time_prob: float | int = 0.05
+ mask_time_length: int = 10
+ mask_time_min_masks: int = 2
+ mask_feature_prob: float | int = 0.0
+ mask_feature_length: int = 10
+ mask_feature_min_masks: int = 0
+ num_codevectors_per_group: int = 320
+ num_codevector_groups: int = 2
+ contrastive_logits_temperature: float = 0.1
+ num_negatives: int = 100
+ codevector_dim: int = 256
+ proj_codevector_dim: int = 256
+ diversity_loss_weight: float = 0.1
+ ctc_loss_reduction: str = "mean"
+ ctc_zero_infinity: bool = False
+ use_weighted_layer_sum: bool = False
+ classifier_proj_size: int = 256
+ tdnn_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 1500)
+ tdnn_kernel: list[int] | tuple[int, ...] = (5, 3, 3, 1, 1)
+ tdnn_dilation: list[int] | tuple[int, ...] = (1, 2, 3, 1, 1)
+ xvector_output_dim: int = 512
+ pad_token_id: int = 0
+ bos_token_id: int = 1
+ eos_token_id: int = 2
+ num_clusters: int = 504
+
+ def __post_init__(self, **kwargs):
+ self.num_feat_extract_layers = len(self.conv_dim)
+ return super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if (
+ (len(self.conv_stride) != self.num_feat_extract_layers)
+ or (len(self.conv_kernel) != self.num_feat_extract_layers)
+ or (len(self.conv_dim) != self.num_feat_extract_layers)
+ ):
+ raise ValueError(
+ "Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="
+ " `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="
+ f" {len(self.conv_dim)}`, `len(config.conv_stride) = {len(self.conv_stride)}`,"
+ f" `len(config.conv_kernel) = {len(self.conv_kernel)}`."
+ )
+
+ @property
+ def inputs_to_logits_ratio(self):
+ return functools.reduce(operator.mul, self.conv_stride, 1)
+
+
+__all__ = ["UniSpeechSatConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech_sat/modeling_unispeech_sat.py b/lib/python3.11/site-packages/transformers/models/unispeech_sat/modeling_unispeech_sat.py
new file mode 100644
index 0000000000000000000000000000000000000000..565852237d06fab9f908d7ac13d20a3dfe53a34b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/unispeech_sat/modeling_unispeech_sat.py
@@ -0,0 +1,1726 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/unispeech_sat/modular_unispeech_sat.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_unispeech_sat.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2021 The Fairseq Authors and the HuggingFace Inc. 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 math
+import warnings
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.nn import CrossEntropyLoss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...integrations.deepspeed import is_deepspeed_zero3_enabled
+from ...integrations.fsdp import is_fsdp_managed_module
+from ...masking_utils import create_bidirectional_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+ BaseModelOutput,
+ CausalLMOutput,
+ ModelOutput,
+ SequenceClassifierOutput,
+ TokenClassifierOutput,
+ Wav2Vec2BaseModelOutput,
+ XVectorOutput,
+)
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel, get_torch_context_manager_or_global_device
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, is_peft_available, logging
+from .configuration_unispeech_sat import UniSpeechSatConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(
+ custom_intro="""
+ Output type of [`UniSpeechSatForPreTrainingOutput`], with potential hidden states and attentions.
+ """
+)
+@dataclass
+class UniSpeechSatForPreTrainingOutput(ModelOutput):
+ r"""
+ loss (*optional*, returned when model is in train mode, `torch.FloatTensor` of shape `(1,)`):
+ Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the [official
+ paper](https://huggingface.co/papers/2006.11477).
+ logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`, *optional*):
+ Prediction scores of the contrastive loss model, i.e. the output of the model before the final softmax.
+ projected_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`):
+ Hidden-states of the model projected to *config.proj_codevector_dim* that can be used to predict the masked
+ projected quantized states.
+ projected_quantized_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`):
+ Quantized extracted feature vectors projected to *config.proj_codevector_dim* representing the positive
+ target vectors for contrastive loss.
+ codevector_perplexity (`torch.FloatTensor` of shape `(1,)`):
+ The perplexity of the codevector distribution, used to measure the diversity of the codebook.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ projected_states: torch.FloatTensor | None = None
+ projected_quantized_states: torch.FloatTensor | None = None
+ codevector_perplexity: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+class UniSpeechSatSamePadLayer(nn.Module):
+ def __init__(self, num_conv_pos_embeddings):
+ super().__init__()
+ self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else 0
+
+ def forward(self, hidden_states):
+ if self.num_pad_remove > 0:
+ hidden_states = hidden_states[:, :, : -self.num_pad_remove]
+ return hidden_states
+
+
+class UniSpeechSatPositionalConvEmbedding(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.conv = nn.Conv1d(
+ config.hidden_size,
+ config.hidden_size,
+ kernel_size=config.num_conv_pos_embeddings,
+ padding=config.num_conv_pos_embeddings // 2,
+ groups=config.num_conv_pos_embedding_groups,
+ )
+
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ if is_deepspeed_zero3_enabled():
+ import deepspeed
+
+ with deepspeed.zero.GatheredParameters(self.conv.weight, modifier_rank=0):
+ self.conv = weight_norm(self.conv, name="weight", dim=2)
+ if hasattr(self.conv, "parametrizations"):
+ weight_g = self.conv.parametrizations.weight.original0
+ weight_v = self.conv.parametrizations.weight.original1
+ else:
+ weight_g = self.conv.weight_g
+ weight_v = self.conv.weight_v
+ deepspeed.zero.register_external_parameter(self, weight_v)
+ deepspeed.zero.register_external_parameter(self, weight_g)
+ else:
+ self.conv = weight_norm(self.conv, name="weight", dim=2)
+
+ self.padding = UniSpeechSatSamePadLayer(config.num_conv_pos_embeddings)
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ def forward(self, hidden_states):
+ hidden_states = hidden_states.transpose(1, 2)
+
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.padding(hidden_states)
+ hidden_states = self.activation(hidden_states)
+
+ hidden_states = hidden_states.transpose(1, 2)
+ return hidden_states
+
+
+class UniSpeechSatNoLayerNormConvLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.conv_dim[layer_id - 1] if layer_id > 0 else 1
+ self.out_conv_dim = config.conv_dim[layer_id]
+
+ self.conv = nn.Conv1d(
+ self.in_conv_dim,
+ self.out_conv_dim,
+ kernel_size=config.conv_kernel[layer_id],
+ stride=config.conv_stride[layer_id],
+ bias=config.conv_bias,
+ )
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+class UniSpeechSatLayerNormConvLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.conv_dim[layer_id - 1] if layer_id > 0 else 1
+ self.out_conv_dim = config.conv_dim[layer_id]
+
+ self.conv = nn.Conv1d(
+ self.in_conv_dim,
+ self.out_conv_dim,
+ kernel_size=config.conv_kernel[layer_id],
+ stride=config.conv_stride[layer_id],
+ bias=config.conv_bias,
+ )
+ self.layer_norm = nn.LayerNorm(self.out_conv_dim, elementwise_affine=True)
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+
+ hidden_states = hidden_states.transpose(-2, -1)
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = hidden_states.transpose(-2, -1)
+
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+class UniSpeechSatGroupNormConvLayer(GradientCheckpointingLayer):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.conv_dim[layer_id - 1] if layer_id > 0 else 1
+ self.out_conv_dim = config.conv_dim[layer_id]
+
+ self.conv = nn.Conv1d(
+ self.in_conv_dim,
+ self.out_conv_dim,
+ kernel_size=config.conv_kernel[layer_id],
+ stride=config.conv_stride[layer_id],
+ bias=config.conv_bias,
+ )
+ self.activation = ACT2FN[config.feat_extract_activation]
+
+ self.layer_norm = nn.GroupNorm(num_groups=self.out_conv_dim, num_channels=self.out_conv_dim, affine=True)
+
+ def forward(self, hidden_states):
+ hidden_states = self.conv(hidden_states)
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+class UniSpeechSatFeatureEncoder(nn.Module):
+ """Construct the features from raw audio waveform"""
+
+ def __init__(self, config):
+ super().__init__()
+
+ if config.feat_extract_norm == "group":
+ conv_layers = [UniSpeechSatGroupNormConvLayer(config, layer_id=0)] + [
+ UniSpeechSatNoLayerNormConvLayer(config, layer_id=i + 1)
+ for i in range(config.num_feat_extract_layers - 1)
+ ]
+ elif config.feat_extract_norm == "layer":
+ conv_layers = [
+ UniSpeechSatLayerNormConvLayer(config, layer_id=i) for i in range(config.num_feat_extract_layers)
+ ]
+ else:
+ raise ValueError(
+ f"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group', 'layer']"
+ )
+ self.conv_layers = nn.ModuleList(conv_layers)
+ self.gradient_checkpointing = False
+ self._requires_grad = True
+
+ def _freeze_parameters(self):
+ for param in self.parameters():
+ param.requires_grad = False
+ self._requires_grad = False
+
+ def forward(self, input_values):
+ hidden_states = input_values[:, None]
+
+ # make sure hidden_states require grad for gradient_checkpointing
+ if self._requires_grad and self.training:
+ hidden_states.requires_grad = True
+
+ for conv_layer in self.conv_layers:
+ hidden_states = conv_layer(hidden_states)
+
+ return hidden_states
+
+
+class UniSpeechSatFeatureProjection(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.layer_norm = nn.LayerNorm(config.conv_dim[-1], eps=config.layer_norm_eps)
+ self.projection = nn.Linear(config.conv_dim[-1], config.hidden_size)
+ self.dropout = nn.Dropout(config.feat_proj_dropout)
+
+ def forward(self, hidden_states):
+ # non-projected hidden states are needed for quantization
+ norm_hidden_states = self.layer_norm(hidden_states)
+ hidden_states = self.projection(norm_hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return hidden_states, norm_hidden_states
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float | None = None,
+ dropout: float = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ if scaling is None:
+ scaling = query.size(-1) ** -0.5
+
+ # Take the dot product between "query" and "key" to get the raw attention scores.
+ attn_weights = torch.matmul(query, key.transpose(2, 3)) * scaling
+
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+class UniSpeechSatAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(
+ self,
+ embed_dim: int,
+ num_heads: int,
+ dropout: float = 0.0,
+ is_decoder: bool = False,
+ bias: bool = True,
+ is_causal: bool = False,
+ config: UniSpeechSatConfig | None = None,
+ ):
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.num_heads = num_heads
+ self.dropout = dropout
+ self.head_dim = embed_dim // num_heads
+ self.config = config
+
+ if (self.head_dim * num_heads) != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}"
+ f" and `num_heads`: {num_heads})."
+ )
+ self.scaling = self.head_dim**-0.5
+ self.is_decoder = is_decoder
+ self.is_causal = is_causal
+
+ self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+ self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ key_value_states: torch.Tensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = False,
+ # TODO: we need a refactor so that the different attention modules can get their specific kwargs
+ # ATM, we have mixed things encoder, decoder, and encoder-decoder attn
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ """Input shape: Batch x Time x Channel"""
+
+ # if key_value_states are provided this layer is used as a cross-attention layer
+ # for the decoder
+ is_cross_attention = key_value_states is not None
+
+ # determine input shapes
+ input_shape = hidden_states.shape[:-1]
+
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ # get query proj
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ current_states = key_value_states if is_cross_attention else hidden_states
+ kv_shape = (*current_states.shape[:-1], -1, self.head_dim)
+ key_states = self.k_proj(current_states).view(kv_shape).transpose(1, 2)
+ value_states = self.v_proj(current_states).view(kv_shape).transpose(1, 2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=0.0 if not self.training else self.dropout,
+ scaling=self.scaling,
+ output_attentions=output_attentions,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights, None
+
+
+class UniSpeechSatFeedForward(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.intermediate_dropout = nn.Dropout(config.activation_dropout)
+
+ self.intermediate_dense = nn.Linear(config.hidden_size, config.intermediate_size)
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ self.output_dense = nn.Linear(config.intermediate_size, config.hidden_size)
+ self.output_dropout = nn.Dropout(config.hidden_dropout)
+
+ def forward(self, hidden_states):
+ hidden_states = self.intermediate_dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ hidden_states = self.intermediate_dropout(hidden_states)
+
+ hidden_states = self.output_dense(hidden_states)
+ hidden_states = self.output_dropout(hidden_states)
+ return hidden_states
+
+
+class UniSpeechSatEncoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config):
+ super().__init__()
+ self.attention = UniSpeechSatAttention(
+ embed_dim=config.hidden_size,
+ num_heads=config.num_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=False,
+ config=config,
+ )
+
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.feed_forward = UniSpeechSatFeedForward(config)
+ self.final_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ def forward(self, hidden_states, attention_mask=None, output_attentions=False):
+ attn_residual = hidden_states
+ hidden_states, attn_weights, _ = self.attention(
+ hidden_states, attention_mask=attention_mask, output_attentions=output_attentions
+ )
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = attn_residual + hidden_states
+
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = hidden_states + self.feed_forward(hidden_states)
+ hidden_states = self.final_layer_norm(hidden_states)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (attn_weights,)
+
+ return outputs
+
+
+class UniSpeechSatEncoder(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.pos_conv_embed = UniSpeechSatPositionalConvEmbedding(config)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layers = nn.ModuleList([UniSpeechSatEncoderLayer(config) for _ in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states: torch.tensor,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ output_hidden_states: bool = False,
+ return_dict: bool = True,
+ ):
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ if attention_mask is not None:
+ # make sure padded tokens output 0
+ expand_attention_mask = attention_mask.unsqueeze(-1).repeat(1, 1, hidden_states.shape[2])
+ hidden_states[~expand_attention_mask] = 0
+
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ )
+
+ position_embeddings = self.pos_conv_embed(hidden_states)
+ hidden_states = hidden_states + position_embeddings.to(hidden_states.device)
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+
+ synced_gpus = is_deepspeed_zero3_enabled() or is_fsdp_managed_module(self)
+
+ for layer in self.layers:
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ dropout_probability = torch.rand([])
+
+ skip_the_layer = self.training and dropout_probability < self.config.layerdrop
+ if not skip_the_layer or synced_gpus:
+ # under fsdp or deepspeed zero3 all gpus must run in sync
+ layer_outputs = layer(
+ hidden_states, attention_mask=attention_mask, output_attentions=output_attentions
+ )
+ hidden_states = layer_outputs[0]
+
+ if skip_the_layer:
+ layer_outputs = (None, None)
+
+ if output_attentions:
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+
+class UniSpeechSatAttnAdapterLayer(nn.Module):
+ def __init__(self, config):
+ """
+ Implements adapter modules directly with 3D tensor weight as parameters and without using ModuleList to speed
+ up training throughput.
+ """
+ super().__init__()
+ self.input_dim = config.adapter_attn_dim
+ self.hidden_dim = config.hidden_size
+
+ self.norm = nn.LayerNorm(self.hidden_dim)
+ self.linear_1 = nn.Linear(self.hidden_dim, self.input_dim)
+ self.act_fn = nn.ReLU()
+ self.linear_2 = nn.Linear(self.input_dim, self.hidden_dim)
+
+ def forward(self, hidden_states: torch.FloatTensor):
+ hidden_states = self.norm(hidden_states)
+
+ hidden_states = self.linear_1(hidden_states)
+ hidden_states = self.act_fn(hidden_states)
+ hidden_states = self.linear_2(hidden_states)
+
+ return hidden_states
+
+
+class UniSpeechSatEncoderLayerStableLayerNorm(GradientCheckpointingLayer):
+ def __init__(self, config):
+ super().__init__()
+ self.attention = UniSpeechSatAttention(
+ embed_dim=config.hidden_size,
+ num_heads=config.num_attention_heads,
+ dropout=config.attention_dropout,
+ is_decoder=False,
+ config=config,
+ )
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.feed_forward = UniSpeechSatFeedForward(config)
+ self.final_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ if getattr(config, "adapter_attn_dim", None) is not None:
+ self.adapter_layer = UniSpeechSatAttnAdapterLayer(config)
+ else:
+ self.adapter_layer = None
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool = False,
+ ):
+ attn_residual = hidden_states
+ hidden_states = self.layer_norm(hidden_states)
+ hidden_states, attn_weights, _ = self.attention(
+ hidden_states, attention_mask=attention_mask, output_attentions=output_attentions
+ )
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = attn_residual + hidden_states
+ hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states))
+
+ if self.adapter_layer is not None:
+ hidden_states = hidden_states + self.adapter_layer(hidden_states)
+
+ outputs = (hidden_states,)
+
+ if output_attentions:
+ outputs += (attn_weights,)
+
+ return outputs
+
+
+class UniSpeechSatEncoderStableLayerNorm(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.pos_conv_embed = UniSpeechSatPositionalConvEmbedding(config)
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.dropout = nn.Dropout(config.hidden_dropout)
+ self.layers = nn.ModuleList(
+ [UniSpeechSatEncoderLayerStableLayerNorm(config) for _ in range(config.num_hidden_layers)]
+ )
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states,
+ attention_mask=None,
+ output_attentions=False,
+ output_hidden_states=False,
+ return_dict=True,
+ ):
+ all_hidden_states = () if output_hidden_states else None
+ all_self_attentions = () if output_attentions else None
+
+ if attention_mask is not None:
+ # make sure padded tokens output 0
+ expand_attention_mask = attention_mask.unsqueeze(-1).repeat(1, 1, hidden_states.shape[2])
+ hidden_states[~expand_attention_mask] = 0
+
+ attention_mask = create_bidirectional_mask(
+ config=self.config,
+ inputs_embeds=hidden_states,
+ attention_mask=attention_mask,
+ )
+
+ position_embeddings = self.pos_conv_embed(hidden_states)
+ hidden_states = hidden_states + position_embeddings
+ hidden_states = self.dropout(hidden_states)
+
+ synced_gpus = is_deepspeed_zero3_enabled() or is_fsdp_managed_module(self)
+
+ for layer in self.layers:
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+ dropout_probability = torch.rand([])
+
+ skip_the_layer = self.training and dropout_probability < self.config.layerdrop
+ if not skip_the_layer or synced_gpus:
+ # under fsdp or deepspeed zero3 all gpus must run in sync
+ # XXX: could optimize this like synced_gpus in generate_utils but not sure if it's worth the code complication
+ layer_outputs = layer(
+ hidden_states, attention_mask=attention_mask, output_attentions=output_attentions
+ )
+ hidden_states = layer_outputs[0]
+
+ if skip_the_layer:
+ layer_outputs = (None, None)
+
+ if output_attentions:
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+ hidden_states = self.layer_norm(hidden_states)
+
+ if output_hidden_states:
+ all_hidden_states = all_hidden_states + (hidden_states,)
+
+ if not return_dict:
+ return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+ return BaseModelOutput(
+ last_hidden_state=hidden_states,
+ hidden_states=all_hidden_states,
+ attentions=all_self_attentions,
+ )
+
+
+class UniSpeechSatGumbelVectorQuantizer(nn.Module):
+ """
+ Vector quantization using gumbel softmax. See `[CATEGORICAL REPARAMETERIZATION WITH
+ GUMBEL-SOFTMAX](https://huggingface.co/papers/1611.01144) for more information.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ self.num_groups = config.num_codevector_groups
+ self.num_vars = config.num_codevectors_per_group
+
+ if config.codevector_dim % self.num_groups != 0:
+ raise ValueError(
+ f"`config.codevector_dim {config.codevector_dim} must be divisible "
+ f"by `config.num_codevector_groups` {self.num_groups} for concatenation"
+ )
+
+ # storage for codebook variables (codewords)
+ self.codevectors = nn.Parameter(
+ torch.FloatTensor(1, self.num_groups * self.num_vars, config.codevector_dim // self.num_groups)
+ )
+ self.weight_proj = nn.Linear(config.hidden_size, self.num_groups * self.num_vars)
+
+ # can be decayed for training
+ self.temperature = 2
+
+ @staticmethod
+ def _compute_perplexity(probs, mask=None):
+ marginal_probs = probs.mean(dim=0)
+ perplexity = torch.exp(-torch.sum(torch.xlogy(marginal_probs, marginal_probs), dim=-1)).sum()
+ return perplexity
+
+ def forward(self, hidden_states):
+ batch_size, sequence_length, hidden_size = hidden_states.shape
+
+ # project to codevector dim
+ hidden_states = self.weight_proj(hidden_states)
+ hidden_states = hidden_states.view(batch_size * sequence_length * self.num_groups, -1)
+
+ if self.training:
+ # sample code vector probs via gumbel in differentiateable way
+ codevector_probs = nn.functional.gumbel_softmax(
+ hidden_states.float(), tau=self.temperature, hard=True
+ ).type_as(hidden_states)
+
+ # compute perplexity
+ codevector_soft_dist = torch.softmax(
+ hidden_states.view(batch_size * sequence_length, self.num_groups, -1).float(), dim=-1
+ )
+ perplexity = self._compute_perplexity(codevector_soft_dist)
+ else:
+ # take argmax in non-differentiable way
+ # comptute hard codevector distribution (one hot)
+ codevector_idx = hidden_states.argmax(dim=-1)
+ codevector_probs = hidden_states.new_zeros(*hidden_states.shape).scatter_(
+ -1, codevector_idx.view(-1, 1), 1.0
+ )
+ codevector_probs = codevector_probs.view(batch_size * sequence_length, self.num_groups, -1)
+
+ perplexity = self._compute_perplexity(codevector_probs)
+
+ codevector_probs = codevector_probs.view(batch_size * sequence_length, -1)
+ # use probs to retrieve codevectors
+ codevectors_per_group = codevector_probs.unsqueeze(-1) * self.codevectors
+ codevectors = codevectors_per_group.view(batch_size * sequence_length, self.num_groups, self.num_vars, -1)
+ codevectors = codevectors.sum(-2).view(batch_size, sequence_length, -1)
+
+ return codevectors, perplexity
+
+
+@auto_docstring
+class UniSpeechSatPreTrainedModel(PreTrainedModel):
+ config: UniSpeechSatConfig
+ base_model_prefix = "unispeech_sat"
+ main_input_name = "input_values"
+ input_modalities = "audio"
+ supports_gradient_checkpointing = True
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ # gumbel softmax requires special init
+ if isinstance(module, UniSpeechSatGumbelVectorQuantizer):
+ init.normal_(module.weight_proj.weight, mean=0.0, std=1)
+ init.zeros_(module.weight_proj.bias)
+ init.uniform_(module.codevectors)
+ elif isinstance(module, UniSpeechSatPositionalConvEmbedding):
+ init.normal_(
+ module.conv.weight,
+ mean=0,
+ std=2 * math.sqrt(1 / (module.conv.kernel_size[0] * module.conv.in_channels)),
+ )
+ init.constant_(module.conv.bias, 0)
+ elif isinstance(module, UniSpeechSatFeatureProjection):
+ k = math.sqrt(1 / module.projection.in_features)
+ init.uniform_(module.projection.weight, a=-k, b=k)
+ init.uniform_(module.projection.bias, a=-k, b=k)
+ elif isinstance(module, nn.Linear):
+ init.normal_(module.weight, mean=0.0, std=self.config.initializer_range)
+
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, (nn.LayerNorm, nn.GroupNorm)):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ elif isinstance(module, nn.Conv1d):
+ init.kaiming_normal_(module.weight)
+
+ if module.bias is not None:
+ k = math.sqrt(module.groups / (module.in_channels * module.kernel_size[0]))
+ init.uniform_(module.bias, a=-k, b=k)
+
+ def _get_feat_extract_output_lengths(self, input_lengths: torch.LongTensor | int):
+ """
+ Computes the output length of the convolutional layers
+ """
+
+ def _conv_out_length(input_length, kernel_size, stride):
+ # 1D convolutional layer output length formula taken
+ # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html
+ return torch.div(input_length - kernel_size, stride, rounding_mode="floor") + 1
+
+ for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride):
+ input_lengths = _conv_out_length(input_lengths, kernel_size, stride)
+
+ return input_lengths
+
+ def _get_feature_vector_attention_mask(self, feature_vector_length: int, attention_mask: torch.LongTensor):
+ # Effectively attention_mask.sum(-1), but not inplace to be able to run
+ # on inference mode.
+ non_padded_lengths = attention_mask.cumsum(dim=-1)[:, -1]
+ output_lengths = self._get_feat_extract_output_lengths(non_padded_lengths).to(torch.long)
+ batch_size = attention_mask.shape[0]
+
+ attention_mask = torch.zeros(
+ (batch_size, feature_vector_length), dtype=attention_mask.dtype, device=attention_mask.device
+ )
+ # these two operations makes sure that all values before the output lengths idxs are attended to
+ attention_mask[(torch.arange(attention_mask.shape[0], device=attention_mask.device), output_lengths - 1)] = 1
+ attention_mask = attention_mask.flip([-1]).cumsum(-1).flip([-1]).bool()
+ return attention_mask
+
+
+def _compute_mask_indices(
+ shape: tuple[int, int],
+ mask_prob: float,
+ mask_length: int,
+ attention_mask: torch.LongTensor | None = None,
+ min_masks: int = 0,
+) -> np.ndarray:
+ """
+ Computes random mask spans for a given shape. Used to implement [SpecAugment: A Simple Data Augmentation Method for
+ ASR](https://huggingface.co/papers/1904.08779). Note that this method is not optimized to run on TPU and should be run on
+ CPU as part of the preprocessing during training.
+
+ Args:
+ shape: The shape for which to compute masks. This should be of a tuple of size 2 where
+ the first element is the batch size and the second element is the length of the axis to span.
+ mask_prob: The percentage of the whole axis (between 0 and 1) which will be masked. The number of
+ independently generated mask spans of length `mask_length` is computed by
+ `mask_prob*shape[1]/mask_length`. Note that due to overlaps, `mask_prob` is an upper bound and the
+ actual percentage will be smaller.
+ mask_length: size of the mask
+ min_masks: minimum number of masked spans
+ attention_mask: A (right-padded) attention mask which independently shortens the feature axis of
+ each batch dimension.
+ """
+ batch_size, sequence_length = shape
+
+ if mask_length < 1:
+ raise ValueError("`mask_length` has to be bigger than 0.")
+
+ if mask_length > sequence_length:
+ raise ValueError(
+ f"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length}"
+ f" and `sequence_length`: {sequence_length}`"
+ )
+
+ # epsilon is used for probabilistic rounding
+ epsilon = np.random.rand(1).item()
+
+ def compute_num_masked_span(input_length):
+ """Given input length, compute how many spans should be masked"""
+ num_masked_span = int(mask_prob * input_length / mask_length + epsilon)
+ num_masked_span = max(num_masked_span, min_masks)
+
+ # make sure num masked span <= sequence_length
+ if num_masked_span * mask_length > sequence_length:
+ num_masked_span = sequence_length // mask_length
+
+ # make sure num_masked span is also <= input_length - (mask_length - 1)
+ if input_length - (mask_length - 1) < num_masked_span:
+ num_masked_span = max(input_length - (mask_length - 1), 0)
+
+ return num_masked_span
+
+ # compute number of masked spans in batch
+ input_lengths = (
+ attention_mask.detach().sum(-1).tolist()
+ if attention_mask is not None
+ else [sequence_length for _ in range(batch_size)]
+ )
+
+ # SpecAugment mask to fill
+ spec_aug_mask = np.zeros((batch_size, sequence_length), dtype=bool)
+ spec_aug_mask_idxs = []
+
+ max_num_masked_span = compute_num_masked_span(sequence_length)
+
+ if max_num_masked_span == 0:
+ return spec_aug_mask
+
+ for input_length in input_lengths:
+ # compute num of masked spans for this input
+ num_masked_span = compute_num_masked_span(input_length)
+
+ # get random indices to mask
+ spec_aug_mask_idx = np.random.choice(
+ np.arange(input_length - (mask_length - 1)), num_masked_span, replace=False
+ )
+
+ # pick first sampled index that will serve as a dummy index to pad vector
+ # to ensure same dimension for all batches due to probabilistic rounding
+ # Picking first sample just pads those vectors twice.
+ if len(spec_aug_mask_idx) == 0:
+ # this case can only happen if `input_length` is strictly smaller then
+ # `sequence_length` in which case the last token has to be a padding
+ # token which we can use as a dummy mask id
+ dummy_mask_idx = sequence_length - 1
+ else:
+ dummy_mask_idx = spec_aug_mask_idx[0]
+
+ spec_aug_mask_idx = np.concatenate(
+ [spec_aug_mask_idx, np.ones(max_num_masked_span - num_masked_span, dtype=np.int32) * dummy_mask_idx]
+ )
+ spec_aug_mask_idxs.append(spec_aug_mask_idx)
+
+ spec_aug_mask_idxs = np.array(spec_aug_mask_idxs)
+
+ # expand masked indices to masked spans
+ spec_aug_mask_idxs = np.broadcast_to(
+ spec_aug_mask_idxs[:, :, None], (batch_size, max_num_masked_span, mask_length)
+ )
+ spec_aug_mask_idxs = spec_aug_mask_idxs.reshape(batch_size, max_num_masked_span * mask_length)
+
+ # add offset to the starting indexes so that indexes now create a span
+ offsets = np.arange(mask_length)[None, None, :]
+ offsets = np.broadcast_to(offsets, (batch_size, max_num_masked_span, mask_length)).reshape(
+ batch_size, max_num_masked_span * mask_length
+ )
+ spec_aug_mask_idxs = spec_aug_mask_idxs + offsets
+
+ # ensure that we cannot have indices larger than sequence_length
+ if spec_aug_mask_idxs.max() > sequence_length - 1:
+ spec_aug_mask_idxs[spec_aug_mask_idxs > sequence_length - 1] = sequence_length - 1
+
+ # scatter indices to mask
+ np.put_along_axis(spec_aug_mask, spec_aug_mask_idxs, 1, -1)
+
+ return spec_aug_mask
+
+
+UniSpeechSatBaseModelOutput = Wav2Vec2BaseModelOutput
+
+
+@auto_docstring
+class UniSpeechSatModel(UniSpeechSatPreTrainedModel):
+ def __init__(self, config: UniSpeechSatConfig):
+ super().__init__(config)
+ self.config = config
+ self.feature_extractor = UniSpeechSatFeatureEncoder(config)
+ self.feature_projection = UniSpeechSatFeatureProjection(config)
+
+ self.masked_spec_embed = nn.Parameter(torch.Tensor(config.hidden_size).uniform_())
+
+ if config.do_stable_layer_norm:
+ self.encoder = UniSpeechSatEncoderStableLayerNorm(config)
+ else:
+ self.encoder = UniSpeechSatEncoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _mask_hidden_states(
+ self,
+ hidden_states: torch.FloatTensor,
+ mask_time_indices: torch.FloatTensor | None = None,
+ attention_mask: torch.LongTensor | None = None,
+ ):
+ """
+ Masks extracted features along time axis and/or along feature axis according to
+ [SpecAugment](https://huggingface.co/papers/1904.08779).
+ """
+
+ # `config.apply_spec_augment` can set masking to False
+ if not getattr(self.config, "apply_spec_augment", True):
+ return hidden_states
+
+ # generate indices & apply SpecAugment along time axis
+ batch_size, sequence_length, hidden_size = hidden_states.size()
+
+ if mask_time_indices is not None:
+ # apply SpecAugment along time axis with given mask_time_indices
+ hidden_states[mask_time_indices] = self.masked_spec_embed.to(hidden_states.dtype)
+ elif self.config.mask_time_prob > 0 and self.training:
+ mask_time_indices = _compute_mask_indices(
+ (batch_size, sequence_length),
+ mask_prob=self.config.mask_time_prob,
+ mask_length=self.config.mask_time_length,
+ attention_mask=attention_mask,
+ min_masks=self.config.mask_time_min_masks,
+ )
+ mask_time_indices = torch.tensor(mask_time_indices, device=hidden_states.device, dtype=torch.bool)
+ hidden_states[mask_time_indices] = self.masked_spec_embed.to(hidden_states.dtype)
+
+ if self.config.mask_feature_prob > 0 and self.training:
+ # generate indices & apply SpecAugment along feature axis
+ mask_feature_indices = _compute_mask_indices(
+ (batch_size, hidden_size),
+ mask_prob=self.config.mask_feature_prob,
+ mask_length=self.config.mask_feature_length,
+ min_masks=self.config.mask_feature_min_masks,
+ )
+ mask_feature_indices = torch.tensor(mask_feature_indices, device=hidden_states.device, dtype=torch.bool)
+ mask_feature_indices = mask_feature_indices[:, None].expand(-1, sequence_length, -1)
+ hidden_states[mask_feature_indices] = 0
+
+ return hidden_states
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ mask_time_indices: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | UniSpeechSatBaseModelOutput:
+ r"""
+ mask_time_indices (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices to mask extracted features for contrastive loss. When in training mode, model learns to predict
+ masked extracted features in *config.proj_codevector_dim* space.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ extract_features = self.feature_extractor(input_values)
+ extract_features = extract_features.transpose(1, 2)
+
+ if attention_mask is not None:
+ # compute reduced attention_mask corresponding to feature vectors
+ attention_mask = self._get_feature_vector_attention_mask(extract_features.shape[1], attention_mask)
+
+ hidden_states, extract_features = self.feature_projection(extract_features)
+ hidden_states = self._mask_hidden_states(
+ hidden_states, mask_time_indices=mask_time_indices, attention_mask=attention_mask
+ )
+
+ encoder_outputs = self.encoder(
+ hidden_states,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ if not return_dict:
+ return (hidden_states, extract_features) + encoder_outputs[1:]
+
+ return UniSpeechSatBaseModelOutput(
+ last_hidden_state=hidden_states,
+ extract_features=extract_features,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ UniSpeechSat Model with a vector-quantization module and ctc loss for pre-training.
+ """
+)
+class UniSpeechSatForPreTraining(UniSpeechSatPreTrainedModel):
+ def __init__(self, config: UniSpeechSatConfig):
+ super().__init__(config)
+ self.unispeech_sat = UniSpeechSatModel(config)
+ self.dropout_features = nn.Dropout(config.feat_quantizer_dropout)
+
+ self.quantizer = UniSpeechSatGumbelVectorQuantizer(config)
+ self.project_q = nn.Linear(config.codevector_dim, config.proj_codevector_dim)
+ self.project_hid = nn.Linear(config.hidden_size, config.proj_codevector_dim)
+
+ self.dropout = nn.Dropout(config.final_dropout)
+
+ self.speaker_proj = nn.Linear(config.hidden_size, config.codevector_dim)
+ self.label_embeddings_concat = nn.Parameter(torch.FloatTensor(config.num_clusters, config.codevector_dim))
+ self.label_embeddings_concat.data.zero_()
+
+ self.layer_norm_for_extract = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ if self.config.do_stable_layer_norm:
+ self.layer_norm_for_extract.requires_grad = False
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def set_gumbel_temperature(self, temperature: int):
+ """
+ Set the Gumbel softmax temperature to a given value. Only necessary for training
+ """
+ self.quantizer.temperature = temperature
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech_sat.feature_extractor._freeze_parameters()
+
+ @staticmethod
+ def compute_contrastive_logits(
+ target_features: torch.FloatTensor,
+ negative_features: torch.FloatTensor,
+ predicted_features: torch.FloatTensor,
+ temperature: int = 1,
+ ):
+ """
+ Compute logits for contrastive loss based using cosine similarity as the distance measure between
+ `[positive_feature, negative_features]` and `[predicted_features]`. Additionally, temperature can be applied.
+ """
+ target_features = torch.cat([target_features, negative_features], dim=0)
+
+ logits = torch.cosine_similarity(predicted_features.float(), target_features.float(), dim=-1)
+ logits = logits.type_as(target_features)
+
+ # apply temperature
+ logits = logits / temperature
+ return logits
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | UniSpeechSatForPreTrainingOutput:
+ r"""
+ Example:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoFeatureExtractor, UniSpeechSatForPreTraining
+ >>> from transformers.models.unispeech_sat.modeling_unispeech_sat import _compute_mask_indices
+
+ >>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base")
+ >>> model = UniSpeechSatForPreTraining.from_pretrained("microsoft/unispeech-sat-base")
+ >>> # TODO: Add full pretraining example
+ ```"""
+
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.unispeech_sat(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ transformer_features = outputs[0]
+
+ # quantize all (unmasked) extracted features and project to final vq dim
+ extract_features = self.dropout_features(outputs[1])
+
+ # TODO(PVP) - add pretraining logic and add to tests
+ logits = extract_features
+ loss = quantized_features = codevector_perplexity = None
+
+ if not return_dict:
+ if loss is not None:
+ return (loss, logits, transformer_features, quantized_features, codevector_perplexity) + outputs[2:]
+ return (logits, transformer_features, quantized_features, codevector_perplexity) + outputs[2:]
+
+ return UniSpeechSatForPreTrainingOutput(
+ loss=loss,
+ logits=logits,
+ projected_states=transformer_features,
+ projected_quantized_states=quantized_features,
+ codevector_perplexity=codevector_perplexity,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+_HIDDEN_STATES_START_POSITION = 2
+
+
+@auto_docstring(
+ custom_intro="""
+ UniSpeechSat Model with a `language modeling` head on top for Connectionist Temporal Classification (CTC).
+ """
+)
+class UniSpeechSatForCTC(UniSpeechSatPreTrainedModel):
+ def __init__(self, config, target_lang: str | None = None):
+ r"""
+ target_lang (`str`, *optional*):
+ Language id of adapter weights. Adapter weights are stored in the format adapter.<lang>.safetensors or
+ adapter.<lang>.bin. Only relevant when using an instance of [`UniSpeechSatForCTC`] with adapters. Uses 'eng' by
+ default.
+ """
+ super().__init__(config)
+
+ self.unispeech_sat = UniSpeechSatModel(config)
+ self.dropout = nn.Dropout(config.final_dropout)
+
+ self.target_lang = target_lang
+
+ if config.vocab_size is None:
+ raise ValueError(
+ f"You are trying to instantiate {self.__class__} with a configuration that "
+ "does not define the vocabulary size of the language model head. Please "
+ "instantiate the model as follows: `UniSpeechSatForCTC.from_pretrained(..., vocab_size=vocab_size)`. "
+ "or define `vocab_size` of your model's configuration."
+ )
+ output_hidden_size = (
+ config.output_hidden_size if hasattr(config, "add_adapter") and config.add_adapter else config.hidden_size
+ )
+ self.lm_head = nn.Linear(output_hidden_size, config.vocab_size)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def tie_weights(self, **kwargs):
+ """
+ This method overwrites [`~PreTrainedModel.tie_weights`] so that adapter weights can be correctly loaded when
+ passing `target_lang=...` to `from_pretrained(...)`.
+
+ This method is **not** supposed to be called by the user and is prone to be changed in the future.
+ """
+
+ if get_torch_context_manager_or_global_device() == torch.device("meta"):
+ return
+
+ # Note that `tie_weights` is usually used to tie input and output embedding weights. The method is re-purposed to
+ # correctly load adapter layers for UniSpeechSat so that we do not have to introduce a new API to
+ # [`PreTrainedModel`]. While slightly hacky, UniSpeechSat never has to tie input and output embeddings, so that it is
+ # ok to repurpose this function here.
+ target_lang = self.target_lang
+
+ if target_lang is not None and getattr(self.config, "adapter_attn_dim", None) is None:
+ raise ValueError(f"Cannot pass `target_lang`: {target_lang} if `config.adapter_attn_dim` is not defined.")
+ elif target_lang is None and getattr(self.config, "adapter_attn_dim", None) is not None:
+ logger.info("By default `target_lang` is set to 'eng'.")
+ elif target_lang is not None:
+ self.load_adapter(target_lang, force_load=True)
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech_sat.feature_extractor._freeze_parameters()
+
+ def freeze_base_model(self):
+ """
+ Calling this function will disable the gradient computation for the base model so that its parameters will not
+ be updated during training. Only the classification head will be updated.
+ """
+ for param in self.unispeech_sat.parameters():
+ param.requires_grad = False
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ labels: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple | CausalLMOutput:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, target_length)`, *optional*):
+ Labels for connectionist temporal classification. Note that `target_length` has to be smaller or equal to
+ the sequence length of the output logits. Indices are selected in `[-100, 0, ..., config.vocab_size - 1]`.
+ All labels set to `-100` are ignored (masked), the loss is only computed for labels in `[0, ...,
+ config.vocab_size - 1]`.
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ if labels is not None and labels.max() >= self.config.vocab_size:
+ raise ValueError(f"Label values must be <= vocab_size: {self.config.vocab_size}")
+
+ outputs = self.unispeech_sat(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = outputs[0]
+ hidden_states = self.dropout(hidden_states)
+
+ logits = self.lm_head(hidden_states)
+
+ loss = None
+ if labels is not None:
+ # retrieve loss input_lengths from attention_mask
+ attention_mask = (
+ attention_mask if attention_mask is not None else torch.ones_like(input_values, dtype=torch.long)
+ )
+ input_lengths = self._get_feat_extract_output_lengths(attention_mask.sum(-1)).to(torch.long)
+
+ # assuming that padded tokens are filled with -100
+ # when not being attended to
+ labels_mask = labels >= 0
+ target_lengths = labels_mask.sum(-1)
+ flattened_targets = labels.masked_select(labels_mask)
+
+ # ctc_loss doesn't support fp16
+ log_probs = nn.functional.log_softmax(logits, dim=-1, dtype=torch.float32).transpose(0, 1)
+
+ with torch.backends.cudnn.flags(enabled=False):
+ loss = nn.functional.ctc_loss(
+ log_probs,
+ flattened_targets,
+ input_lengths,
+ target_lengths,
+ blank=self.config.pad_token_id,
+ reduction=self.config.ctc_loss_reduction,
+ zero_infinity=self.config.ctc_zero_infinity,
+ )
+
+ if not return_dict:
+ output = (logits,) + outputs[_HIDDEN_STATES_START_POSITION:]
+ return ((loss,) + output) if loss is not None else output
+
+ return CausalLMOutput(
+ loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ UniSpeechSat Model with a sequence classification head on top (a linear layer over the pooled output) for tasks like
+ SUPERB Keyword Spotting.
+ """
+)
+class UniSpeechSatForSequenceClassification(UniSpeechSatPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ if hasattr(config, "add_adapter") and config.add_adapter:
+ raise ValueError(
+ "Sequence classification does not support the use of UniSpeechSat adapters (config.add_adapter=True)"
+ )
+ self.unispeech_sat = UniSpeechSatModel(config)
+ num_layers = config.num_hidden_layers + 1 # transformer layers + input embeddings
+ if config.use_weighted_layer_sum:
+ self.layer_weights = nn.Parameter(torch.ones(num_layers) / num_layers)
+ self.projector = nn.Linear(config.hidden_size, config.classifier_proj_size)
+ self.classifier = nn.Linear(config.classifier_proj_size, config.num_labels)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech_sat.feature_extractor._freeze_parameters()
+
+ def freeze_base_model(self):
+ """
+ Calling this function will disable the gradient computation for the base model so that its parameters will not
+ be updated during training. Only the classification head will be updated.
+ """
+ for param in self.unispeech_sat.parameters():
+ param.requires_grad = False
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ labels: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple | SequenceClassifierOutput:
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Float values of input raw speech waveform. Values can be obtained by loading a `.flac` or `.wav` audio file
+ into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library
+ (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
+ To prepare the array into `input_values`, the [`AutoProcessor`] should be used for padding and conversion
+ into a tensor of type `torch.FloatTensor`. See [`UniSpeechSatProcessor.__call__`] for details.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = True if self.config.use_weighted_layer_sum else output_hidden_states
+
+ outputs = self.unispeech_sat(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if self.config.use_weighted_layer_sum:
+ hidden_states = outputs[_HIDDEN_STATES_START_POSITION]
+ hidden_states = torch.stack(hidden_states, dim=1)
+ norm_weights = nn.functional.softmax(self.layer_weights, dim=-1)
+ hidden_states = (hidden_states * norm_weights.view(-1, 1, 1)).sum(dim=1)
+ else:
+ hidden_states = outputs[0]
+
+ hidden_states = self.projector(hidden_states)
+ if attention_mask is None:
+ pooled_output = hidden_states.mean(dim=1)
+ else:
+ padding_mask = self._get_feature_vector_attention_mask(hidden_states.shape[1], attention_mask)
+ expand_padding_mask = padding_mask.unsqueeze(-1).repeat(1, 1, hidden_states.shape[2])
+ hidden_states[~expand_padding_mask] = 0.0
+ pooled_output = hidden_states.sum(dim=1) / padding_mask.sum(dim=1).view(-1, 1)
+
+ logits = self.classifier(pooled_output)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.config.num_labels), labels.view(-1))
+
+ if not return_dict:
+ output = (logits,) + outputs[_HIDDEN_STATES_START_POSITION:]
+ return ((loss,) + output) if loss is not None else output
+
+ return SequenceClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@auto_docstring
+class UniSpeechSatForAudioFrameClassification(UniSpeechSatPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ if hasattr(config, "add_adapter") and config.add_adapter:
+ raise ValueError(
+ "Audio frame classification does not support the use of UniSpeechSat adapters (config.add_adapter=True)"
+ )
+ self.unispeech_sat = UniSpeechSatModel(config)
+ num_layers = config.num_hidden_layers + 1 # transformer layers + input embeddings
+ if config.use_weighted_layer_sum:
+ self.layer_weights = nn.Parameter(torch.ones(num_layers) / num_layers)
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+ self.num_labels = config.num_labels
+
+ self.post_init()
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech_sat.feature_extractor._freeze_parameters()
+
+ def freeze_base_model(self):
+ """
+ Calling this function will disable the gradient computation for the base model so that its parameters will not
+ be updated during training. Only the classification head will be updated.
+ """
+ for param in self.unispeech_sat.parameters():
+ param.requires_grad = False
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ labels: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | TokenClassifierOutput:
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Float values of input raw speech waveform. Values can be obtained by loading a `.flac` or `.wav` audio file
+ into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library
+ (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
+ To prepare the array into `input_values`, the [`AutoProcessor`] should be used for padding and conversion
+ into a tensor of type `torch.FloatTensor`. See [`UniSpeechSatProcessor.__call__`] for details.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = True if self.config.use_weighted_layer_sum else output_hidden_states
+
+ outputs = self.unispeech_sat(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if self.config.use_weighted_layer_sum:
+ hidden_states = outputs[_HIDDEN_STATES_START_POSITION]
+ hidden_states = torch.stack(hidden_states, dim=1)
+ norm_weights = nn.functional.softmax(self.layer_weights, dim=-1)
+ hidden_states = (hidden_states * norm_weights.view(-1, 1, 1)).sum(dim=1)
+ else:
+ hidden_states = outputs[0]
+
+ logits = self.classifier(hidden_states)
+
+ loss = None
+ if labels is not None:
+ loss_fct = CrossEntropyLoss()
+ loss = loss_fct(logits.view(-1, self.num_labels), torch.argmax(labels.view(-1, self.num_labels), axis=1))
+
+ if not return_dict:
+ output = (logits,) + outputs[_HIDDEN_STATES_START_POSITION:]
+ return output
+
+ return TokenClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+class AMSoftmaxLoss(nn.Module):
+ def __init__(self, input_dim, num_labels, scale=30.0, margin=0.4):
+ super().__init__()
+ self.scale = scale
+ self.margin = margin
+ self.num_labels = num_labels
+ self.weight = nn.Parameter(torch.randn(input_dim, num_labels), requires_grad=True)
+ self.loss = nn.CrossEntropyLoss()
+
+ def forward(self, hidden_states, labels):
+ labels = labels.flatten()
+ weight = nn.functional.normalize(self.weight, dim=0)
+ hidden_states = nn.functional.normalize(hidden_states, dim=1)
+ cos_theta = torch.mm(hidden_states, weight)
+ psi = cos_theta - self.margin
+
+ onehot = nn.functional.one_hot(labels, self.num_labels)
+ logits = self.scale * torch.where(onehot.bool(), psi, cos_theta)
+ loss = self.loss(logits, labels)
+
+ return loss
+
+
+class TDNNLayer(nn.Module):
+ def __init__(self, config, layer_id=0):
+ super().__init__()
+ self.in_conv_dim = config.tdnn_dim[layer_id - 1] if layer_id > 0 else config.tdnn_dim[layer_id]
+ self.out_conv_dim = config.tdnn_dim[layer_id]
+ self.kernel_size = config.tdnn_kernel[layer_id]
+ self.dilation = config.tdnn_dilation[layer_id]
+
+ self.kernel = nn.Linear(self.in_conv_dim * self.kernel_size, self.out_conv_dim)
+ self.activation = nn.ReLU()
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ if is_peft_available():
+ from peft.tuners.lora import LoraLayer
+
+ if is_peft_available():
+ if isinstance(self.kernel, LoraLayer):
+ warnings.warn(
+ "Detected LoRA on TDNNLayer. LoRA weights won't be applied due to optimization. "
+ "You should exclude TDNNLayer from LoRA's target modules.",
+ )
+
+ # for backward compatibility, we keep nn.Linear but call F.conv1d for speed up
+ hidden_states = hidden_states.transpose(1, 2)
+ weight = self.kernel.weight.view(self.out_conv_dim, self.kernel_size, self.in_conv_dim).transpose(1, 2)
+ hidden_states = nn.functional.conv1d(hidden_states, weight, self.kernel.bias, dilation=self.dilation)
+ hidden_states = hidden_states.transpose(1, 2)
+
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+@auto_docstring(
+ custom_intro="""
+ UniSpeechSat Model with an XVector feature extraction head on top for tasks like Speaker Verification.
+ """
+)
+class UniSpeechSatForXVector(UniSpeechSatPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.unispeech_sat = UniSpeechSatModel(config)
+ num_layers = config.num_hidden_layers + 1 # transformer layers + input embeddings
+ if config.use_weighted_layer_sum:
+ self.layer_weights = nn.Parameter(torch.ones(num_layers) / num_layers)
+ self.projector = nn.Linear(config.hidden_size, config.tdnn_dim[0])
+
+ tdnn_layers = [TDNNLayer(config, i) for i in range(len(config.tdnn_dim))]
+ self.tdnn = nn.ModuleList(tdnn_layers)
+
+ self.feature_extractor = nn.Linear(config.tdnn_dim[-1] * 2, config.xvector_output_dim)
+ self.classifier = nn.Linear(config.xvector_output_dim, config.xvector_output_dim)
+
+ self.objective = AMSoftmaxLoss(config.xvector_output_dim, config.num_labels)
+
+ self.post_init()
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech_sat.feature_extractor._freeze_parameters()
+
+ def freeze_base_model(self):
+ """
+ Calling this function will disable the gradient computation for the base model so that its parameters will not
+ be updated during training. Only the classification head will be updated.
+ """
+ for param in self.unispeech_sat.parameters():
+ param.requires_grad = False
+
+ def _get_tdnn_output_lengths(self, input_lengths: torch.LongTensor | int):
+ """
+ Computes the output length of the TDNN layers
+ """
+
+ def _conv_out_length(input_length, kernel_size, stride):
+ # 1D convolutional layer output length formula taken
+ # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html
+ return (input_length - kernel_size) // stride + 1
+
+ for kernel_size in self.config.tdnn_kernel:
+ input_lengths = _conv_out_length(input_lengths, kernel_size, 1)
+
+ return input_lengths
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ labels: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple | XVectorOutput:
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Float values of input raw speech waveform. Values can be obtained by loading a `.flac` or `.wav` audio file
+ into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library
+ (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
+ To prepare the array into `input_values`, the [`AutoProcessor`] should be used for padding and conversion
+ into a tensor of type `torch.FloatTensor`. See [`UniSpeechSatProcessor.__call__`] for details.
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+ """
+
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = True if self.config.use_weighted_layer_sum else output_hidden_states
+
+ outputs = self.unispeech_sat(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ if self.config.use_weighted_layer_sum:
+ hidden_states = outputs[_HIDDEN_STATES_START_POSITION]
+ hidden_states = torch.stack(hidden_states, dim=1)
+ norm_weights = nn.functional.softmax(self.layer_weights, dim=-1)
+ hidden_states = (hidden_states * norm_weights.view(-1, 1, 1)).sum(dim=1)
+ else:
+ hidden_states = outputs[0]
+
+ hidden_states = self.projector(hidden_states)
+
+ for tdnn_layer in self.tdnn:
+ hidden_states = tdnn_layer(hidden_states)
+
+ # Statistic Pooling
+ if attention_mask is None:
+ mean_features = hidden_states.mean(dim=1)
+ std_features = hidden_states.std(dim=1)
+ else:
+ feat_extract_output_lengths = self._get_feat_extract_output_lengths(attention_mask.sum(dim=1))
+ tdnn_output_lengths = self._get_tdnn_output_lengths(feat_extract_output_lengths)
+ mean_features = []
+ std_features = []
+ for i, length in enumerate(tdnn_output_lengths):
+ mean_features.append(hidden_states[i, :length].mean(dim=0))
+ std_features.append(hidden_states[i, :length].std(dim=0))
+ mean_features = torch.stack(mean_features)
+ std_features = torch.stack(std_features)
+ statistic_pooling = torch.cat([mean_features, std_features], dim=-1)
+
+ output_embeddings = self.feature_extractor(statistic_pooling)
+ logits = self.classifier(output_embeddings)
+
+ loss = None
+ if labels is not None:
+ loss = self.objective(logits, labels)
+
+ if not return_dict:
+ output = (logits, output_embeddings) + outputs[_HIDDEN_STATES_START_POSITION:]
+ return ((loss,) + output) if loss is not None else output
+
+ return XVectorOutput(
+ loss=loss,
+ logits=logits,
+ embeddings=output_embeddings,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = [
+ "UniSpeechSatForAudioFrameClassification",
+ "UniSpeechSatForCTC",
+ "UniSpeechSatForPreTraining",
+ "UniSpeechSatForSequenceClassification",
+ "UniSpeechSatForXVector",
+ "UniSpeechSatModel",
+ "UniSpeechSatPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/unispeech_sat/modular_unispeech_sat.py b/lib/python3.11/site-packages/transformers/models/unispeech_sat/modular_unispeech_sat.py
new file mode 100644
index 0000000000000000000000000000000000000000..b90470695df177c8ec9d95605b166fa1d4c907a1
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/unispeech_sat/modular_unispeech_sat.py
@@ -0,0 +1,444 @@
+# Copyright 2021 The Fairseq Authors and the HuggingFace Inc. 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.
+"""PyTorch UniSpeechSat model."""
+
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+
+from ... import initialization as init
+from ...modeling_outputs import ModelOutput, Wav2Vec2BaseModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring, logging
+from ..wav2vec2.modeling_wav2vec2 import (
+ Wav2Vec2Encoder,
+ Wav2Vec2EncoderStableLayerNorm,
+ Wav2Vec2FeatureEncoder,
+ Wav2Vec2FeatureProjection,
+ Wav2Vec2ForAudioFrameClassification,
+ Wav2Vec2ForCTC,
+ Wav2Vec2ForSequenceClassification,
+ Wav2Vec2ForXVector,
+ Wav2Vec2GumbelVectorQuantizer,
+ Wav2Vec2Model,
+ Wav2Vec2PositionalConvEmbedding,
+)
+from .configuration_unispeech_sat import UniSpeechSatConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+_HIDDEN_STATES_START_POSITION = 2
+
+
+@auto_docstring(
+ custom_intro="""
+ Output type of [`UniSpeechSatForPreTrainingOutput`], with potential hidden states and attentions.
+ """
+)
+@dataclass
+class UniSpeechSatForPreTrainingOutput(ModelOutput):
+ r"""
+ loss (*optional*, returned when model is in train mode, `torch.FloatTensor` of shape `(1,)`):
+ Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the [official
+ paper](https://huggingface.co/papers/2006.11477).
+ logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`, *optional*):
+ Prediction scores of the contrastive loss model, i.e. the output of the model before the final softmax.
+ projected_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`):
+ Hidden-states of the model projected to *config.proj_codevector_dim* that can be used to predict the masked
+ projected quantized states.
+ projected_quantized_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.proj_codevector_dim)`):
+ Quantized extracted feature vectors projected to *config.proj_codevector_dim* representing the positive
+ target vectors for contrastive loss.
+ codevector_perplexity (`torch.FloatTensor` of shape `(1,)`):
+ The perplexity of the codevector distribution, used to measure the diversity of the codebook.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ projected_states: torch.FloatTensor | None = None
+ projected_quantized_states: torch.FloatTensor | None = None
+ codevector_perplexity: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+class UniSpeechSatPositionalConvEmbedding(Wav2Vec2PositionalConvEmbedding):
+ pass
+
+
+class UniSpeechSatFeatureEncoder(Wav2Vec2FeatureEncoder):
+ pass
+
+
+class UniSpeechSatFeatureProjection(Wav2Vec2FeatureProjection):
+ pass
+
+
+class UniSpeechSatEncoder(Wav2Vec2Encoder):
+ pass
+
+
+class UniSpeechSatEncoderStableLayerNorm(Wav2Vec2EncoderStableLayerNorm):
+ pass
+
+
+class UniSpeechSatGumbelVectorQuantizer(Wav2Vec2GumbelVectorQuantizer):
+ def __init__(self, config):
+ super().__init__(config)
+ self.weight_proj = nn.Linear(config.hidden_size, self.num_groups * self.num_vars)
+
+ @staticmethod
+ def _compute_perplexity(probs, mask=None):
+ marginal_probs = probs.mean(dim=0)
+ perplexity = torch.exp(-torch.sum(torch.xlogy(marginal_probs, marginal_probs), dim=-1)).sum()
+ return perplexity
+
+ def forward(self, hidden_states):
+ batch_size, sequence_length, hidden_size = hidden_states.shape
+
+ # project to codevector dim
+ hidden_states = self.weight_proj(hidden_states)
+ hidden_states = hidden_states.view(batch_size * sequence_length * self.num_groups, -1)
+
+ if self.training:
+ # sample code vector probs via gumbel in differentiateable way
+ codevector_probs = nn.functional.gumbel_softmax(
+ hidden_states.float(), tau=self.temperature, hard=True
+ ).type_as(hidden_states)
+
+ # compute perplexity
+ codevector_soft_dist = torch.softmax(
+ hidden_states.view(batch_size * sequence_length, self.num_groups, -1).float(), dim=-1
+ )
+ perplexity = self._compute_perplexity(codevector_soft_dist)
+ else:
+ # take argmax in non-differentiable way
+ # comptute hard codevector distribution (one hot)
+ codevector_idx = hidden_states.argmax(dim=-1)
+ codevector_probs = hidden_states.new_zeros(*hidden_states.shape).scatter_(
+ -1, codevector_idx.view(-1, 1), 1.0
+ )
+ codevector_probs = codevector_probs.view(batch_size * sequence_length, self.num_groups, -1)
+
+ perplexity = self._compute_perplexity(codevector_probs)
+
+ codevector_probs = codevector_probs.view(batch_size * sequence_length, -1)
+ # use probs to retrieve codevectors
+ codevectors_per_group = codevector_probs.unsqueeze(-1) * self.codevectors
+ codevectors = codevectors_per_group.view(batch_size * sequence_length, self.num_groups, self.num_vars, -1)
+ codevectors = codevectors.sum(-2).view(batch_size, sequence_length, -1)
+
+ return codevectors, perplexity
+
+
+@auto_docstring
+class UniSpeechSatPreTrainedModel(PreTrainedModel):
+ config: UniSpeechSatConfig
+ base_model_prefix = "unispeech_sat"
+ main_input_name = "input_values"
+ input_modalities = "audio"
+ supports_gradient_checkpointing = True
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ """Initialize the weights"""
+ # gumbel softmax requires special init
+ if isinstance(module, UniSpeechSatGumbelVectorQuantizer):
+ init.normal_(module.weight_proj.weight, mean=0.0, std=1)
+ init.zeros_(module.weight_proj.bias)
+ init.uniform_(module.codevectors)
+ elif isinstance(module, UniSpeechSatPositionalConvEmbedding):
+ init.normal_(
+ module.conv.weight,
+ mean=0,
+ std=2 * math.sqrt(1 / (module.conv.kernel_size[0] * module.conv.in_channels)),
+ )
+ init.constant_(module.conv.bias, 0)
+ elif isinstance(module, UniSpeechSatFeatureProjection):
+ k = math.sqrt(1 / module.projection.in_features)
+ init.uniform_(module.projection.weight, a=-k, b=k)
+ init.uniform_(module.projection.bias, a=-k, b=k)
+ elif isinstance(module, nn.Linear):
+ init.normal_(module.weight, mean=0.0, std=self.config.initializer_range)
+
+ if module.bias is not None:
+ init.zeros_(module.bias)
+ elif isinstance(module, (nn.LayerNorm, nn.GroupNorm)):
+ init.zeros_(module.bias)
+ init.ones_(module.weight)
+ elif isinstance(module, nn.Conv1d):
+ init.kaiming_normal_(module.weight)
+
+ if module.bias is not None:
+ k = math.sqrt(module.groups / (module.in_channels * module.kernel_size[0]))
+ init.uniform_(module.bias, a=-k, b=k)
+
+ def _get_feat_extract_output_lengths(self, input_lengths: torch.LongTensor | int):
+ """
+ Computes the output length of the convolutional layers
+ """
+
+ def _conv_out_length(input_length, kernel_size, stride):
+ # 1D convolutional layer output length formula taken
+ # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html
+ return torch.div(input_length - kernel_size, stride, rounding_mode="floor") + 1
+
+ for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride):
+ input_lengths = _conv_out_length(input_lengths, kernel_size, stride)
+
+ return input_lengths
+
+ def _get_feature_vector_attention_mask(self, feature_vector_length: int, attention_mask: torch.LongTensor):
+ # Effectively attention_mask.sum(-1), but not inplace to be able to run
+ # on inference mode.
+ non_padded_lengths = attention_mask.cumsum(dim=-1)[:, -1]
+ output_lengths = self._get_feat_extract_output_lengths(non_padded_lengths).to(torch.long)
+ batch_size = attention_mask.shape[0]
+
+ attention_mask = torch.zeros(
+ (batch_size, feature_vector_length), dtype=attention_mask.dtype, device=attention_mask.device
+ )
+ # these two operations makes sure that all values before the output lengths idxs are attended to
+ attention_mask[(torch.arange(attention_mask.shape[0], device=attention_mask.device), output_lengths - 1)] = 1
+ attention_mask = attention_mask.flip([-1]).cumsum(-1).flip([-1]).bool()
+ return attention_mask
+
+
+UniSpeechSatBaseModelOutput = Wav2Vec2BaseModelOutput
+
+
+class UniSpeechSatModel(UniSpeechSatPreTrainedModel, Wav2Vec2Model):
+ def __init__(self, config: UniSpeechSatConfig):
+ UniSpeechSatPreTrainedModel.__init__(self, config)
+ self.config = config
+ self.feature_extractor = UniSpeechSatFeatureEncoder(config)
+ self.feature_projection = UniSpeechSatFeatureProjection(config)
+
+ self.masked_spec_embed = nn.Parameter(torch.Tensor(config.hidden_size).uniform_())
+
+ if config.do_stable_layer_norm:
+ self.encoder = UniSpeechSatEncoderStableLayerNorm(config)
+ else:
+ self.encoder = UniSpeechSatEncoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def freeze_feature_encoder(self):
+ raise AttributeError("Not needed for UniSpeechSat")
+
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ mask_time_indices: torch.FloatTensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | UniSpeechSatBaseModelOutput:
+ r"""
+ mask_time_indices (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Indices to mask extracted features for contrastive loss. When in training mode, model learns to predict
+ masked extracted features in *config.proj_codevector_dim* space.
+ """
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ extract_features = self.feature_extractor(input_values)
+ extract_features = extract_features.transpose(1, 2)
+
+ if attention_mask is not None:
+ # compute reduced attention_mask corresponding to feature vectors
+ attention_mask = self._get_feature_vector_attention_mask(extract_features.shape[1], attention_mask)
+
+ hidden_states, extract_features = self.feature_projection(extract_features)
+ hidden_states = self._mask_hidden_states(
+ hidden_states, mask_time_indices=mask_time_indices, attention_mask=attention_mask
+ )
+
+ encoder_outputs = self.encoder(
+ hidden_states,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+
+ hidden_states = encoder_outputs[0]
+
+ if not return_dict:
+ return (hidden_states, extract_features) + encoder_outputs[1:]
+
+ return UniSpeechSatBaseModelOutput(
+ last_hidden_state=hidden_states,
+ extract_features=extract_features,
+ hidden_states=encoder_outputs.hidden_states,
+ attentions=encoder_outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ UniSpeechSat Model with a vector-quantization module and ctc loss for pre-training.
+ """
+)
+class UniSpeechSatForPreTraining(UniSpeechSatPreTrainedModel):
+ def __init__(self, config: UniSpeechSatConfig):
+ super().__init__(config)
+ self.unispeech_sat = UniSpeechSatModel(config)
+ self.dropout_features = nn.Dropout(config.feat_quantizer_dropout)
+
+ self.quantizer = UniSpeechSatGumbelVectorQuantizer(config)
+ self.project_q = nn.Linear(config.codevector_dim, config.proj_codevector_dim)
+ self.project_hid = nn.Linear(config.hidden_size, config.proj_codevector_dim)
+
+ self.dropout = nn.Dropout(config.final_dropout)
+
+ self.speaker_proj = nn.Linear(config.hidden_size, config.codevector_dim)
+ self.label_embeddings_concat = nn.Parameter(torch.FloatTensor(config.num_clusters, config.codevector_dim))
+ self.label_embeddings_concat.data.zero_()
+
+ self.layer_norm_for_extract = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ if self.config.do_stable_layer_norm:
+ self.layer_norm_for_extract.requires_grad = False
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def set_gumbel_temperature(self, temperature: int):
+ """
+ Set the Gumbel softmax temperature to a given value. Only necessary for training
+ """
+ self.quantizer.temperature = temperature
+
+ def freeze_feature_encoder(self):
+ """
+ Calling this function will disable the gradient computation for the feature encoder so that its parameter will
+ not be updated during training.
+ """
+ self.unispeech_sat.feature_extractor._freeze_parameters()
+
+ @staticmethod
+ def compute_contrastive_logits(
+ target_features: torch.FloatTensor,
+ negative_features: torch.FloatTensor,
+ predicted_features: torch.FloatTensor,
+ temperature: int = 1,
+ ):
+ """
+ Compute logits for contrastive loss based using cosine similarity as the distance measure between
+ `[positive_feature, negative_features]` and `[predicted_features]`. Additionally, temperature can be applied.
+ """
+ target_features = torch.cat([target_features, negative_features], dim=0)
+
+ logits = torch.cosine_similarity(predicted_features.float(), target_features.float(), dim=-1)
+ logits = logits.type_as(target_features)
+
+ # apply temperature
+ logits = logits / temperature
+ return logits
+
+ @auto_docstring
+ def forward(
+ self,
+ input_values: torch.Tensor | None,
+ attention_mask: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | UniSpeechSatForPreTrainingOutput:
+ r"""
+ Example:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoFeatureExtractor, UniSpeechSatForPreTraining
+ >>> from transformers.models.unispeech_sat.modeling_unispeech_sat import _compute_mask_indices
+
+ >>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base")
+ >>> model = UniSpeechSatForPreTraining.from_pretrained("microsoft/unispeech-sat-base")
+ >>> # TODO: Add full pretraining example
+ ```"""
+
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ outputs = self.unispeech_sat(
+ input_values,
+ attention_mask=attention_mask,
+ output_attentions=output_attentions,
+ output_hidden_states=output_hidden_states,
+ return_dict=return_dict,
+ )
+ transformer_features = outputs[0]
+
+ # quantize all (unmasked) extracted features and project to final vq dim
+ extract_features = self.dropout_features(outputs[1])
+
+ # TODO(PVP) - add pretraining logic and add to tests
+ logits = extract_features
+ loss = quantized_features = codevector_perplexity = None
+
+ if not return_dict:
+ if loss is not None:
+ return (loss, logits, transformer_features, quantized_features, codevector_perplexity) + outputs[2:]
+ return (logits, transformer_features, quantized_features, codevector_perplexity) + outputs[2:]
+
+ return UniSpeechSatForPreTrainingOutput(
+ loss=loss,
+ logits=logits,
+ projected_states=transformer_features,
+ projected_quantized_states=quantized_features,
+ codevector_perplexity=codevector_perplexity,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+class UniSpeechSatForCTC(Wav2Vec2ForCTC):
+ pass
+
+
+class UniSpeechSatForSequenceClassification(Wav2Vec2ForSequenceClassification):
+ pass
+
+
+class UniSpeechSatForAudioFrameClassification(Wav2Vec2ForAudioFrameClassification):
+ pass
+
+
+class UniSpeechSatForXVector(Wav2Vec2ForXVector):
+ pass
+
+
+__all__ = [
+ "UniSpeechSatForAudioFrameClassification",
+ "UniSpeechSatForCTC",
+ "UniSpeechSatForPreTraining",
+ "UniSpeechSatForSequenceClassification",
+ "UniSpeechSatForXVector",
+ "UniSpeechSatModel",
+ "UniSpeechSatPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/univnet/__init__.py b/lib/python3.11/site-packages/transformers/models/univnet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d02d0dbe574ebac34022e5e8727c900e16f5977
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/univnet/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2024 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_univnet import *
+ from .feature_extraction_univnet import *
+ from .modeling_univnet import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5562a004ee884b0d989a6c4aea44739128099c72
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/configuration_univnet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/configuration_univnet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8be7b6c708cee2322eb444d5609a815df2c50e3
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/configuration_univnet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/feature_extraction_univnet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/feature_extraction_univnet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9741f51318e969428f29ee3c16eadcca924f8c58
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/feature_extraction_univnet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/modeling_univnet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/modeling_univnet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fbdcc8a3c6098160a026625a636fae9e1e127445
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/univnet/__pycache__/modeling_univnet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/univnet/configuration_univnet.py b/lib/python3.11/site-packages/transformers/models/univnet/configuration_univnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..7866b27939a97a2d3355a0363f92a958442c11d4
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/univnet/configuration_univnet.py
@@ -0,0 +1,101 @@
+# Copyright 2023 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.
+"""UnivNetModel model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="dg845/univnet-dev")
+@strict
+class UnivNetConfig(PreTrainedConfig):
+ r"""
+ model_in_channels (`int`, *optional*, defaults to 64):
+ The number of input channels for the UnivNet residual network. This should correspond to
+ `noise_sequence.shape[1]` and the value used in the [`UnivNetFeatureExtractor`] class.
+ model_hidden_channels (`int`, *optional*, defaults to 32):
+ The number of hidden channels of each residual block in the UnivNet residual network.
+ num_mel_bins (`int`, *optional*, defaults to 100):
+ The number of frequency bins in the conditioning log-mel spectrogram. This should correspond to the value
+ used in the [`UnivNetFeatureExtractor`] class.
+ resblock_kernel_sizes (`tuple[int]` or `list[int]`, *optional*, defaults to `[3, 3, 3]`):
+ A tuple of integers defining the kernel sizes of the 1D convolutional layers in the UnivNet residual
+ network. The length of `resblock_kernel_sizes` defines the number of resnet blocks and should match that of
+ `resblock_stride_sizes` and `resblock_dilation_sizes`.
+ resblock_stride_sizes (`tuple[int]` or `list[int]`, *optional*, defaults to `[8, 8, 4]`):
+ A tuple of integers defining the stride sizes of the 1D convolutional layers in the UnivNet residual
+ network. The length of `resblock_stride_sizes` should match that of `resblock_kernel_sizes` and
+ `resblock_dilation_sizes`.
+ resblock_dilation_sizes (`tuple[tuple[int]]` or `list[list[int]]`, *optional*, defaults to `[[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]`):
+ A nested tuple of integers defining the dilation rates of the dilated 1D convolutional layers in the
+ UnivNet residual network. The length of `resblock_dilation_sizes` should match that of
+ `resblock_kernel_sizes` and `resblock_stride_sizes`. The length of each nested list in
+ `resblock_dilation_sizes` defines the number of convolutional layers per resnet block.
+ kernel_predictor_num_blocks (`int`, *optional*, defaults to 3):
+ The number of residual blocks in the kernel predictor network, which calculates the kernel and bias for
+ each location variable convolution layer in the UnivNet residual network.
+ kernel_predictor_hidden_channels (`int`, *optional*, defaults to 64):
+ The number of hidden channels for each residual block in the kernel predictor network.
+ kernel_predictor_conv_size (`int`, *optional*, defaults to 3):
+ The kernel size of each 1D convolutional layer in the kernel predictor network.
+ kernel_predictor_dropout (`float`, *optional*, defaults to 0.0):
+ The dropout probability for each residual block in the kernel predictor network.
+ leaky_relu_slope (`float`, *optional*, defaults to 0.2):
+ The angle of the negative slope used by the leaky ReLU activation.
+
+ Example:
+
+ ```python
+ >>> from transformers import UnivNetModel, UnivNetConfig
+
+ >>> # Initializing a Tortoise TTS style configuration
+ >>> configuration = UnivNetConfig()
+
+ >>> # Initializing a model (with random weights) from the Tortoise TTS style configuration
+ >>> model = UnivNetModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```
+ """
+
+ model_type = "univnet"
+
+ model_in_channels: int = 64
+ model_hidden_channels: int = 32
+ num_mel_bins: int = 100
+ resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 3, 3)
+ resblock_stride_sizes: list[int] | tuple[int, ...] = (8, 8, 4)
+ resblock_dilation_sizes: list | tuple = ((1, 3, 9, 27), (1, 3, 9, 27), (1, 3, 9, 27))
+ kernel_predictor_num_blocks: int = 3
+ kernel_predictor_hidden_channels: int = 64
+ kernel_predictor_conv_size: int = 3
+ kernel_predictor_dropout: float | int = 0.0
+ initializer_range: float = 0.01
+ leaky_relu_slope: float = 0.2
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if not (
+ len(self.resblock_kernel_sizes) == len(self.resblock_stride_sizes) == len(self.resblock_dilation_sizes)
+ ):
+ raise ValueError(
+ "`resblock_kernel_sizes`, `resblock_stride_sizes`, and `resblock_dilation_sizes` must all have the"
+ " same length (which will be the number of resnet blocks in the model)."
+ )
+
+
+__all__ = ["UnivNetConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/univnet/feature_extraction_univnet.py b/lib/python3.11/site-packages/transformers/models/univnet/feature_extraction_univnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..84e9420a0f75913c418d2c790c4df846d538c1a1
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/univnet/feature_extraction_univnet.py
@@ -0,0 +1,458 @@
+# Copyright 2023 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.
+"""Feature extractor class for UnivNetModel."""
+
+from typing import Any
+
+import numpy as np
+
+from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
+from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
+from ...feature_extraction_utils import BatchFeature
+from ...utils import PaddingStrategy, TensorType, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class UnivNetFeatureExtractor(SequenceFeatureExtractor):
+ r"""
+ Constructs a UnivNet feature extractor.
+
+ This class extracts log-mel-filter bank features from raw speech using the short time Fourier Transform (STFT). The
+ STFT implementation follows that of TacoTron 2 and Hifi-GAN.
+
+ This feature extractor inherits from [`~feature_extraction_sequence_utils.SequenceFeatureExtractor`] which contains
+ most of the main methods. Users should refer to this superclass for more information regarding those methods.
+
+ Args:
+ feature_size (`int`, *optional*, defaults to 1):
+ The feature dimension of the extracted features.
+ sampling_rate (`int`, *optional*, defaults to 24000):
+ The sampling rate at which the audio files should be digitalized expressed in hertz (Hz).
+ padding_value (`float`, *optional*, defaults to 0.0):
+ The value to pad with when applying the padding strategy defined by the `padding` argument to
+ [`UnivNetFeatureExtractor.__call__`]. Should correspond to audio silence. The `pad_end` argument to
+ `__call__` will also use this padding value.
+ do_normalize (`bool`, *optional*, defaults to `False`):
+ Whether to perform Tacotron 2 normalization on the input. Normalizing can help to significantly improve the
+ performance for some models.
+ num_mel_bins (`int`, *optional*, defaults to 100):
+ The number of mel-frequency bins in the extracted spectrogram features. This should match
+ `UnivNetModel.config.num_mel_bins`.
+ hop_length (`int`, *optional*, defaults to 256):
+ The direct number of samples between sliding windows. Otherwise referred to as "shift" in many papers. Note
+ that this is different from other audio feature extractors such as [`SpeechT5FeatureExtractor`] which take
+ the `hop_length` in ms.
+ win_length (`int`, *optional*, defaults to 1024):
+ The direct number of samples for each sliding window. Note that this is different from other audio feature
+ extractors such as [`SpeechT5FeatureExtractor`] which take the `win_length` in ms.
+ win_function (`str`, *optional*, defaults to `"hann_window"`):
+ Name for the window function used for windowing, must be accessible via `torch.{win_function}`
+ filter_length (`int`, *optional*, defaults to 1024):
+ The number of FFT components to use. If `None`, this is determined using
+ `transformers.audio_utils.optimal_fft_length`.
+ max_length_s (`int`, *optional*, defaults to 10):
+ The maximum input length of the model in seconds. This is used to pad the audio.
+ fmin (`float`, *optional*, defaults to 0.0):
+ Minimum mel frequency in Hz.
+ fmax (`float`, *optional*):
+ Maximum mel frequency in Hz. If not set, defaults to `sampling_rate / 2`.
+ mel_floor (`float`, *optional*, defaults to 1e-09):
+ Minimum value of mel frequency banks. Note that the way [`UnivNetFeatureExtractor`] uses `mel_floor` is
+ different than in [`transformers.audio_utils.spectrogram`].
+ center (`bool`, *optional*, defaults to `False`):
+ Whether to pad the waveform so that frame `t` is centered around time `t * hop_length`. If `False`, frame
+ `t` will start at time `t * hop_length`.
+ compression_factor (`float`, *optional*, defaults to 1.0):
+ The multiplicative compression factor for dynamic range compression during spectral normalization.
+ compression_clip_val (`float`, *optional*, defaults to 1e-05):
+ The clip value applied to the waveform before applying dynamic range compression during spectral
+ normalization.
+ normalize_min (`float`, *optional*, defaults to -11.512925148010254):
+ The min value used for Tacotron 2-style linear normalization. The default is the original value from the
+ Tacotron 2 implementation.
+ normalize_max (`float`, *optional*, defaults to 2.3143386840820312):
+ The max value used for Tacotron 2-style linear normalization. The default is the original value from the
+ Tacotron 2 implementation.
+ model_in_channels (`int`, *optional*, defaults to 64):
+ The number of input channels to the [`UnivNetModel`] model. This should match
+ `UnivNetModel.config.model_in_channels`.
+ pad_end_length (`int`, *optional*, defaults to 10):
+ If padding the end of each waveform, the number of spectrogram frames worth of samples to append. The
+ number of appended samples will be `pad_end_length * hop_length`.
+ return_attention_mask (`bool`, *optional*, defaults to `True`):
+ Whether or not [`~UnivNetFeatureExtractor.__call__`] should return `attention_mask`.
+ """
+
+ model_input_names = ["input_features", "noise_sequence", "padding_mask"]
+
+ def __init__(
+ self,
+ feature_size: int = 1,
+ sampling_rate: int = 24000,
+ padding_value: float = 0.0,
+ do_normalize: bool = False,
+ num_mel_bins: int = 100,
+ hop_length: int = 256,
+ win_length: int = 1024,
+ win_function: str = "hann_window",
+ filter_length: int | None = 1024,
+ max_length_s: int = 10,
+ fmin: float = 0.0,
+ fmax: float | None = None,
+ mel_floor: float = 1e-9,
+ center: bool = False,
+ compression_factor: float = 1.0,
+ compression_clip_val: float = 1e-5,
+ normalize_min: float = -11.512925148010254,
+ normalize_max: float = 2.3143386840820312,
+ model_in_channels: int = 64,
+ pad_end_length: int = 10,
+ return_attention_mask=True,
+ **kwargs,
+ ):
+ super().__init__(
+ feature_size=feature_size,
+ sampling_rate=sampling_rate,
+ padding_value=padding_value,
+ return_attention_mask=return_attention_mask,
+ **kwargs,
+ )
+
+ self.do_normalize = do_normalize
+
+ self.num_mel_bins = num_mel_bins
+ self.hop_length = hop_length
+ self.win_length = win_length
+ self.win_function = win_function
+ self.filter_length = filter_length
+ self.fmin = fmin
+ if fmax is None:
+ # Follows the librosa.filters.mel implementation
+ fmax = float(sampling_rate) / 2
+ self.fmax = fmax
+ self.mel_floor = mel_floor
+
+ self.max_length_s = max_length_s
+ self.num_max_samples = max_length_s * sampling_rate
+
+ if self.filter_length is None:
+ self.n_fft = optimal_fft_length(self.win_length)
+ else:
+ self.n_fft = self.filter_length
+ self.n_freqs = (self.n_fft // 2) + 1
+
+ self.window = window_function(window_length=self.win_length, name=self.win_function, periodic=True)
+
+ self.mel_filters = mel_filter_bank(
+ num_frequency_bins=self.n_freqs,
+ num_mel_filters=self.num_mel_bins,
+ min_frequency=self.fmin,
+ max_frequency=self.fmax,
+ sampling_rate=self.sampling_rate,
+ norm="slaney",
+ mel_scale="slaney",
+ )
+
+ self.center = center
+ self.compression_factor = compression_factor
+ self.compression_clip_val = compression_clip_val
+ self.normalize_min = normalize_min
+ self.normalize_max = normalize_max
+ self.model_in_channels = model_in_channels
+ self.pad_end_length = pad_end_length
+
+ def normalize(self, spectrogram):
+ return 2 * ((spectrogram - self.normalize_min) / (self.normalize_max - self.normalize_min)) - 1
+
+ def denormalize(self, spectrogram):
+ return self.normalize_min + (self.normalize_max - self.normalize_min) * ((spectrogram + 1) / 2)
+
+ def mel_spectrogram(self, waveform: np.ndarray) -> np.ndarray:
+ """
+ Calculates log MEL spectrograms from a batch of waveforms. Note that the input waveform(s) will be padded by
+ `int(self.n_fft - self.hop_length) / 2` on both sides using the `reflect` padding mode.
+
+ Args:
+ waveform (`np.ndarray` of shape `(length,)`):
+ The input waveform. This must be a single real-valued, mono waveform.
+
+ Returns:
+ `numpy.ndarray`: Array containing a log-mel spectrogram of shape `(num_frames, num_mel_bins)`.
+ """
+ # Do custom padding based on the official MelGAN and Hifi-GAN implementations
+ # See https://github.com/maum-ai/univnet/blob/9bb2b54838bb6d7ce767131cc7b8b61198bc7558/utils/stft.py#L84-L86
+ waveform = np.pad(
+ waveform,
+ (int((self.n_fft - self.hop_length) / 2), int((self.n_fft - self.hop_length) / 2)),
+ mode="reflect",
+ )
+
+ # Get the complex spectrogram.
+ # Note: waveform must be unbatched currently due to the implementation of spectrogram(...).
+ complex_spectrogram = spectrogram(
+ waveform,
+ window=self.window,
+ frame_length=self.n_fft,
+ hop_length=self.hop_length,
+ fft_length=self.n_fft,
+ power=None,
+ center=self.center,
+ mel_filters=None,
+ mel_floor=None,
+ )
+
+ # Apply the MEL filter bank and MEL floor manually since UnivNet uses a slightly different implementation
+ amplitude_spectrogram = np.sqrt(
+ np.real(complex_spectrogram) ** 2 + np.imag(complex_spectrogram) ** 2 + self.mel_floor
+ )
+ mel_spectrogram = np.matmul(self.mel_filters.T, amplitude_spectrogram)
+
+ # Perform spectral normalization to get the log mel spectrogram.
+ log_mel_spectrogram = np.log(
+ np.clip(mel_spectrogram, a_min=self.compression_clip_val, a_max=None) * self.compression_factor
+ )
+
+ # Return spectrogram with num_mel_bins last
+ return log_mel_spectrogram.T
+
+ def generate_noise(
+ self,
+ noise_length: int,
+ generator: np.random.Generator | None = None,
+ ) -> np.ndarray:
+ """
+ Generates a random noise sequence of standard Gaussian noise for use in the `noise_sequence` argument of
+ [`UnivNetModel.forward`].
+
+ Args:
+ spectrogram_length (`int`):
+ The length (dim 0) of the generated noise.
+ model_in_channels (`int`, *optional*, defaults to `None`):
+ The number of features (dim 1) of the generated noise. This should correspond to the
+ `model_in_channels` of the [`UnivNetGan`] model. If not set, this will default to
+ `self.config.model_in_channels`.
+ generator (`numpy.random.Generator`, *optional*, defaults to `None`)
+ An optional `numpy.random.Generator` random number generator to control noise generation. If not set, a
+ new generator with fresh entropy will be created.
+
+ Returns:
+ `numpy.ndarray`: Array containing random standard Gaussian noise of shape `(noise_length,
+ model_in_channels)`.
+ """
+ if generator is None:
+ generator = np.random.default_rng()
+
+ noise_shape = (noise_length, self.model_in_channels)
+ noise = generator.standard_normal(noise_shape, dtype=np.float32)
+
+ return noise
+
+ def batch_decode(self, waveforms, waveform_lengths=None) -> list[np.ndarray]:
+ r"""
+ Removes padding from generated audio after running [`UnivNetModel.forward`]. This returns a ragged list of 1D
+ audio waveform arrays and not a single tensor/array because in general the waveforms will have different
+ lengths after removing padding.
+
+ Args:
+ waveforms (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ The batched output waveforms from the [`UnivNetModel`].
+ waveform_lengths (`torch.FloatTensor` of shape `(batch_size,)`, *optional*):
+ The batched lengths of each waveform before padding.
+
+ Returns:
+ `list[np.ndarray]`: A ragged list of 1D waveform arrays with padding removed.
+ """
+ # Collapse the batched waveform tensor to a list of 1D audio waveforms
+ waveforms = [waveform.detach().to(device="cpu", copy=True).numpy() for waveform in waveforms]
+
+ if waveform_lengths is not None:
+ waveforms = [waveform[: waveform_lengths[i]] for i, waveform in enumerate(waveforms)]
+
+ return waveforms
+
+ def __call__(
+ self,
+ raw_speech: np.ndarray | list[float] | list[np.ndarray] | list[list[float]],
+ sampling_rate: int | None = None,
+ padding: bool | str | PaddingStrategy = True,
+ max_length: int | None = None,
+ truncation: bool = True,
+ pad_to_multiple_of: int | None = None,
+ return_noise: bool = True,
+ generator: np.random.Generator | None = None,
+ pad_end: bool = False,
+ pad_length: int | None = None,
+ do_normalize: str | None = None,
+ return_attention_mask: bool | None = None,
+ return_tensors: str | TensorType | None = None,
+ ) -> BatchFeature:
+ """
+ Main method to featurize and prepare for the model one or several sequence(s).
+
+ Args:
+ raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`):
+ The sequence or batch of sequences to be padded. Each sequence can be a numpy array, a list of float
+ values, a list of numpy arrays or a list of list of float values. Must be mono channel audio, not
+ stereo, i.e. single float per timestep.
+ sampling_rate (`int`, *optional*):
+ The sampling rate at which the `raw_speech` input was sampled. It is strongly recommended to pass
+ `sampling_rate` at the forward call to prevent silent errors and allow automatic speech recognition
+ pipeline.
+ padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `True`):
+ Select a strategy to pad the input `raw_speech` waveforms (according to the model's padding side and
+ padding index) among:
+
+ - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+ sequence if provided).
+ - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
+ acceptable input length for the model if that argument is not provided.
+ - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
+ lengths).
+
+ If `pad_end = True`, that padding will occur before the `padding` strategy is applied.
+ max_length (`int`, *optional*):
+ Maximum length of the returned list and optionally padding length (see above).
+ truncation (`bool`, *optional*, defaults to `True`):
+ Activates truncation to cut input sequences longer than `max_length` to `max_length`.
+ pad_to_multiple_of (`int`, *optional*):
+ If set will pad the sequence to a multiple of the provided value.
+
+ This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability
+ `>= 7.5` (Volta), or on TPUs which benefit from having sequence lengths be a multiple of 128.
+ return_noise (`bool`, *optional*, defaults to `True`):
+ Whether to generate and return a noise waveform for use in [`UnivNetModel.forward`].
+ generator (`numpy.random.Generator`, *optional*, defaults to `None`):
+ An optional `numpy.random.Generator` random number generator to use when generating noise.
+ pad_end (`bool`, *optional*, defaults to `False`):
+ Whether to pad the end of each waveform with silence. This can help reduce artifacts at the end of the
+ generated audio sample; see https://github.com/seungwonpark/melgan/issues/8 for more details. This
+ padding will be done before the padding strategy specified in `padding` is performed.
+ pad_length (`int`, *optional*, defaults to `None`):
+ If padding the end of each waveform, the length of the padding in spectrogram frames. If not set, this
+ will default to `self.config.pad_end_length`.
+ do_normalize (`bool`, *optional*):
+ Whether to perform Tacotron 2 normalization on the input. Normalizing can help to significantly improve
+ the performance for some models. If not set, this will default to `self.config.do_normalize`.
+ return_attention_mask (`bool`, *optional*):
+ Whether to return the attention mask. If left to the default, will return the attention mask according
+ to the specific feature_extractor's default.
+
+ [What are attention masks?](../glossary#attention-mask)
+
+ return_tensors (`str` or [`~utils.TensorType`], *optional*):
+ If set, will return tensors instead of list of python integers. Acceptable values are:
+
+ - `'pt'`: Return PyTorch `torch.np.array` objects.
+ - `'np'`: Return Numpy `np.ndarray` objects.
+ """
+ do_normalize = do_normalize if do_normalize is not None else self.do_normalize
+
+ if sampling_rate is not None:
+ if sampling_rate != self.sampling_rate:
+ raise ValueError(
+ f"The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"
+ f" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"
+ f" was sampled with {self.sampling_rate} and not {sampling_rate}."
+ )
+ else:
+ logger.warning(
+ f"It is strongly recommended to pass the `sampling_rate` argument to `{self.__class__.__name__}()`. "
+ "Failing to do so can result in silent errors that might be hard to debug."
+ )
+
+ is_batched_numpy = isinstance(raw_speech, np.ndarray) and len(raw_speech.shape) > 1
+ if is_batched_numpy and len(raw_speech.shape) > 2:
+ raise ValueError(f"Only mono-channel audio is supported for input to {self}")
+ is_batched = is_batched_numpy or (
+ isinstance(raw_speech, (list, tuple)) and (isinstance(raw_speech[0], (np.ndarray, tuple, list)))
+ )
+
+ if is_batched:
+ raw_speech = [np.asarray(speech, dtype=np.float32) for speech in raw_speech]
+ elif not is_batched and not isinstance(raw_speech, np.ndarray):
+ raw_speech = np.asarray(raw_speech, dtype=np.float32)
+ elif isinstance(raw_speech, np.ndarray) and raw_speech.dtype is np.dtype(np.float64):
+ raw_speech = raw_speech.astype(np.float32)
+
+ # always return batch
+ if not is_batched:
+ raw_speech = [np.asarray(raw_speech, dtype=np.float32)]
+
+ # Pad end to reduce artifacts
+ if pad_end:
+ pad_length = pad_length if pad_length is not None else self.pad_end_length
+ raw_speech = [
+ np.pad(waveform, (0, pad_length * self.hop_length), constant_values=self.padding_value)
+ for waveform in raw_speech
+ ]
+
+ batched_speech = BatchFeature({"input_features": raw_speech})
+
+ padded_inputs = self.pad(
+ batched_speech,
+ padding=padding,
+ max_length=max_length if max_length is not None else self.num_max_samples,
+ truncation=truncation,
+ pad_to_multiple_of=pad_to_multiple_of,
+ return_attention_mask=return_attention_mask,
+ )
+
+ # make sure list is in array format
+ # input_features = padded_inputs.get("input_features").transpose(2, 0, 1)
+ input_features = padded_inputs.get("input_features")
+
+ mel_spectrograms = [self.mel_spectrogram(waveform) for waveform in input_features]
+
+ if isinstance(input_features[0], list):
+ batched_speech["input_features"] = [np.asarray(mel, dtype=np.float32) for mel in mel_spectrograms]
+ else:
+ batched_speech["input_features"] = [mel.astype(np.float32) for mel in mel_spectrograms]
+
+ # convert attention_mask to correct format
+ attention_mask = padded_inputs.get("attention_mask")
+ if attention_mask is not None:
+ batched_speech["padding_mask"] = [np.asarray(array, dtype=np.int32) for array in attention_mask]
+
+ if return_noise:
+ noise = [
+ self.generate_noise(spectrogram.shape[0], generator)
+ for spectrogram in batched_speech["input_features"]
+ ]
+ batched_speech["noise_sequence"] = noise
+
+ if do_normalize:
+ batched_speech["input_features"] = [
+ self.normalize(spectrogram) for spectrogram in batched_speech["input_features"]
+ ]
+
+ if return_tensors is not None:
+ batched_speech = batched_speech.convert_to_tensors(return_tensors)
+
+ return batched_speech
+
+ def to_dict(self) -> dict[str, Any]:
+ output = super().to_dict()
+
+ # Don't serialize these as they are derived from the other properties.
+ names = ["window", "mel_filters", "n_fft", "n_freqs", "num_max_samples"]
+ for name in names:
+ if name in output:
+ del output[name]
+
+ return output
+
+
+__all__ = ["UnivNetFeatureExtractor"]
diff --git a/lib/python3.11/site-packages/transformers/models/univnet/modeling_univnet.py b/lib/python3.11/site-packages/transformers/models/univnet/modeling_univnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3cdb13f83642ace07c03dfe15add889498dcf82
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/univnet/modeling_univnet.py
@@ -0,0 +1,611 @@
+# Copyright 2023 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.
+"""PyTorch UnivNetModel model."""
+
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from ...modeling_outputs import ModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring, logging
+from .configuration_univnet import UnivNetConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(
+ custom_intro="""
+ Output class for the [`UnivNetModel`], which includes the generated audio waveforms and the original unpadded
+ lengths of those waveforms (so that the padding can be removed by [`UnivNetModel.batch_decode`]).
+ """
+)
+@dataclass
+class UnivNetModelOutput(ModelOutput):
+ r"""
+ waveforms (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
+ Batched 1D (mono-channel) output audio waveforms.
+ waveform_lengths (`torch.FloatTensor` of shape `(batch_size,)`):
+ The batched length in samples of each unpadded waveform in `waveforms`.
+ """
+
+ waveforms: torch.FloatTensor | None = None
+ waveform_lengths: torch.FloatTensor | None = None
+
+
+class UnivNetKernelPredictorResidualBlock(nn.Module):
+ """
+ Implementation of the residual block for the kernel predictor network inside each location variable convolution
+ block (LVCBlock).
+
+ Parameters:
+ config: (`UnivNetConfig`):
+ Config for the `UnivNetModel` model.
+ """
+
+ def __init__(
+ self,
+ config: UnivNetConfig,
+ ):
+ super().__init__()
+ self.channels = config.model_in_channels
+ self.kernel_size = config.kernel_predictor_conv_size
+ self.dropout_prob = config.kernel_predictor_dropout
+ self.leaky_relu_slope = config.leaky_relu_slope
+
+ padding = (self.kernel_size - 1) // 2
+
+ self.dropout = nn.Dropout(self.dropout_prob)
+ self.conv1 = nn.Conv1d(self.channels, self.channels, self.kernel_size, padding=padding, bias=True)
+ self.conv2 = nn.Conv1d(self.channels, self.channels, self.kernel_size, padding=padding, bias=True)
+
+ def forward(self, hidden_states: torch.FloatTensor):
+ # hidden_states should have shape (batch_size, channels, seq_length)
+ residual = hidden_states
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = self.conv1(hidden_states)
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.leaky_relu_slope)
+ hidden_states = self.conv2(hidden_states)
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.leaky_relu_slope)
+ return hidden_states + residual
+
+ def apply_weight_norm(self):
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ weight_norm(self.conv1)
+ weight_norm(self.conv2)
+
+ def remove_weight_norm(self):
+ nn.utils.remove_weight_norm(self.conv1)
+ nn.utils.remove_weight_norm(self.conv2)
+
+
+class UnivNetKernelPredictor(nn.Module):
+ """
+ Implementation of the kernel predictor network which supplies the kernel and bias for the location variable
+ convolutional layers (LVCs) in each UnivNet LVCBlock.
+
+ Based on the KernelPredictor implementation in
+ [maum-ai/univnet](https://github.com/maum-ai/univnet/blob/9bb2b54838bb6d7ce767131cc7b8b61198bc7558/model/lvcnet.py#L7).
+
+ Parameters:
+ config: (`UnivNetConfig`):
+ Config for the `UnivNetModel` model.
+ conv_kernel_size (`int`, *optional*, defaults to 3):
+ The kernel size for the location variable convolutional layer kernels (convolutional weight tensor).
+ conv_layers (`int`, *optional*, defaults to 4):
+ The number of location variable convolutional layers to output kernels and biases for.
+ """
+
+ def __init__(
+ self,
+ config: UnivNetConfig,
+ conv_kernel_size: int = 3,
+ conv_layers: int = 4,
+ ):
+ super().__init__()
+
+ self.conv_in_channels = config.model_hidden_channels
+ self.conv_out_channels = 2 * config.model_hidden_channels
+ self.conv_kernel_size = conv_kernel_size
+ self.conv_layers = conv_layers
+
+ self.kernel_channels = (
+ self.conv_in_channels * self.conv_out_channels * self.conv_kernel_size * self.conv_layers
+ )
+ self.bias_channels = self.conv_out_channels * self.conv_layers
+
+ self.resnet_in_channels = config.num_mel_bins
+ self.resnet_hidden_channels = config.kernel_predictor_hidden_channels
+ self.resnet_kernel_size = config.kernel_predictor_conv_size
+ self.num_blocks = config.kernel_predictor_num_blocks
+
+ self.leaky_relu_slope = config.leaky_relu_slope
+
+ padding = (self.resnet_kernel_size - 1) // 2
+
+ self.input_conv = nn.Conv1d(self.resnet_in_channels, self.resnet_hidden_channels, 5, padding=2, bias=True)
+
+ self.resblocks = nn.ModuleList([UnivNetKernelPredictorResidualBlock(config) for _ in range(self.num_blocks)])
+
+ self.kernel_conv = nn.Conv1d(
+ self.resnet_hidden_channels, self.kernel_channels, self.resnet_kernel_size, padding=padding, bias=True
+ )
+ self.bias_conv = nn.Conv1d(
+ self.resnet_hidden_channels, self.bias_channels, self.resnet_kernel_size, padding=padding, bias=True
+ )
+
+ def forward(self, spectrogram: torch.FloatTensor):
+ """
+ Maps a conditioning log-mel spectrogram to a tensor of convolutional kernels and biases, for use in location
+ variable convolutional layers. Note that the input spectrogram should have shape (batch_size, input_channels,
+ seq_length).
+
+ Args:
+ spectrogram (`torch.FloatTensor` of shape `(batch_size, input_channels, seq_length)`):
+ Tensor containing the log-mel spectrograms.
+
+ Returns:
+ tuple[`torch.FloatTensor, `torch.FloatTensor`]: tuple of tensors where the first element is the tensor of
+ location variable convolution kernels of shape `(batch_size, self.conv_layers, self.conv_in_channels,
+ self.conv_out_channels, self.conv_kernel_size, seq_length)` and the second element is the tensor of
+ location variable convolution biases of shape `(batch_size, self.conv_layers. self.conv_out_channels,
+ seq_length)`.
+ """
+ batch_size, _, seq_length = spectrogram.shape
+
+ hidden_states = self.input_conv(spectrogram)
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.leaky_relu_slope)
+
+ for resblock in self.resblocks:
+ hidden_states = resblock(hidden_states)
+
+ kernel_hidden_states = self.kernel_conv(hidden_states)
+ bias_hidden_states = self.bias_conv(hidden_states)
+
+ # Reshape kernels and biases to appropriate shape
+ kernels = kernel_hidden_states.view(
+ batch_size,
+ self.conv_layers,
+ self.conv_in_channels,
+ self.conv_out_channels,
+ self.conv_kernel_size,
+ seq_length,
+ ).contiguous()
+ biases = bias_hidden_states.view(
+ batch_size,
+ self.conv_layers,
+ self.conv_out_channels,
+ seq_length,
+ ).contiguous()
+
+ return kernels, biases
+
+ def apply_weight_norm(self):
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ weight_norm(self.input_conv)
+ for layer in self.resblocks:
+ layer.apply_weight_norm()
+ weight_norm(self.kernel_conv)
+ weight_norm(self.bias_conv)
+
+ def remove_weight_norm(self):
+ nn.utils.remove_weight_norm(self.input_conv)
+ for layer in self.resblocks:
+ layer.remove_weight_norm()
+ nn.utils.remove_weight_norm(self.kernel_conv)
+ nn.utils.remove_weight_norm(self.bias_conv)
+
+
+class UnivNetLvcResidualBlock(nn.Module):
+ """
+ Implementation of the location variable convolution (LVC) residual block for the UnivNet residual network.
+
+ Parameters:
+ config: (`UnivNetConfig`):
+ Config for the `UnivNetModel` model.
+ kernel_size (`int`):
+ The kernel size for the dilated 1D convolutional layer.
+ dilation (`int`):
+ The dilation for the dilated 1D convolutional layer.
+ """
+
+ def __init__(
+ self,
+ config: UnivNetConfig,
+ kernel_size: int,
+ dilation: int,
+ ):
+ super().__init__()
+ self.hidden_channels = config.model_hidden_channels
+ self.kernel_size = kernel_size
+ self.dilation = dilation
+ self.leaky_relu_slope = config.leaky_relu_slope
+
+ padding = self.dilation * (self.kernel_size - 1) // 2
+
+ self.conv = nn.Conv1d(
+ self.hidden_channels,
+ self.hidden_channels,
+ self.kernel_size,
+ padding=padding,
+ dilation=self.dilation,
+ )
+
+ def forward(self, hidden_states, kernel, bias, hop_size=256):
+ residual = hidden_states
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.leaky_relu_slope)
+ hidden_states = self.conv(hidden_states)
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.leaky_relu_slope)
+ hidden_states = self.location_variable_convolution(hidden_states, kernel, bias, hop_size=hop_size)
+ # Gated activation unit
+ hidden_states = torch.sigmoid(hidden_states[:, : self.hidden_channels, :]) * torch.tanh(
+ hidden_states[:, self.hidden_channels :, :]
+ )
+ # Skip connection
+ hidden_states = residual + hidden_states
+
+ return hidden_states
+
+ # Based on https://github.com/maum-ai/univnet/blob/9bb2b54838bb6d7ce767131cc7b8b61198bc7558/model/lvcnet.py#L171
+ def location_variable_convolution(
+ self,
+ hidden_states: torch.FloatTensor,
+ kernel: torch.FloatTensor,
+ bias: torch.FloatTensor,
+ dilation: int = 1,
+ hop_size: int = 256,
+ ):
+ """
+ Performs location-variable convolution operation on the input sequence (hidden_states) using the local
+ convolution kernel. This was introduced in [LVCNet: Efficient Condition-Dependent Modeling Network for Waveform
+ Generation](https://huggingface.co/papers/2102.10815) by Zhen Zheng, Jianzong Wang, Ning Cheng, and Jing Xiao.
+
+ Time: 414 μs ± 309 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each), test on NVIDIA V100.
+
+ Args:
+ hidden_states (`torch.FloatTensor` of shape `(batch_size, in_channels, in_length)`):
+ The input sequence of shape (batch, in_channels, in_length).
+ kernel (`torch.FloatTensor` of shape `(batch_size, in_channels, out_channels, kernel_size, kernel_length)`):
+ The local convolution kernel of shape (batch, in_channels, out_channels, kernel_size, kernel_length).
+ bias (`torch.FloatTensor` of shape `(batch_size, out_channels, kernel_length)`):
+ The bias for the local convolution of shape (batch, out_channels, kernel_length).
+ dilation (`int`, *optional*, defaults to 1):
+ The dilation of convolution.
+ hop_size (`int`, *optional*, defaults to 256):
+ The hop_size of the conditioning sequence.
+ Returns:
+ `torch.FloatTensor`: the output sequence after performing local convolution with shape (batch_size,
+ out_channels, in_length).
+ """
+ batch, _, in_length = hidden_states.shape
+ batch, _, out_channels, kernel_size, kernel_length = kernel.shape
+ if in_length != (kernel_length * hop_size):
+ raise ValueError(
+ f"Dim 2 of `hidden_states` should be {kernel_length * hop_size}) but got {in_length}. Please check"
+ " `hidden_states` or `kernel` and `hop_size` to make sure they are correct."
+ )
+
+ padding = dilation * int((kernel_size - 1) / 2)
+
+ # (batch, in_channels, in_length + 2*padding)
+ hidden_states = nn.functional.pad(hidden_states, (padding, padding), "constant", 0)
+ # (batch, in_channels, kernel_length, hop_size + 2*padding)
+ hidden_states = hidden_states.unfold(2, hop_size + 2 * padding, hop_size)
+
+ if hop_size < dilation:
+ hidden_states = nn.functional.pad(hidden_states, (0, dilation), "constant", 0)
+ # (batch, in_channels, kernel_length, (hop_size + 2*padding)/dilation, dilation)
+ hidden_states = hidden_states.unfold(3, dilation, dilation)
+ hidden_states = hidden_states[:, :, :, :, :hop_size]
+ # (batch, in_channels, kernel_length, dilation, (hop_size + 2*padding)/dilation)
+ hidden_states = hidden_states.transpose(3, 4)
+ # (batch, in_channels, kernel_length, dilation, _, kernel_size)
+ hidden_states = hidden_states.unfold(4, kernel_size, 1)
+
+ # Apply local convolution kernel to hidden_states.
+ output_hidden_states = torch.einsum("bildsk,biokl->bolsd", hidden_states, kernel)
+
+ output_hidden_states = output_hidden_states.to(memory_format=torch.channels_last_3d)
+ bias = bias.unsqueeze(-1).unsqueeze(-1).to(memory_format=torch.channels_last_3d)
+ output_hidden_states = output_hidden_states + bias
+ output_hidden_states = output_hidden_states.contiguous().view(batch, out_channels, -1)
+
+ return output_hidden_states
+
+ def apply_weight_norm(self):
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ weight_norm(self.conv)
+
+ def remove_weight_norm(self):
+ nn.utils.remove_weight_norm(self.conv)
+
+
+class UnivNetLvcBlock(nn.Module):
+ """
+ Implementation of the location variable convolution (LVC) residual block of the UnivNet residual block. Includes a
+ `UnivNetKernelPredictor` inside to predict the kernels and biases of the LVC layers.
+
+ Based on LVCBlock in
+ [maum-ai/univnet](https://github.com/maum-ai/univnet/blob/9bb2b54838bb6d7ce767131cc7b8b61198bc7558/model/lvcnet.py#L98)
+
+ Parameters:
+ config (`UnivNetConfig`):
+ Config for the `UnivNetModel` model.
+ layer_id (`int`):
+ An integer corresponding to the index of the current LVC resnet block layer. This should be between 0 and
+ `len(config.resblock_stride_sizes) - 1)` inclusive.
+ lvc_hop_size (`int`, *optional*, defaults to 256):
+ The hop size for the location variable convolutional layers.
+ """
+
+ def __init__(
+ self,
+ config: UnivNetConfig,
+ layer_id: int,
+ lvc_hop_size: int = 256,
+ ):
+ super().__init__()
+ self.hidden_channels = config.model_hidden_channels
+ self.kernel_size = config.resblock_kernel_sizes[layer_id]
+ self.stride = config.resblock_stride_sizes[layer_id]
+ self.dilations = config.resblock_dilation_sizes[layer_id]
+ self.cond_hop_length = lvc_hop_size
+ self.leaky_relu_slope = config.leaky_relu_slope
+ self.num_blocks = len(self.dilations)
+
+ self.convt_pre = nn.ConvTranspose1d(
+ self.hidden_channels,
+ self.hidden_channels,
+ 2 * self.stride,
+ stride=self.stride,
+ padding=self.stride // 2 + self.stride % 2,
+ output_padding=self.stride % 2,
+ )
+
+ self.kernel_predictor = UnivNetKernelPredictor(config, self.kernel_size, self.num_blocks)
+
+ self.resblocks = nn.ModuleList(
+ [UnivNetLvcResidualBlock(config, self.kernel_size, self.dilations[i]) for i in range(self.num_blocks)]
+ )
+
+ def forward(self, hidden_states: torch.FloatTensor, spectrogram: torch.FloatTensor):
+ # hidden_states: (batch_size, hidden_channels, seq_length)
+ # spectrogram: (batch_size, cond_channels, cond_length)
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.leaky_relu_slope)
+ hidden_states = self.convt_pre(hidden_states)
+
+ kernels, biases = self.kernel_predictor(spectrogram)
+
+ for i, resblock in enumerate(self.resblocks):
+ kernel = kernels[:, i, :, :, :, :]
+ bias = biases[:, i, :, :]
+ hidden_states = resblock(hidden_states, kernel, bias, hop_size=self.cond_hop_length)
+
+ return hidden_states
+
+ def apply_weight_norm(self):
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ weight_norm(self.convt_pre)
+ self.kernel_predictor.apply_weight_norm()
+ for layer in self.resblocks:
+ layer.apply_weight_norm()
+
+ def remove_weight_norm(self):
+ nn.utils.remove_weight_norm(self.convt_pre)
+ self.kernel_predictor.remove_weight_norm()
+ for layer in self.resblocks:
+ layer.remove_weight_norm()
+
+
+@auto_docstring
+class UnivNetModel(PreTrainedModel):
+ config: UnivNetConfig
+ main_input_name = "input_features"
+ input_modalities = "audio"
+
+ def __init__(self, config: UnivNetConfig):
+ super().__init__(config)
+
+ self.num_kernels = len(config.resblock_kernel_sizes)
+ self.leaky_relu_slope = config.leaky_relu_slope
+
+ self.conv_pre = nn.Conv1d(
+ config.model_in_channels,
+ config.model_hidden_channels,
+ kernel_size=7,
+ stride=1,
+ padding=3,
+ padding_mode="reflect",
+ )
+
+ # Initialize location-variable convolution ResNet Blocks.
+ num_layers = len(config.resblock_stride_sizes)
+ hop_length = 1
+ hop_lengths = []
+ for stride in config.resblock_stride_sizes:
+ hop_length = hop_length * stride
+ hop_lengths.append(hop_length)
+
+ self.resblocks = nn.ModuleList(
+ [
+ UnivNetLvcBlock(
+ config,
+ layer_id=i,
+ lvc_hop_size=hop_lengths[i],
+ )
+ for i in range(num_layers)
+ ]
+ )
+
+ self.conv_post = nn.Conv1d(config.model_hidden_channels, 1, 7, padding=3, padding_mode="reflect")
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ input_features: torch.FloatTensor,
+ noise_sequence: torch.FloatTensor | None = None,
+ padding_mask: torch.FloatTensor | None = None,
+ generator: torch.Generator | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor] | UnivNetModelOutput:
+ r"""
+ noise_sequence (`torch.FloatTensor`, *optional*):
+ Tensor containing a noise sequence of standard Gaussian noise. Can be batched and of shape `(batch_size,
+ sequence_length, config.model_in_channels)`, or un-batched and of shape (sequence_length,
+ config.model_in_channels)`. If not supplied, will be randomly generated.
+ padding_mask (`torch.BoolTensor`, *optional*):
+ Mask indicating which parts of each sequence are padded. Mask values are selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**
+ - 0 for tokens that are **masked**
+
+ The mask can be batched and of shape `(batch_size, sequence_length)` or un-batched and of shape
+ `(sequence_length,)`.
+ generator (`torch.Generator`, *optional*):
+ A [torch generator](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make generation
+ deterministic.
+ return_dict:
+ Whether to return a [`~utils.ModelOutput`] subclass instead of a plain tuple.
+
+ Example:
+
+ ```python
+ >>> from transformers import UnivNetFeatureExtractor, UnivNetModel
+ >>> from datasets import load_dataset, Audio
+
+ >>> model = UnivNetModel.from_pretrained("dg845/univnet-dev")
+ >>> feature_extractor = UnivNetFeatureExtractor.from_pretrained("dg845/univnet-dev")
+
+ >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
+ >>> # Resample the audio to the feature extractor's sampling rate.
+ >>> ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
+ >>> inputs = feature_extractor(
+ ... ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
+ ... )
+ >>> audio = model(**inputs).waveforms
+ >>> list(audio.shape)
+ [1, 140288]
+ ```
+ """
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+ # Resolve batch sizes for noise_sequence and spectrogram
+ spectrogram_batched = input_features.dim() == 3
+ if not spectrogram_batched:
+ input_features = input_features.unsqueeze(0)
+ spectrogram_batch_size, spectrogram_length, _ = input_features.shape
+
+ if noise_sequence is not None:
+ noise_sequence_batched = noise_sequence.dim() == 3
+ if not noise_sequence_batched:
+ noise_sequence = noise_sequence.unsqueeze(0)
+ else:
+ # Randomly generate noise_sequence
+ noise_sequence_shape = (spectrogram_batch_size, spectrogram_length, self.config.model_in_channels)
+ noise_sequence = torch.randn(
+ noise_sequence_shape, generator=generator, dtype=input_features.dtype, device=input_features.device
+ )
+ noise_sequence_batch_size = noise_sequence.shape[0]
+
+ if spectrogram_batch_size > 1 and noise_sequence_batch_size == 1:
+ # Repeat noise_sequence spectrogram_batch_size times
+ noise_sequence = noise_sequence.repeat(spectrogram_batch_size, 1, 1)
+ elif noise_sequence_batch_size > 1 and spectrogram_batch_size == 1:
+ # Repeat spectrogram noise_sequence_batch_size times
+ input_features = input_features.repeat(noise_sequence_batch_size, 1, 1)
+
+ if noise_sequence_batch_size != spectrogram_batch_size:
+ raise ValueError(
+ f"The batch size of `noise_sequence` is {noise_sequence_batch_size} and the batch size of"
+ f" `input_features` is {spectrogram_batch_size}, but the two are expected to be equal."
+ )
+
+ if padding_mask is not None:
+ if padding_mask.dim() == 1:
+ padding_mask = padding_mask.unsqueeze(0)
+ padding_mask_batch_size = padding_mask.shape[0]
+ if padding_mask_batch_size != spectrogram_batch_size:
+ raise ValueError(
+ f"The batch size of `padding_mask` is {padding_mask_batch_size} and the batch size of"
+ f" `input_features` is {spectrogram_batch_size}, but the two are expected to be equal."
+ )
+
+ # Change shapes to have channels before sequence lengths
+ hidden_states = noise_sequence.transpose(2, 1)
+ input_features = input_features.transpose(2, 1)
+
+ hidden_states = self.conv_pre(hidden_states)
+
+ for resblock in self.resblocks:
+ hidden_states = resblock(hidden_states, input_features)
+
+ hidden_states = nn.functional.leaky_relu(hidden_states, self.leaky_relu_slope)
+ hidden_states = self.conv_post(hidden_states)
+ hidden_states = torch.tanh(hidden_states)
+
+ # Remove sequence length dimension since this collapses to 1
+ # NOTE: keep waveforms batched even if there's only one
+ waveform = hidden_states.squeeze(1)
+
+ # Get sequence lengths for UnivNetFeatureExtractor.batch_decode.
+ waveform_lengths = None
+ if padding_mask is not None:
+ # Padding is always contiguous and added on the right
+ waveform_lengths = torch.sum(padding_mask, dim=1)
+
+ if not return_dict:
+ outputs = (waveform, waveform_lengths)
+ return outputs
+
+ return UnivNetModelOutput(
+ waveforms=waveform,
+ waveform_lengths=waveform_lengths,
+ )
+
+ def apply_weight_norm(self):
+ weight_norm = nn.utils.weight_norm
+ if hasattr(nn.utils.parametrizations, "weight_norm"):
+ weight_norm = nn.utils.parametrizations.weight_norm
+
+ weight_norm(self.conv_pre)
+ for layer in self.resblocks:
+ layer.apply_weight_norm()
+ weight_norm(self.conv_post)
+
+ def remove_weight_norm(self):
+ nn.utils.remove_weight_norm(self.conv_pre)
+ for layer in self.resblocks:
+ layer.remove_weight_norm()
+ nn.utils.remove_weight_norm(self.conv_post)
+
+
+__all__ = ["UnivNetModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/upernet/__init__.py b/lib/python3.11/site-packages/transformers/models/upernet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dee32c4758f0e4c54406473ec7146caa5514c413
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/upernet/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2024 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_upernet import *
+ from .modeling_upernet import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/upernet/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/upernet/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9d409101ffc72f3b1ac0fdbd4a540a59f95c44b8
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/upernet/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/upernet/__pycache__/configuration_upernet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/upernet/__pycache__/configuration_upernet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6a34239e65fc8f4cd80352c372b39d3035bb1cbc
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/upernet/__pycache__/configuration_upernet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/upernet/__pycache__/modeling_upernet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/upernet/__pycache__/modeling_upernet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..662f3763653f2c6a16c4e83a62aec460c20e3373
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/upernet/__pycache__/modeling_upernet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/upernet/configuration_upernet.py b/lib/python3.11/site-packages/transformers/models/upernet/configuration_upernet.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c11075e7ab7a29f69e8dd6e4f2a0921b39b1508
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/upernet/configuration_upernet.py
@@ -0,0 +1,87 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""UperNet model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import consolidate_backbone_kwargs_to_config
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto.configuration_auto import AutoConfig
+
+
+@auto_docstring(checkpoint="openmmlab/upernet-convnext-tiny")
+@strict
+class UperNetConfig(PreTrainedConfig):
+ r"""
+ pool_scales (`tuple[int]`, *optional*, defaults to `[1, 2, 3, 6]`):
+ Pooling scales used in Pooling Pyramid Module applied on the last feature map.
+ use_auxiliary_head (`bool`, *optional*, defaults to `True`):
+ Whether to use an auxiliary head during training.
+ auxiliary_loss_weight (`float`, *optional*, defaults to 0.4):
+ Weight of the cross-entropy loss of the auxiliary head.
+ auxiliary_in_channels (`int`, *optional*, defaults to 256):
+ Number of input channels in the auxiliary head.
+ auxiliary_channels (`int`, *optional*, defaults to 256):
+ Number of channels to use in the auxiliary head.
+ auxiliary_num_convs (`int`, *optional*, defaults to 1):
+ Number of convolutional layers to use in the auxiliary head.
+ auxiliary_concat_input (`bool`, *optional*, defaults to `False`):
+ Whether to concatenate the output of the auxiliary head with the input before the classification layer.
+ loss_ignore_index (`int`, *optional*, defaults to 255):
+ The index that is ignored by the loss function.
+
+ Examples:
+
+ ```python
+ >>> from transformers import UperNetConfig, UperNetForSemanticSegmentation
+
+ >>> # Initializing a configuration
+ >>> configuration = UperNetConfig()
+
+ >>> # Initializing a model (with random weights) from the configuration
+ >>> model = UperNetForSemanticSegmentation(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "upernet"
+ sub_configs = {"backbone_config": AutoConfig}
+
+ backbone_config: dict | PreTrainedConfig | None = None
+ hidden_size: int = 512
+ initializer_range: float = 0.02
+ pool_scales: list[int] | tuple[int, ...] = (1, 2, 3, 6)
+ use_auxiliary_head: bool = True
+ auxiliary_loss_weight: float = 0.4
+ auxiliary_in_channels: int | None = None
+ auxiliary_channels: int = 256
+ auxiliary_num_convs: int = 1
+ auxiliary_concat_input: bool = False
+ loss_ignore_index: int = 255
+
+ def __post_init__(self, **kwargs):
+ self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+ backbone_config=self.backbone_config,
+ default_config_type="resnet",
+ default_config_kwargs={
+ "out_features": ["stage1", "stage2", "stage3", "stage4"],
+ },
+ **kwargs,
+ )
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["UperNetConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/upernet/modeling_upernet.py b/lib/python3.11/site-packages/transformers/models/upernet/modeling_upernet.py
new file mode 100644
index 0000000000000000000000000000000000000000..98dd697da205119eaa7e772c88e1b4821e5ec6b5
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/upernet/modeling_upernet.py
@@ -0,0 +1,378 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""PyTorch UperNet model. Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation."""
+
+import torch
+from torch import nn
+from torch.nn import CrossEntropyLoss
+
+from ...backbone_utils import load_backbone
+from ...modeling_outputs import SemanticSegmenterOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import auto_docstring
+from .configuration_upernet import UperNetConfig
+
+
+class UperNetConvModule(nn.Module):
+ """
+ A convolutional block that bundles conv/norm/activation layers. This block simplifies the usage of convolution
+ layers, which are commonly used with a norm layer (e.g., BatchNorm) and activation layer (e.g., ReLU).
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int | tuple[int, int],
+ padding: int | tuple[int, int] | str = 0,
+ bias: bool = False,
+ dilation: int | tuple[int, int] = 1,
+ ) -> None:
+ super().__init__()
+ self.conv = nn.Conv2d(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ padding=padding,
+ bias=bias,
+ dilation=dilation,
+ )
+ self.batch_norm = nn.BatchNorm2d(out_channels)
+ self.activation = nn.ReLU()
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ output = self.conv(input)
+ output = self.batch_norm(output)
+ output = self.activation(output)
+
+ return output
+
+
+class UperNetPyramidPoolingBlock(nn.Module):
+ def __init__(self, pool_scale: int, in_channels: int, channels: int) -> None:
+ super().__init__()
+ self.layers = [
+ nn.AdaptiveAvgPool2d(pool_scale),
+ UperNetConvModule(in_channels, channels, kernel_size=1),
+ ]
+ for i, layer in enumerate(self.layers):
+ self.add_module(str(i), layer)
+
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
+ hidden_state = input
+ for layer in self.layers:
+ hidden_state = layer(hidden_state)
+ return hidden_state
+
+
+class UperNetPyramidPoolingModule(nn.Module):
+ """
+ Pyramid Pooling Module (PPM) used in PSPNet.
+
+ Args:
+ pool_scales (`tuple[int]`):
+ Pooling scales used in Pooling Pyramid Module.
+ in_channels (`int`):
+ Input channels.
+ channels (`int`):
+ Channels after modules, before conv_seg.
+ align_corners (`bool`):
+ align_corners argument of F.interpolate.
+ """
+
+ def __init__(self, pool_scales: tuple[int, ...], in_channels: int, channels: int, align_corners: bool) -> None:
+ super().__init__()
+ self.pool_scales = pool_scales
+ self.align_corners = align_corners
+ self.in_channels = in_channels
+ self.channels = channels
+ self.blocks = []
+ for i, pool_scale in enumerate(pool_scales):
+ block = UperNetPyramidPoolingBlock(pool_scale=pool_scale, in_channels=in_channels, channels=channels)
+ self.blocks.append(block)
+ self.add_module(str(i), block)
+
+ def forward(self, x: torch.Tensor) -> list[torch.Tensor]:
+ ppm_outs = []
+ for ppm in self.blocks:
+ ppm_out = ppm(x)
+ upsampled_ppm_out = nn.functional.interpolate(
+ ppm_out, size=x.size()[2:], mode="bilinear", align_corners=self.align_corners
+ )
+ ppm_outs.append(upsampled_ppm_out)
+ return ppm_outs
+
+
+class UperNetHead(nn.Module):
+ """
+ Unified Perceptual Parsing for Scene Understanding. This head is the implementation of
+ [UPerNet](https://huggingface.co/papers/1807.10221).
+ """
+
+ def __init__(self, config, in_channels):
+ super().__init__()
+
+ self.config = config
+ self.pool_scales = config.pool_scales # e.g. (1, 2, 3, 6)
+ self.in_channels = in_channels
+ self.channels = config.hidden_size
+ self.align_corners = False
+ self.classifier = nn.Conv2d(self.channels, config.num_labels, kernel_size=1)
+
+ # PSP Module
+ self.psp_modules = UperNetPyramidPoolingModule(
+ self.pool_scales,
+ self.in_channels[-1],
+ self.channels,
+ align_corners=self.align_corners,
+ )
+ self.bottleneck = UperNetConvModule(
+ self.in_channels[-1] + len(self.pool_scales) * self.channels,
+ self.channels,
+ kernel_size=3,
+ padding=1,
+ )
+ # FPN Module
+ self.lateral_convs = nn.ModuleList()
+ self.fpn_convs = nn.ModuleList()
+ for in_channels in self.in_channels[:-1]: # skip the top layer
+ l_conv = UperNetConvModule(in_channels, self.channels, kernel_size=1)
+ fpn_conv = UperNetConvModule(self.channels, self.channels, kernel_size=3, padding=1)
+ self.lateral_convs.append(l_conv)
+ self.fpn_convs.append(fpn_conv)
+
+ self.fpn_bottleneck = UperNetConvModule(
+ len(self.in_channels) * self.channels,
+ self.channels,
+ kernel_size=3,
+ padding=1,
+ )
+
+ def psp_forward(self, inputs):
+ x = inputs[-1]
+ psp_outs = [x]
+ psp_outs.extend(self.psp_modules(x))
+ psp_outs = torch.cat(psp_outs, dim=1)
+ output = self.bottleneck(psp_outs)
+
+ return output
+
+ def forward(self, encoder_hidden_states: torch.Tensor) -> torch.Tensor:
+ # build laterals
+ laterals = [lateral_conv(encoder_hidden_states[i]) for i, lateral_conv in enumerate(self.lateral_convs)]
+
+ laterals.append(self.psp_forward(encoder_hidden_states))
+
+ # build top-down path
+ used_backbone_levels = len(laterals)
+ for i in range(used_backbone_levels - 1, 0, -1):
+ prev_shape = laterals[i - 1].shape[2:]
+ laterals[i - 1] = laterals[i - 1] + nn.functional.interpolate(
+ laterals[i], size=prev_shape, mode="bilinear", align_corners=self.align_corners
+ )
+
+ # build outputs
+ fpn_outs = [self.fpn_convs[i](laterals[i]) for i in range(used_backbone_levels - 1)]
+ # append psp feature
+ fpn_outs.append(laterals[-1])
+
+ for i in range(used_backbone_levels - 1, 0, -1):
+ fpn_outs[i] = nn.functional.interpolate(
+ fpn_outs[i], size=fpn_outs[0].shape[2:], mode="bilinear", align_corners=self.align_corners
+ )
+ fpn_outs = torch.cat(fpn_outs, dim=1)
+ output = self.fpn_bottleneck(fpn_outs)
+ output = self.classifier(output)
+
+ return output
+
+
+class UperNetFCNHead(nn.Module):
+ """
+ Fully Convolution Networks for Semantic Segmentation. This head is the implementation of
+ [FCNNet](https://huggingface.co/papers/1411.4038>).
+
+ Args:
+ config:
+ Configuration.
+ in_channels (int):
+ Number of input channels.
+ kernel_size (int):
+ The kernel size for convs in the head. Default: 3.
+ dilation (int):
+ The dilation rate for convs in the head. Default: 1.
+ """
+
+ def __init__(
+ self, config, in_channels, in_index: int = 2, kernel_size: int = 3, dilation: int | tuple[int, int] = 1
+ ) -> None:
+ super().__init__()
+
+ self.config = config
+ self.in_channels = (
+ in_channels[in_index] if config.auxiliary_in_channels is None else config.auxiliary_in_channels
+ )
+ self.channels = config.auxiliary_channels
+ self.num_convs = config.auxiliary_num_convs
+ self.concat_input = config.auxiliary_concat_input
+ self.in_index = in_index
+
+ conv_padding = (kernel_size // 2) * dilation
+ convs = []
+ convs.append(
+ UperNetConvModule(
+ self.in_channels, self.channels, kernel_size=kernel_size, padding=conv_padding, dilation=dilation
+ )
+ )
+ for i in range(self.num_convs - 1):
+ convs.append(
+ UperNetConvModule(
+ self.channels, self.channels, kernel_size=kernel_size, padding=conv_padding, dilation=dilation
+ )
+ )
+ if self.num_convs == 0:
+ self.convs = nn.Identity()
+ else:
+ self.convs = nn.Sequential(*convs)
+ if self.concat_input:
+ self.conv_cat = UperNetConvModule(
+ self.in_channels + self.channels, self.channels, kernel_size=kernel_size, padding=kernel_size // 2
+ )
+
+ self.classifier = nn.Conv2d(self.channels, config.num_labels, kernel_size=1)
+
+ def forward(self, encoder_hidden_states: torch.Tensor) -> torch.Tensor:
+ # just take the relevant feature maps
+ hidden_states = encoder_hidden_states[self.in_index]
+ output = self.convs(hidden_states)
+ if self.concat_input:
+ output = self.conv_cat(torch.cat([hidden_states, output], dim=1))
+ output = self.classifier(output)
+ return output
+
+
+@auto_docstring
+class UperNetPreTrainedModel(PreTrainedModel):
+ config: UperNetConfig
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ _no_split_modules = []
+
+
+@auto_docstring(
+ custom_intro="""
+ UperNet framework leveraging any vision backbone e.g. for ADE20k, CityScapes.
+ """
+)
+class UperNetForSemanticSegmentation(UperNetPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.backbone = load_backbone(config)
+
+ # Semantic segmentation head(s)
+ self.decode_head = UperNetHead(config, in_channels=self.backbone.channels)
+ self.auxiliary_head = (
+ UperNetFCNHead(config, in_channels=self.backbone.channels) if config.use_auxiliary_head else None
+ )
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor | None = None,
+ output_attentions: bool | None = None,
+ output_hidden_states: bool | None = None,
+ labels: torch.Tensor | None = None,
+ return_dict: bool | None = None,
+ **kwargs,
+ ) -> tuple | SemanticSegmenterOutput:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, height, width)`, *optional*):
+ Ground truth semantic segmentation maps for computing the loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels > 1`, a classification loss is computed (Cross-Entropy).
+
+ Examples:
+ ```python
+ >>> from transformers import AutoImageProcessor, UperNetForSemanticSegmentation
+ >>> from PIL import Image
+ >>> from huggingface_hub import hf_hub_download
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("openmmlab/upernet-convnext-tiny")
+ >>> model = UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-convnext-tiny")
+
+ >>> filepath = hf_hub_download(
+ ... repo_id="hf-internal-testing/fixtures_ade20k", filename="ADE_val_00000001.jpg", repo_type="dataset"
+ ... )
+ >>> image = Image.open(filepath).convert("RGB")
+
+ >>> inputs = image_processor(images=image, return_tensors="pt")
+
+ >>> outputs = model(**inputs)
+
+ >>> logits = outputs.logits # shape (batch_size, num_labels, height, width)
+ >>> list(logits.shape)
+ [1, 150, 512, 512]
+ ```"""
+ if labels is not None and self.config.num_labels == 1:
+ raise ValueError("The number of labels should be greater than one")
+
+ return_dict = return_dict if return_dict is not None else self.config.return_dict
+ output_hidden_states = (
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+ )
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+
+ outputs = self.backbone.forward_with_filtered_kwargs(
+ pixel_values, output_hidden_states=output_hidden_states, output_attentions=output_attentions
+ )
+ features = outputs.feature_maps
+
+ logits = self.decode_head(features)
+ logits = nn.functional.interpolate(logits, size=pixel_values.shape[2:], mode="bilinear", align_corners=False)
+
+ auxiliary_logits = None
+ if self.auxiliary_head is not None:
+ auxiliary_logits = self.auxiliary_head(features)
+ auxiliary_logits = nn.functional.interpolate(
+ auxiliary_logits, size=pixel_values.shape[2:], mode="bilinear", align_corners=False
+ )
+
+ loss = None
+ if labels is not None:
+ # compute weighted loss
+ loss_fct = CrossEntropyLoss(ignore_index=self.config.loss_ignore_index)
+ loss = loss_fct(logits, labels)
+ if auxiliary_logits is not None:
+ auxiliary_loss = loss_fct(auxiliary_logits, labels)
+ loss += self.config.auxiliary_loss_weight * auxiliary_loss
+
+ if not return_dict:
+ if output_hidden_states:
+ output = (logits,) + outputs[1:]
+ else:
+ output = (logits,) + outputs[2:]
+ return ((loss,) + output) if loss is not None else output
+
+ return SemanticSegmenterOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = ["UperNetForSemanticSegmentation", "UperNetPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/__init__.py b/lib/python3.11/site-packages/transformers/models/uvdoc/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8172dcf3bb4b66d17e0c8c79c678363d9a105e4d
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/uvdoc/__init__.py
@@ -0,0 +1,30 @@
+# Copyright 2026 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_uvdoc import *
+ from .image_processing_uvdoc import *
+ from .modeling_uvdoc import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6a42967fd2112ff29cf497300703a00e7893fb18
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/configuration_uvdoc.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/configuration_uvdoc.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..253b8f133d1af4a8945e6be2c8f0801e31e20243
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/configuration_uvdoc.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/image_processing_uvdoc.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/image_processing_uvdoc.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..96a33419d8a46ffc130f0034253e72fb6e1ffcda
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/image_processing_uvdoc.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/modeling_uvdoc.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/modeling_uvdoc.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..08f0b5e6e56346635d9009da1156082ba44a38ad
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/modeling_uvdoc.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/modular_uvdoc.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/modular_uvdoc.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d6a56eced63390ab78418e2aa8a3339d9678544d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/uvdoc/__pycache__/modular_uvdoc.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/configuration_uvdoc.py b/lib/python3.11/site-packages/transformers/models/uvdoc/configuration_uvdoc.py
new file mode 100644
index 0000000000000000000000000000000000000000..00ef3fcfd84bbb6bb0a2ca4bc6fcfb427c9f1700
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/uvdoc/configuration_uvdoc.py
@@ -0,0 +1,145 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/uvdoc/modular_uvdoc.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_uvdoc.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 collections.abc import Sequence
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import BackboneConfigMixin, consolidate_backbone_kwargs_to_config
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import AutoConfig
+
+
+@auto_docstring(checkpoint="PaddlePaddle/UVDoc_safetensors")
+@strict
+class UVDocBackboneConfig(BackboneConfigMixin, PreTrainedConfig):
+ r"""
+ resnet_head (`Sequence[list[int] | tuple[int, ...]]`, *optional*, defaults to `((3, 32), (32, 32))`):
+ Configuration for the ResNet head layers in format [in_channels, out_channels].
+ resnet_configs (`Sequence[Sequence[tuple[int, int, int, bool] | list[int | bool]]]`, *optional*, defaults to `(((32, 32, 1, False),
+ (32, 32, 3, False), (32, 32, 3, False)), ((32, 64, 1, True), (64, 64, 3, False), (64, 64, 3, False), (64, 64, 3, False)), ((64, 128, 1, True),
+ (128, 128, 3, False), (128, 128, 3, False), (128, 128, 3, False), (128, 128, 3, False), (128, 128, 3, False)))`):
+ Configuration for the ResNet stages in format [in_channels, out_channels, dilation_value, downsample].
+ stage_configs (Sequence[Sequence[tuple[int, ...] | list[int]]], *optional*, defaults to `(((128, 1),), ((128, 2),),
+ ((128, 5),), ((128, 8),(128, 3),(128, 2),), ((128, 12), (128, 7), (128, 4),), ((128, 18), (128, 12), (128, 6),),)`):
+ Configuration for the bridge module stages in format [in_channels, dilation_value].
+ Each inner sequence corresponds to a single bridge block, and the outer sequence groups blocks by bridge stage.
+ """
+
+ model_type = "uvdoc_backbone"
+
+ _out_features: list[str] | None = None
+ _out_indices: list[int] | None = None
+
+ resnet_head: Sequence[list[int] | tuple[int, ...]] = (
+ (3, 32),
+ (32, 32),
+ )
+
+ resnet_configs: Sequence[Sequence[tuple[int, int, int, bool] | list[int | bool]]] = (
+ (
+ (32, 32, 1, False),
+ (32, 32, 3, False),
+ (32, 32, 3, False),
+ ),
+ (
+ (32, 64, 1, True),
+ (64, 64, 3, False),
+ (64, 64, 3, False),
+ (64, 64, 3, False),
+ ),
+ (
+ (64, 128, 1, True),
+ (128, 128, 3, False),
+ (128, 128, 3, False),
+ (128, 128, 3, False),
+ (128, 128, 3, False),
+ (128, 128, 3, False),
+ ),
+ )
+
+ stage_configs: Sequence[Sequence[tuple[int, ...] | list[int]]] = (
+ ((128, 1),),
+ ((128, 2),),
+ ((128, 5),),
+ (
+ (128, 8),
+ (128, 3),
+ (128, 2),
+ ),
+ (
+ (128, 12),
+ (128, 7),
+ (128, 4),
+ ),
+ (
+ (128, 18),
+ (128, 12),
+ (128, 6),
+ ),
+ )
+
+ kernel_size: int = 5
+
+ def __post_init__(self, **kwargs):
+ self.depths = [len(stages) for stages in self.stage_configs]
+ self.stage_names = ["stem"] + [f"stage{idx}" for idx in range(1, len(self.stage_configs) + 1)]
+ self.set_output_features_output_indices(
+ out_indices=kwargs.pop("out_indices", None), out_features=kwargs.pop("out_features", None)
+ )
+ super().__post_init__(**kwargs)
+
+
+@auto_docstring(checkpoint="PaddlePaddle/UVDoc_safetensors")
+@strict
+class UVDocConfig(PreTrainedConfig):
+ r"""
+ padding_mode (`str`, *optional*, defaults to `"reflect"`):
+ Padding mode for convolutional layers. Supported modes are `"reflect"`, `"constant"`, and `"replicate"`.
+ kernel_size (`int`, *optional*, defaults to 5):
+ Kernel size for convolutional layers in the backbone network.
+ bridge_connector (`list[int] | tuple[int, ...]`, *optional*, defaults to `(128, 128)`):
+ Configuration for the bridge connector in format [in_channels, out_channels].
+ out_point_positions2D (`Sequence[list[int] | tuple[int, ...]]`, *optional*, defaults to `((128, 32), (32, 2))`):
+ Configuration for the output point positions 2D layer in format [in_channels, out_channels].
+ """
+
+ model_type = "uvdoc"
+ sub_configs = {"backbone_config": AutoConfig}
+ backbone_config: dict | PreTrainedConfig | None = None
+
+ hidden_act: str = "prelu"
+ padding_mode: str = "reflect"
+ kernel_size: int = 5
+ bridge_connector: list[int] | tuple[int, ...] = (128, 128)
+ out_point_positions2D: Sequence[list[int] | tuple[int, ...]] = ((128, 32), (32, 2))
+
+ def __post_init__(self, **kwargs):
+ self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+ backbone_config=self.backbone_config,
+ default_config_type="uvdoc_backbone",
+ **kwargs,
+ )
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["UVDocBackboneConfig", "UVDocConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/image_processing_uvdoc.py b/lib/python3.11/site-packages/transformers/models/uvdoc/image_processing_uvdoc.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c4e17c7845a864809209e77650125cf8eae2899
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/uvdoc/image_processing_uvdoc.py
@@ -0,0 +1,147 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/uvdoc/modular_uvdoc.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_uvdoc.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 torch
+import torch.nn.functional as F
+
+from ...feature_extraction_utils import BatchFeature
+from ...image_processing_backends import TorchvisionBackend
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import PILImageResampling, SizeDict
+from ...utils import auto_docstring
+from ...utils.generic import TensorType
+from ...utils.import_utils import requires
+
+
+@auto_docstring
+@requires(backends=("torch",))
+class UVDocImageProcessor(TorchvisionBackend):
+ do_rescale = True
+ do_resize = True
+ size = {"height": 712, "width": 488}
+ resample = PILImageResampling.BILINEAR
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+ processed_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ stacked_images = self.rescale_and_normalize(
+ stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ # RGB to BGR conversion
+ stacked_images = stacked_images[:, [2, 1, 0], :, :]
+ processed_images_grouped[shape] = stacked_images
+
+ rescale_and_normalize_images = reorder_images(processed_images_grouped, grouped_images_index)
+
+ original_images = rescale_and_normalize_images.copy()
+
+ grouped_images, grouped_images_index = group_images_by_shape(
+ rescale_and_normalize_images, disable_grouping=disable_grouping
+ )
+ interpolated_images_grouped = {}
+ # Upsample images and extract originals for post-processing
+ for shape, stacked_images in grouped_images.items():
+ # Interpolate to target size (use interpolate with align_corners=True to match original implementation)
+ if do_resize:
+ stacked_images = F.interpolate(
+ stacked_images, size=(size.height, size.width), mode="bilinear", align_corners=True
+ )
+ interpolated_images_grouped[shape] = stacked_images
+
+ pixel_values = reorder_images(interpolated_images_grouped, grouped_images_index)
+
+ return BatchFeature(
+ data={"pixel_values": pixel_values, "original_images": original_images},
+ tensor_type=return_tensors,
+ skip_tensor_conversion=["original_images"],
+ )
+
+ def post_process_document_rectification(
+ self,
+ prediction: torch.Tensor,
+ original_images: list[torch.Tensor],
+ scale: float = 255.0,
+ ) -> list[dict[str, torch.Tensor]]:
+ """
+ Post-process document rectification predictions to convert them into rectified images.
+
+ Args:
+ prediction: Predicted 2D Bezier mesh coordinates, shape (B, 2, H, W)
+ original_images: List of original input tensors, each of shape (C, H_i, W_i). Images may have different sizes.
+ scale: Scaling factor for output images (default: 255.0)
+
+ Returns:
+ List of dictionaries containing rectified images. Each dictionary has:
+ - "images": Rectified image tensor of shape (H, W, 3) with dtype torch.uint8
+ and BGR channel order (suitable for OpenCV visualization)
+ """
+ image_list = list(original_images)
+ scale = torch.tensor(float(scale), device=prediction.device)
+ results = []
+
+ for i, original_image in enumerate(image_list):
+ # Ensure (1, C, H, W) for grid_sample
+ if original_image.ndim == 3:
+ original_image = original_image.unsqueeze(0)
+ original_image = original_image.to(prediction.device)
+ original_height, original_width = original_image.shape[2:]
+
+ # Upsample predicted mesh for this image to its original size
+ upsampled_mesh = F.interpolate(
+ prediction[i : i + 1],
+ size=(original_height, original_width),
+ mode="bilinear",
+ align_corners=True,
+ )
+ # Permute mesh for grid_sample: (1, H, W, 2)
+ rearranged_mesh = upsampled_mesh.permute(0, 2, 3, 1)
+
+ # Apply spatial transformation to rectify the document
+ rectified = F.grid_sample(original_image, rearranged_mesh, align_corners=True)
+
+ # Remove batch dimension and rearrange channels: (H, W, C)
+ image = rectified.squeeze(0).permute(1, 2, 0)
+
+ # Scale and convert to uint8 with BGR channel
+ image = image * scale
+
+ image = image.flip(dims=[-1]).to(dtype=torch.uint8, non_blocking=True, copy=False)
+
+ results.append({"images": image})
+
+ return results
+
+
+__all__ = ["UVDocImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/modeling_uvdoc.py b/lib/python3.11/site-packages/transformers/models/uvdoc/modeling_uvdoc.py
new file mode 100644
index 0000000000000000000000000000000000000000..7bcb3ed225369e541f1b893444cf58f59e1c1e26
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/uvdoc/modeling_uvdoc.py
@@ -0,0 +1,391 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/uvdoc/modular_uvdoc.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_uvdoc.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 torch
+import torch.nn as nn
+
+from ...activations import ACT2FN
+from ...backbone_utils import BackboneMixin, filter_output_hidden_states
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BackboneOutput, BaseModelOutputWithNoAttention
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_uvdoc import UVDocBackboneConfig, UVDocConfig
+
+
+class UVDocConvLayer(nn.Module):
+ """Convolutional layer with batch normalization and activation."""
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int = 3,
+ stride: int = 1,
+ padding: int = 0,
+ padding_mode: str = "zeros",
+ bias: bool = False,
+ dilation: int = 1,
+ activation: str = "relu",
+ ):
+ super().__init__()
+
+ self.convolution = nn.Conv2d(
+ in_channels,
+ out_channels,
+ bias=bias,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=padding,
+ padding_mode=padding_mode,
+ dilation=dilation,
+ )
+ self.normalization = nn.BatchNorm2d(out_channels)
+ self.activation = ACT2FN[activation] if activation is not None else nn.Identity()
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.convolution(hidden_states)
+ hidden_states = self.normalization(hidden_states)
+ hidden_states = self.activation(hidden_states)
+ return hidden_states
+
+
+class UVDocResidualBlock(nn.Module):
+ """Base residual block with dilation support."""
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ stride: int = 1,
+ padding: int = 0,
+ dilation: int = 1,
+ downsample: bool = False,
+ activation: str = "relu",
+ ):
+ super().__init__()
+
+ self.conv_down = (
+ UVDocConvLayer(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=kernel_size // 2,
+ bias=True,
+ activation=None,
+ )
+ if downsample
+ else nn.Identity()
+ )
+
+ self.conv_start = UVDocConvLayer(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=padding,
+ dilation=dilation,
+ bias=True,
+ )
+
+ self.conv_final = UVDocConvLayer(
+ in_channels=out_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=1,
+ padding=padding,
+ bias=True,
+ dilation=dilation,
+ activation=None,
+ )
+
+ self.act_fn = ACT2FN[activation] if activation is not None else nn.Identity()
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ residual = self.conv_down(hidden_states)
+ hidden_states = self.conv_start(hidden_states)
+ hidden_states = self.conv_final(hidden_states)
+ hidden_states = hidden_states + residual
+ hidden_states = self.act_fn(hidden_states)
+ return hidden_states
+
+
+class UVDocResNetStage(nn.Module):
+ """A ResNet stage containing multiple residual blocks."""
+
+ def __init__(self, config, stage_index):
+ super().__init__()
+
+ stages = config.resnet_configs[stage_index]
+ self.layers = nn.ModuleList([])
+ for in_channels, out_channels, dilation, downsample in stages:
+ self.layers.append(
+ UVDocResidualBlock(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ stride=2 if downsample else 1,
+ padding=dilation * 2,
+ dilation=dilation,
+ downsample=downsample,
+ kernel_size=config.kernel_size,
+ )
+ )
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ for layer in self.layers:
+ hidden_states = layer(hidden_states)
+ return hidden_states
+
+
+class UVDocResNet(nn.Module):
+ """Initial resnet_head and resnet_down."""
+
+ def __init__(self, config):
+ super().__init__()
+ self.resnet_head = nn.ModuleList([])
+ for i in range(len(config.resnet_head)):
+ self.resnet_head.append(
+ UVDocConvLayer(
+ in_channels=config.resnet_head[i][0],
+ out_channels=config.resnet_head[i][1],
+ kernel_size=config.kernel_size,
+ stride=2,
+ padding=config.kernel_size // 2,
+ )
+ )
+
+ self.resnet_down = nn.ModuleList([])
+ for stage_index in range(len(config.resnet_configs)):
+ stage = UVDocResNetStage(config, stage_index)
+ self.resnet_down.append(stage)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ for head in self.resnet_head:
+ hidden_states = head(hidden_states)
+ for stage in self.resnet_down:
+ hidden_states = stage(hidden_states)
+ return hidden_states
+
+
+class UVDocBridgeBlock(GradientCheckpointingLayer):
+ """Bridge module with dilated convolutions for long-range dependencies."""
+
+ def __init__(self, config, bridge_index):
+ super().__init__()
+ self.blocks = nn.ModuleList([])
+ bridge = config.stage_configs[bridge_index]
+ for in_channels, dilation in bridge:
+ self.blocks.append(UVDocConvLayer(in_channels, in_channels, padding=dilation, dilation=dilation))
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ for block in self.blocks:
+ hidden_states = block(hidden_states)
+ return hidden_states
+
+
+class UVDocPointPositions2D(nn.Module):
+ """Module for predicting 2D point positions for document rectification."""
+
+ def __init__(self, config):
+ super().__init__()
+
+ self.conv_down = UVDocConvLayer(
+ in_channels=config.out_point_positions2D[0][0],
+ out_channels=config.out_point_positions2D[0][1],
+ kernel_size=config.kernel_size,
+ stride=1,
+ padding=config.kernel_size // 2,
+ padding_mode=config.padding_mode,
+ activation=config.hidden_act,
+ )
+
+ self.conv_up = nn.Conv2d(
+ in_channels=config.out_point_positions2D[1][0],
+ out_channels=config.out_point_positions2D[1][1],
+ kernel_size=config.kernel_size,
+ stride=1,
+ padding=config.kernel_size // 2,
+ padding_mode=config.padding_mode,
+ )
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.conv_down(hidden_states)
+ hidden_states = self.conv_up(hidden_states)
+ return hidden_states
+
+
+@auto_docstring
+class UVDocPreTrainedModel(PreTrainedModel):
+ """
+ Base class for all PPOCRV5 Server Det pre-trained models. Handles model initialization,
+ configuration, and loading of pre-trained weights, following the Transformers library conventions.
+ """
+
+ config: UVDocConfig
+ base_model_prefix = "uvdoc"
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ _can_compile_fullgraph = True
+ supports_gradient_checkpointing = True
+ _can_record_outputs = {
+ "hidden_states": UVDocBridgeBlock,
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ """Initialize the weights."""
+ if isinstance(module, nn.PReLU):
+ module.reset_parameters()
+
+
+class UVDocBridge(UVDocPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.bridge = nn.ModuleList([])
+ for bridge_index in range(len(config.stage_configs)):
+ self.bridge.append(UVDocBridgeBlock(config, bridge_index))
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ for layer in self.bridge:
+ feature = layer(hidden_states)
+ return BaseModelOutputWithNoAttention(last_hidden_state=feature)
+
+
+@auto_docstring(
+ custom_intro="""
+ UVDoc backbone model for feature extraction.
+ """
+)
+class UVDocBackbone(BackboneMixin, UVDocPreTrainedModel):
+ has_attentions = False
+ base_model_prefix = "backbone"
+
+ def __init__(self, config: UVDocBackboneConfig):
+ super().__init__(config)
+
+ num_features = [config.resnet_head[-1][-1]]
+ for stage in config.stage_configs:
+ num_features.append(stage[0][1])
+ self.num_features = num_features
+
+ self.resnet = UVDocResNet(config)
+ self.bridge = UVDocBridge(config)
+
+ self.post_init()
+
+ @can_return_tuple
+ @filter_output_hidden_states
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BackboneOutput:
+ kwargs["output_hidden_states"] = True # required to extract layers for the stages
+ hidden_states = self.resnet(pixel_values)
+ outputs = self.bridge(hidden_states, **kwargs)
+
+ feature_maps = ()
+ for idx, stage in enumerate(self.stage_names):
+ if stage in self.out_features:
+ feature_maps += (outputs.hidden_states[idx],)
+
+ return BackboneOutput(
+ feature_maps=feature_maps,
+ hidden_states=outputs.hidden_states,
+ )
+
+
+class UVDocHead(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.num_bridge_layers = len(config.backbone_config.stage_configs)
+
+ self.bridge_connector = UVDocConvLayer(
+ in_channels=config.bridge_connector[0] * self.num_bridge_layers,
+ out_channels=config.bridge_connector[1],
+ kernel_size=1,
+ stride=1,
+ padding=0,
+ dilation=1,
+ )
+
+ self.out_point_positions2D = UVDocPointPositions2D(config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.torch.Tensor:
+ hidden_states = self.bridge_connector(hidden_states)
+ hidden_states = self.out_point_positions2D(hidden_states)
+ return hidden_states
+
+
+@auto_docstring(
+ custom_intro=r"""
+ The model takes raw document images (pixel values) as input, processes them through the UVDoc backbone to predict spatial transformation parameters,
+ and outputs the rectified (corrected) document image tensor.
+ """
+)
+class UVDocModel(UVDocPreTrainedModel):
+ def __init__(self, config: UVDocConfig):
+ super().__init__(config)
+
+ self.backbone = UVDocBackbone(config.backbone_config)
+ self.head = UVDocHead(config)
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | BaseModelOutputWithNoAttention:
+ backbone_outputs = self.backbone(pixel_values, **kwargs)
+ fused_outputs = torch.cat(backbone_outputs.feature_maps, dim=1)
+ last_hidden_state = self.head(fused_outputs, **kwargs)
+
+ return BaseModelOutputWithNoAttention(
+ last_hidden_state=last_hidden_state,
+ hidden_states=backbone_outputs.hidden_states,
+ )
+
+
+__all__ = ["UVDocBridge", "UVDocBackbone", "UVDocModel", "UVDocPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/uvdoc/modular_uvdoc.py b/lib/python3.11/site-packages/transformers/models/uvdoc/modular_uvdoc.py
new file mode 100644
index 0000000000000000000000000000000000000000..a27b0847663760d5f1c30f82d68250e6b30e0bf6
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/uvdoc/modular_uvdoc.py
@@ -0,0 +1,618 @@
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. 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 collections.abc import Sequence
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from huggingface_hub.dataclasses import strict
+
+from ...activations import ACT2FN
+from ...backbone_utils import (
+ BackboneConfigMixin,
+ BackboneMixin,
+ consolidate_backbone_kwargs_to_config,
+ filter_output_hidden_states,
+)
+from ...configuration_utils import PreTrainedConfig
+from ...feature_extraction_utils import BatchFeature
+from ...image_processing_backends import TorchvisionBackend
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import PILImageResampling, SizeDict
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BackboneOutput, BaseModelOutputWithNoAttention
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ...utils.generic import TensorType, merge_with_config_defaults
+from ...utils.import_utils import requires
+from ...utils.output_capturing import capture_outputs
+from ..auto import AutoConfig
+from ..pp_lcnet.modeling_pp_lcnet import PPLCNetConvLayer
+from ..pp_ocrv5_server_det.modeling_pp_ocrv5_server_det import PPOCRV5ServerDetPreTrainedModel
+
+
+@auto_docstring(checkpoint="PaddlePaddle/UVDoc_safetensors")
+@strict
+class UVDocBackboneConfig(BackboneConfigMixin, PreTrainedConfig):
+ r"""
+ resnet_head (`Sequence[list[int] | tuple[int, ...]]`, *optional*, defaults to `((3, 32), (32, 32))`):
+ Configuration for the ResNet head layers in format [in_channels, out_channels].
+ resnet_configs (`Sequence[Sequence[tuple[int, int, int, bool] | list[int | bool]]]`, *optional*, defaults to `(((32, 32, 1, False),
+ (32, 32, 3, False), (32, 32, 3, False)), ((32, 64, 1, True), (64, 64, 3, False), (64, 64, 3, False), (64, 64, 3, False)), ((64, 128, 1, True),
+ (128, 128, 3, False), (128, 128, 3, False), (128, 128, 3, False), (128, 128, 3, False), (128, 128, 3, False)))`):
+ Configuration for the ResNet stages in format [in_channels, out_channels, dilation_value, downsample].
+ stage_configs (Sequence[Sequence[tuple[int, ...] | list[int]]], *optional*, defaults to `(((128, 1),), ((128, 2),),
+ ((128, 5),), ((128, 8),(128, 3),(128, 2),), ((128, 12), (128, 7), (128, 4),), ((128, 18), (128, 12), (128, 6),),)`):
+ Configuration for the bridge module stages in format [in_channels, dilation_value].
+ Each inner sequence corresponds to a single bridge block, and the outer sequence groups blocks by bridge stage.
+ """
+
+ model_type = "uvdoc_backbone"
+
+ _out_features: list[str] | None = None
+ _out_indices: list[int] | None = None
+
+ resnet_head: Sequence[list[int] | tuple[int, ...]] = (
+ (3, 32),
+ (32, 32),
+ )
+
+ resnet_configs: Sequence[Sequence[tuple[int, int, int, bool] | list[int | bool]]] = (
+ (
+ (32, 32, 1, False),
+ (32, 32, 3, False),
+ (32, 32, 3, False),
+ ),
+ (
+ (32, 64, 1, True),
+ (64, 64, 3, False),
+ (64, 64, 3, False),
+ (64, 64, 3, False),
+ ),
+ (
+ (64, 128, 1, True),
+ (128, 128, 3, False),
+ (128, 128, 3, False),
+ (128, 128, 3, False),
+ (128, 128, 3, False),
+ (128, 128, 3, False),
+ ),
+ )
+
+ stage_configs: Sequence[Sequence[tuple[int, ...] | list[int]]] = (
+ ((128, 1),),
+ ((128, 2),),
+ ((128, 5),),
+ (
+ (128, 8),
+ (128, 3),
+ (128, 2),
+ ),
+ (
+ (128, 12),
+ (128, 7),
+ (128, 4),
+ ),
+ (
+ (128, 18),
+ (128, 12),
+ (128, 6),
+ ),
+ )
+
+ kernel_size: int = 5
+
+ def __post_init__(self, **kwargs):
+ self.depths = [len(stages) for stages in self.stage_configs]
+ self.stage_names = ["stem"] + [f"stage{idx}" for idx in range(1, len(self.stage_configs) + 1)]
+ self.set_output_features_output_indices(
+ out_indices=kwargs.pop("out_indices", None), out_features=kwargs.pop("out_features", None)
+ )
+ super().__post_init__(**kwargs)
+
+
+@auto_docstring(checkpoint="PaddlePaddle/UVDoc_safetensors")
+@strict
+class UVDocConfig(PreTrainedConfig):
+ r"""
+ padding_mode (`str`, *optional*, defaults to `"reflect"`):
+ Padding mode for convolutional layers. Supported modes are `"reflect"`, `"constant"`, and `"replicate"`.
+ kernel_size (`int`, *optional*, defaults to 5):
+ Kernel size for convolutional layers in the backbone network.
+ bridge_connector (`list[int] | tuple[int, ...]`, *optional*, defaults to `(128, 128)`):
+ Configuration for the bridge connector in format [in_channels, out_channels].
+ out_point_positions2D (`Sequence[list[int] | tuple[int, ...]]`, *optional*, defaults to `((128, 32), (32, 2))`):
+ Configuration for the output point positions 2D layer in format [in_channels, out_channels].
+ """
+
+ model_type = "uvdoc"
+ sub_configs = {"backbone_config": AutoConfig}
+ backbone_config: dict | PreTrainedConfig | None = None
+
+ hidden_act: str = "prelu"
+ padding_mode: str = "reflect"
+ kernel_size: int = 5
+ bridge_connector: list[int] | tuple[int, ...] = (128, 128)
+ out_point_positions2D: Sequence[list[int] | tuple[int, ...]] = ((128, 32), (32, 2))
+
+ def __post_init__(self, **kwargs):
+ self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+ backbone_config=self.backbone_config,
+ default_config_type="uvdoc_backbone",
+ **kwargs,
+ )
+ super().__post_init__(**kwargs)
+
+
+@auto_docstring
+@requires(backends=("torch",))
+class UVDocImageProcessor(TorchvisionBackend):
+ do_rescale = True
+ do_resize = True
+ size = {"height": 712, "width": 488}
+ resample = PILImageResampling.BILINEAR
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+ processed_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ stacked_images = self.rescale_and_normalize(
+ stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ # RGB to BGR conversion
+ stacked_images = stacked_images[:, [2, 1, 0], :, :]
+ processed_images_grouped[shape] = stacked_images
+
+ rescale_and_normalize_images = reorder_images(processed_images_grouped, grouped_images_index)
+
+ original_images = rescale_and_normalize_images.copy()
+
+ grouped_images, grouped_images_index = group_images_by_shape(
+ rescale_and_normalize_images, disable_grouping=disable_grouping
+ )
+ interpolated_images_grouped = {}
+ # Upsample images and extract originals for post-processing
+ for shape, stacked_images in grouped_images.items():
+ # Interpolate to target size (use interpolate with align_corners=True to match original implementation)
+ if do_resize:
+ stacked_images = F.interpolate(
+ stacked_images, size=(size.height, size.width), mode="bilinear", align_corners=True
+ )
+ interpolated_images_grouped[shape] = stacked_images
+
+ pixel_values = reorder_images(interpolated_images_grouped, grouped_images_index)
+
+ return BatchFeature(
+ data={"pixel_values": pixel_values, "original_images": original_images},
+ tensor_type=return_tensors,
+ skip_tensor_conversion=["original_images"],
+ )
+
+ def post_process_document_rectification(
+ self,
+ prediction: torch.Tensor,
+ original_images: list[torch.Tensor],
+ scale: float = 255.0,
+ ) -> list[dict[str, torch.Tensor]]:
+ """
+ Post-process document rectification predictions to convert them into rectified images.
+
+ Args:
+ prediction: Predicted 2D Bezier mesh coordinates, shape (B, 2, H, W)
+ original_images: List of original input tensors, each of shape (C, H_i, W_i). Images may have different sizes.
+ scale: Scaling factor for output images (default: 255.0)
+
+ Returns:
+ List of dictionaries containing rectified images. Each dictionary has:
+ - "images": Rectified image tensor of shape (H, W, 3) with dtype torch.uint8
+ and BGR channel order (suitable for OpenCV visualization)
+ """
+ image_list = list(original_images)
+ scale = torch.tensor(float(scale), device=prediction.device)
+ results = []
+
+ for i, original_image in enumerate(image_list):
+ # Ensure (1, C, H, W) for grid_sample
+ if original_image.ndim == 3:
+ original_image = original_image.unsqueeze(0)
+ original_image = original_image.to(prediction.device)
+ original_height, original_width = original_image.shape[2:]
+
+ # Upsample predicted mesh for this image to its original size
+ upsampled_mesh = F.interpolate(
+ prediction[i : i + 1],
+ size=(original_height, original_width),
+ mode="bilinear",
+ align_corners=True,
+ )
+ # Permute mesh for grid_sample: (1, H, W, 2)
+ rearranged_mesh = upsampled_mesh.permute(0, 2, 3, 1)
+
+ # Apply spatial transformation to rectify the document
+ rectified = F.grid_sample(original_image, rearranged_mesh, align_corners=True)
+
+ # Remove batch dimension and rearrange channels: (H, W, C)
+ image = rectified.squeeze(0).permute(1, 2, 0)
+
+ # Scale and convert to uint8 with BGR channel
+ image = image * scale
+
+ image = image.flip(dims=[-1]).to(dtype=torch.uint8, non_blocking=True, copy=False)
+
+ results.append({"images": image})
+
+ return results
+
+
+class UVDocConvLayer(PPLCNetConvLayer):
+ """Convolutional layer with batch normalization and activation."""
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int = 3,
+ stride: int = 1,
+ padding: int = 0,
+ padding_mode: str = "zeros",
+ bias: bool = False,
+ dilation: int = 1,
+ activation: str = "relu",
+ ):
+ super().__init__()
+
+ self.convolution = nn.Conv2d(
+ in_channels,
+ out_channels,
+ bias=bias,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=padding,
+ padding_mode=padding_mode,
+ dilation=dilation,
+ )
+
+
+class UVDocResidualBlock(nn.Module):
+ """Base residual block with dilation support."""
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ stride: int = 1,
+ padding: int = 0,
+ dilation: int = 1,
+ downsample: bool = False,
+ activation: str = "relu",
+ ):
+ super().__init__()
+
+ self.conv_down = (
+ UVDocConvLayer(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=kernel_size // 2,
+ bias=True,
+ activation=None,
+ )
+ if downsample
+ else nn.Identity()
+ )
+
+ self.conv_start = UVDocConvLayer(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=padding,
+ dilation=dilation,
+ bias=True,
+ )
+
+ self.conv_final = UVDocConvLayer(
+ in_channels=out_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=1,
+ padding=padding,
+ bias=True,
+ dilation=dilation,
+ activation=None,
+ )
+
+ self.act_fn = ACT2FN[activation] if activation is not None else nn.Identity()
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ residual = self.conv_down(hidden_states)
+ hidden_states = self.conv_start(hidden_states)
+ hidden_states = self.conv_final(hidden_states)
+ hidden_states = hidden_states + residual
+ hidden_states = self.act_fn(hidden_states)
+ return hidden_states
+
+
+class UVDocResNetStage(nn.Module):
+ """A ResNet stage containing multiple residual blocks."""
+
+ def __init__(self, config, stage_index):
+ super().__init__()
+
+ stages = config.resnet_configs[stage_index]
+ self.layers = nn.ModuleList([])
+ for in_channels, out_channels, dilation, downsample in stages:
+ self.layers.append(
+ UVDocResidualBlock(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ stride=2 if downsample else 1,
+ padding=dilation * 2,
+ dilation=dilation,
+ downsample=downsample,
+ kernel_size=config.kernel_size,
+ )
+ )
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ for layer in self.layers:
+ hidden_states = layer(hidden_states)
+ return hidden_states
+
+
+class UVDocResNet(nn.Module):
+ """Initial resnet_head and resnet_down."""
+
+ def __init__(self, config):
+ super().__init__()
+ self.resnet_head = nn.ModuleList([])
+ for i in range(len(config.resnet_head)):
+ self.resnet_head.append(
+ UVDocConvLayer(
+ in_channels=config.resnet_head[i][0],
+ out_channels=config.resnet_head[i][1],
+ kernel_size=config.kernel_size,
+ stride=2,
+ padding=config.kernel_size // 2,
+ )
+ )
+
+ self.resnet_down = nn.ModuleList([])
+ for stage_index in range(len(config.resnet_configs)):
+ stage = UVDocResNetStage(config, stage_index)
+ self.resnet_down.append(stage)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ for head in self.resnet_head:
+ hidden_states = head(hidden_states)
+ for stage in self.resnet_down:
+ hidden_states = stage(hidden_states)
+ return hidden_states
+
+
+class UVDocBridgeBlock(GradientCheckpointingLayer):
+ """Bridge module with dilated convolutions for long-range dependencies."""
+
+ def __init__(self, config, bridge_index):
+ super().__init__()
+ self.blocks = nn.ModuleList([])
+ bridge = config.stage_configs[bridge_index]
+ for in_channels, dilation in bridge:
+ self.blocks.append(UVDocConvLayer(in_channels, in_channels, padding=dilation, dilation=dilation))
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ for block in self.blocks:
+ hidden_states = block(hidden_states)
+ return hidden_states
+
+
+class UVDocPointPositions2D(nn.Module):
+ """Module for predicting 2D point positions for document rectification."""
+
+ def __init__(self, config):
+ super().__init__()
+
+ self.conv_down = UVDocConvLayer(
+ in_channels=config.out_point_positions2D[0][0],
+ out_channels=config.out_point_positions2D[0][1],
+ kernel_size=config.kernel_size,
+ stride=1,
+ padding=config.kernel_size // 2,
+ padding_mode=config.padding_mode,
+ activation=config.hidden_act,
+ )
+
+ self.conv_up = nn.Conv2d(
+ in_channels=config.out_point_positions2D[1][0],
+ out_channels=config.out_point_positions2D[1][1],
+ kernel_size=config.kernel_size,
+ stride=1,
+ padding=config.kernel_size // 2,
+ padding_mode=config.padding_mode,
+ )
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.conv_down(hidden_states)
+ hidden_states = self.conv_up(hidden_states)
+ return hidden_states
+
+
+@auto_docstring
+class UVDocPreTrainedModel(PPOCRV5ServerDetPreTrainedModel):
+ supports_gradient_checkpointing = True
+ _can_record_outputs = {
+ "hidden_states": UVDocBridgeBlock,
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ PreTrainedModel._init_weights(module)
+ """Initialize the weights."""
+ if isinstance(module, nn.PReLU):
+ module.reset_parameters()
+
+
+class UVDocBridge(UVDocPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.bridge = nn.ModuleList([])
+ for bridge_index in range(len(config.stage_configs)):
+ self.bridge.append(UVDocBridgeBlock(config, bridge_index))
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ for layer in self.bridge:
+ feature = layer(hidden_states)
+ return BaseModelOutputWithNoAttention(last_hidden_state=feature)
+
+
+@auto_docstring(
+ custom_intro="""
+ UVDoc backbone model for feature extraction.
+ """
+)
+class UVDocBackbone(BackboneMixin, UVDocPreTrainedModel):
+ has_attentions = False
+ base_model_prefix = "backbone"
+
+ def __init__(self, config: UVDocBackboneConfig):
+ super().__init__(config)
+
+ num_features = [config.resnet_head[-1][-1]]
+ for stage in config.stage_configs:
+ num_features.append(stage[0][1])
+ self.num_features = num_features
+
+ self.resnet = UVDocResNet(config)
+ self.bridge = UVDocBridge(config)
+
+ self.post_init()
+
+ @can_return_tuple
+ @filter_output_hidden_states
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BackboneOutput:
+ kwargs["output_hidden_states"] = True # required to extract layers for the stages
+ hidden_states = self.resnet(pixel_values)
+ outputs = self.bridge(hidden_states, **kwargs)
+
+ feature_maps = ()
+ for idx, stage in enumerate(self.stage_names):
+ if stage in self.out_features:
+ feature_maps += (outputs.hidden_states[idx],)
+
+ return BackboneOutput(
+ feature_maps=feature_maps,
+ hidden_states=outputs.hidden_states,
+ )
+
+
+class UVDocHead(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.num_bridge_layers = len(config.backbone_config.stage_configs)
+
+ self.bridge_connector = UVDocConvLayer(
+ in_channels=config.bridge_connector[0] * self.num_bridge_layers,
+ out_channels=config.bridge_connector[1],
+ kernel_size=1,
+ stride=1,
+ padding=0,
+ dilation=1,
+ )
+
+ self.out_point_positions2D = UVDocPointPositions2D(config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.torch.Tensor:
+ hidden_states = self.bridge_connector(hidden_states)
+ hidden_states = self.out_point_positions2D(hidden_states)
+ return hidden_states
+
+
+@auto_docstring(
+ custom_intro=r"""
+ The model takes raw document images (pixel values) as input, processes them through the UVDoc backbone to predict spatial transformation parameters,
+ and outputs the rectified (corrected) document image tensor.
+ """
+)
+class UVDocModel(UVDocPreTrainedModel):
+ def __init__(self, config: UVDocConfig):
+ super().__init__(config)
+
+ self.backbone = UVDocBackbone(config.backbone_config)
+ self.head = UVDocHead(config)
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.FloatTensor] | BaseModelOutputWithNoAttention:
+ backbone_outputs = self.backbone(pixel_values, **kwargs)
+ fused_outputs = torch.cat(backbone_outputs.feature_maps, dim=1)
+ last_hidden_state = self.head(fused_outputs, **kwargs)
+
+ return BaseModelOutputWithNoAttention(
+ last_hidden_state=last_hidden_state,
+ hidden_states=backbone_outputs.hidden_states,
+ )
+
+
+__all__ = [
+ "UVDocBridge",
+ "UVDocBackbone",
+ "UVDocBackboneConfig",
+ "UVDocImageProcessor",
+ "UVDocConfig",
+ "UVDocModel",
+ "UVDocPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/vaultgemma/__init__.py b/lib/python3.11/site-packages/transformers/models/vaultgemma/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e41a0e15febbd8cb5cccdc0867560b7c70d10d80
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vaultgemma/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2025 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_vaultgemma import *
+ from .modeling_vaultgemma import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7071b23e96063c6e8c6f8f257cc485327a62908
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/configuration_vaultgemma.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/configuration_vaultgemma.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b907f80f03475daeb297760f7466a24aa5ba3aa4
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/configuration_vaultgemma.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/modeling_vaultgemma.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/modeling_vaultgemma.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e9f374b63f57fc3fa280947392f19b6de25da08
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/modeling_vaultgemma.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/modular_vaultgemma.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/modular_vaultgemma.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a8d87c1e36c0e37ba5f96b10941a2546a2f6c4c
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vaultgemma/__pycache__/modular_vaultgemma.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vaultgemma/configuration_vaultgemma.py b/lib/python3.11/site-packages/transformers/models/vaultgemma/configuration_vaultgemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..a60b7e8edc0c8c9928fe0dd27a80c7ffcf08d316
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vaultgemma/configuration_vaultgemma.py
@@ -0,0 +1,109 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/vaultgemma/modular_vaultgemma.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_vaultgemma.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...modeling_rope_utils import RopeParameters
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="google/vaultgemma-1b")
+@strict
+class VaultGemmaConfig(PreTrainedConfig):
+ r"""
+ query_pre_attn_scalar (`float`, *optional*, defaults to 256):
+ scaling factor used on the attention scores
+ final_logit_softcapping (`float`, *optional*, defaults to 30.0):
+ scaling factor when applying tanh softcapping on the logits.
+ attn_logit_softcapping (`float`, *optional*, defaults to 50.0):
+ scaling factor when applying tanh softcapping on the attention scores.
+
+ ```python
+ >>> from transformers import VaultGemmaModel, VaultGemmaConfig
+ >>> # Initializing a VaultGemma vaultgemma-7b style configuration
+ >>> configuration = VaultGemmaConfig()
+ >>> # Initializing a model from the vaultgemma-7b style configuration
+ >>> model = VaultGemmaModel(configuration)
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "vaultgemma"
+ keys_to_ignore_at_inference = ["past_key_values"]
+ base_model_tp_plan = {
+ "layers.*.self_attn.q_proj": "colwise",
+ "layers.*.self_attn.k_proj": "colwise",
+ "layers.*.self_attn.v_proj": "colwise",
+ "layers.*.self_attn.o_proj": "rowwise",
+ "layers.*.mlp.gate_proj": "colwise",
+ "layers.*.mlp.up_proj": "colwise",
+ "layers.*.mlp.down_proj": "rowwise",
+ }
+ base_model_pp_plan = {
+ "embed_tokens": (["input_ids"], ["inputs_embeds"]),
+ "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
+ "norm": (["hidden_states"], ["hidden_states"]),
+ }
+
+ vocab_size: int = 256000
+ hidden_size: int = 2304
+ intermediate_size: int = 9216
+ num_hidden_layers: int = 26
+ num_attention_heads: int = 8
+ num_key_value_heads: int = 4
+ head_dim: int = 256
+ hidden_activation: str = "gelu_pytorch_tanh"
+ max_position_embeddings: int = 8192
+ initializer_range: float = 0.02
+ rms_norm_eps: float = 1e-6
+ use_cache: bool = True
+ pad_token_id: int | None = 0
+ eos_token_id: int | list[int] | None = 1
+ bos_token_id: int | None = 2
+ tie_word_embeddings: bool = True
+ rope_parameters: RopeParameters | dict | None = None
+ attention_bias: bool = False
+ attention_dropout: int | float | None = 0.0
+ query_pre_attn_scalar: int = 256
+ sliding_window: int | None = 4096
+ layer_types: list[str] | None = None
+ final_logit_softcapping: float | None = 30.0
+ attn_logit_softcapping: float | None = 50.0
+
+ def __post_init__(self, **kwargs):
+ if self.layer_types is None:
+ self.layer_types = [
+ "sliding_attention" if bool((i + 1) % 2) else "full_attention" for i in range(self.num_hidden_layers)
+ ]
+
+ super().__post_init__(**kwargs)
+
+ def validate_architecture(self):
+ """Part of `@strict`-powered validation. Validates the architecture of the config."""
+ if self.hidden_size % self.num_attention_heads != 0:
+ raise ValueError(
+ f"The hidden size ({self.hidden_size}) is not a multiple of the number of attention "
+ f"heads ({self.num_attention_heads})."
+ )
+
+
+__all__ = ["VaultGemmaConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/vaultgemma/modeling_vaultgemma.py b/lib/python3.11/site-packages/transformers/models/vaultgemma/modeling_vaultgemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..f0a2e48d20b8fd36e6a096baa1b5d28c10f3b8b4
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vaultgemma/modeling_vaultgemma.py
@@ -0,0 +1,546 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/vaultgemma/modular_vaultgemma.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_vaultgemma.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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 collections.abc import Callable
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache
+from ...generation import GenerationMixin
+from ...integrations import use_kernel_func_from_hub, use_kernelized_func
+from ...masking_utils import create_causal_mask, create_sliding_window_causal_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
+from ...modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ...utils.generic import maybe_autocast, merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_vaultgemma import VaultGemmaConfig
+
+
+class VaultGemmaRMSNorm(nn.Module):
+ def __init__(self, dim: int, eps: float = 1e-6):
+ super().__init__()
+ self.eps = eps
+ self.weight = nn.Parameter(torch.zeros(dim))
+
+ def _norm(self, x):
+ return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+ def forward(self, x):
+ output = self._norm(x.float())
+ # Llama does x.to(float16) * w whilst VaultGemma is (x * w).to(float16)
+ # See https://github.com/huggingface/transformers/pull/29402
+ output = output * (1.0 + self.weight.float())
+ return output.type_as(x)
+
+ def extra_repr(self):
+ return f"{tuple(self.weight.shape)}, eps={self.eps}"
+
+
+class VaultGemmaMLP(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.hidden_size = config.hidden_size
+ self.intermediate_size = config.intermediate_size
+ self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+ self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+ self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
+ self.act_fn = ACT2FN[config.hidden_activation]
+
+ def forward(self, x):
+ down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+ return down_proj
+
+
+def rotate_half(x):
+ """Rotates half the hidden dims of the input."""
+ x1 = x[..., : x.shape[-1] // 2]
+ x2 = x[..., x.shape[-1] // 2 :]
+ return torch.cat((-x2, x1), dim=-1)
+
+
+@use_kernel_func_from_hub("rotary_pos_emb")
+def apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1):
+ """Applies Rotary Position Embedding to the query and key tensors.
+
+ Args:
+ q (`torch.Tensor`): The query tensor.
+ k (`torch.Tensor`): The key tensor.
+ cos (`torch.Tensor`): The cosine part of the rotary embedding.
+ sin (`torch.Tensor`): The sine part of the rotary embedding.
+ unsqueeze_dim (`int`, *optional*, defaults to 1):
+ The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+ sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+ that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+ k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+ cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+ the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+ Returns:
+ `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+ """
+ cos = cos.unsqueeze(unsqueeze_dim)
+ sin = sin.unsqueeze(unsqueeze_dim)
+ q_embed = (q * cos) + (rotate_half(q) * sin)
+ k_embed = (k * cos) + (rotate_half(k) * sin)
+ return q_embed, k_embed
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+ """
+ This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+ num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+ """
+ batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+ if n_rep == 1:
+ return hidden_states
+ hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+ return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ dropout: float | int = 0.0,
+ scaling: float | None = None,
+ softcap: float | None = None,
+ **kwargs,
+) -> tuple[torch.Tensor, torch.Tensor]:
+ if scaling is None:
+ scaling = module.head_dim**-0.5
+
+ key_states = repeat_kv(key, module.num_key_value_groups)
+ value_states = repeat_kv(value, module.num_key_value_groups)
+
+ attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
+
+ if softcap is not None:
+ attn_weights = attn_weights / softcap
+ attn_weights = torch.tanh(attn_weights)
+ attn_weights = attn_weights * softcap
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ # upcast attention to fp32
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value_states)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+ return attn_output, attn_weights
+
+
+@use_kernelized_func(apply_rotary_pos_emb)
+class VaultGemmaAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config: VaultGemmaConfig, layer_idx: int):
+ super().__init__()
+ self.layer_type = config.layer_types[layer_idx] if hasattr(config, "layer_types") else None
+ self.config = config
+ self.layer_idx = layer_idx
+ self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
+ self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
+ self.scaling = config.query_pre_attn_scalar**-0.5
+ self.attention_dropout = self.config.attention_dropout
+ self.is_causal = True
+
+ self.q_proj = nn.Linear(
+ config.hidden_size, config.num_attention_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.k_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.v_proj = nn.Linear(
+ config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
+ )
+ self.o_proj = nn.Linear(
+ config.num_attention_heads * self.head_dim, config.hidden_size, bias=config.attention_bias
+ )
+ self.attn_logit_softcapping = self.config.attn_logit_softcapping
+ self.sliding_window = config.sliding_window if self.layer_type == "sliding_attention" else None
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+ attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None, tuple[torch.Tensor] | None]:
+ input_shape = hidden_states.shape[:-1]
+ hidden_shape = (*input_shape, -1, self.head_dim)
+
+ query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
+
+ if past_key_values is not None:
+ key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask,
+ dropout=self.attention_dropout if self.training else 0.0,
+ scaling=self.scaling,
+ sliding_window=self.sliding_window,
+ softcap=self.attn_logit_softcapping,
+ **kwargs,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.o_proj(attn_output)
+ return attn_output, attn_weights
+
+
+class VaultGemmaDecoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: VaultGemmaConfig, layer_idx: int):
+ super().__init__()
+ self.hidden_size = config.hidden_size
+ self.config = config
+ self.self_attn = VaultGemmaAttention(config=config, layer_idx=layer_idx)
+ self.mlp = VaultGemmaMLP(config)
+ self.input_layernorm = VaultGemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ self.pre_feedforward_layernorm = VaultGemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor, tuple[torch.FloatTensor, torch.FloatTensor] | None]:
+ residual = hidden_states
+ hidden_states = self.input_layernorm(hidden_states)
+ # Self Attention
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ **kwargs,
+ )
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = residual + hidden_states
+
+ return hidden_states
+
+
+class VaultGemmaRotaryEmbedding(nn.Module):
+ inv_freq: torch.Tensor # fix linting for `register_buffer`
+
+ def __init__(self, config: VaultGemmaConfig, device=None):
+ super().__init__()
+ self.max_seq_len_cached = config.max_position_embeddings
+ self.original_max_seq_len = config.max_position_embeddings
+
+ self.config = config
+
+ self.rope_type = self.config.rope_parameters["rope_type"]
+ rope_init_fn: Callable = self.compute_default_rope_parameters
+ if self.rope_type != "default":
+ rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
+ inv_freq, self.attention_scaling = rope_init_fn(self.config, device)
+
+ self.register_buffer("inv_freq", inv_freq, persistent=False)
+ self.register_buffer("original_inv_freq", inv_freq.clone(), persistent=False)
+
+ @staticmethod
+ def compute_default_rope_parameters(
+ config: VaultGemmaConfig | None = None,
+ device: Optional["torch.device"] = None,
+ seq_len: int | None = None,
+ ) -> tuple["torch.Tensor", float]:
+ """
+ Computes the inverse frequencies according to the original RoPE implementation
+ Args:
+ config ([`~transformers.PreTrainedConfig`]):
+ The model configuration.
+ device (`torch.device`):
+ The device to use for initialization of the inverse frequencies.
+ seq_len (`int`, *optional*):
+ The current sequence length. Unused for this type of RoPE.
+ Returns:
+ Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
+ post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
+ """
+ base = config.rope_parameters["rope_theta"]
+ dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
+
+ attention_factor = 1.0 # Unused in this type of RoPE
+
+ # Compute the inverse frequencies
+ inv_freq = 1.0 / (
+ base ** (torch.arange(0, dim, 2, dtype=torch.int64).to(device=device, dtype=torch.float) / dim)
+ )
+ return inv_freq, attention_factor
+
+ @torch.no_grad()
+ @dynamic_rope_update # power user: used with advanced RoPE types (e.g. dynamic rope)
+ def forward(self, x, position_ids):
+ inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)
+ position_ids_expanded = position_ids[:, None, :].float()
+
+ device_type = x.device.type if isinstance(x.device.type, str) and x.device.type != "mps" else "cpu"
+ with maybe_autocast(device_type=device_type, enabled=False): # Force float32
+ freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2)
+ emb = torch.cat((freqs, freqs), dim=-1)
+ cos = emb.cos() * self.attention_scaling
+ sin = emb.sin() * self.attention_scaling
+
+ return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+class VaultGemmaTextScaledWordEmbedding(nn.Embedding):
+ """
+ This module overrides nn.Embeddings' forward by multiplying with embeddings scale.
+ """
+
+ def __init__(self, num_embeddings: int, embedding_dim: int, padding_idx: int, embed_scale: float = 1.0):
+ super().__init__(num_embeddings, embedding_dim, padding_idx)
+ self.scalar_embed_scale = embed_scale
+ self.register_buffer("embed_scale", torch.tensor(embed_scale), persistent=False)
+
+ def forward(self, input_ids: torch.Tensor):
+ return super().forward(input_ids) * self.embed_scale.to(self.weight.dtype)
+
+
+@auto_docstring
+class VaultGemmaPreTrainedModel(PreTrainedModel):
+ config: VaultGemmaConfig
+ base_model_prefix = "model"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["VaultGemmaDecoderLayer"]
+ _skip_keys_device_placement = ["past_key_values"]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _supports_flex_attn = True
+
+ _can_compile_fullgraph = True
+ _supports_attention_backend = True
+ _can_record_outputs = {
+ "hidden_states": VaultGemmaDecoderLayer,
+ "attentions": VaultGemmaAttention,
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ # We initialize with 0s to be 1 centered as the RMSNorm here does (1 + weight)
+ if "RMSNorm" in module.__class__.__name__:
+ init.zeros_(module.weight)
+ elif isinstance(module, VaultGemmaTextScaledWordEmbedding):
+ init.constant_(module.embed_scale, module.scalar_embed_scale)
+
+
+@auto_docstring
+class VaultGemmaModel(VaultGemmaPreTrainedModel):
+ def __init__(self, config: VaultGemmaConfig):
+ super().__init__(config)
+ self.padding_idx = config.pad_token_id
+ self.vocab_size = config.vocab_size
+ # VaultGemma3 downcasts the below to bfloat16, causing sqrt(3072)=55.4256 to become 55.5. See https://github.com/huggingface/transformers/pull/29402
+ self.embed_tokens = VaultGemmaTextScaledWordEmbedding(
+ config.vocab_size, config.hidden_size, self.padding_idx, embed_scale=self.config.hidden_size**0.5
+ )
+ self.layers = nn.ModuleList(
+ [VaultGemmaDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+ )
+ self.norm = VaultGemmaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+ self.rotary_emb = VaultGemmaRotaryEmbedding(config)
+ self.gradient_checkpointing = False
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutputWithPast:
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ if inputs_embeds is None:
+ inputs_embeds: torch.Tensor = self.embed_tokens(input_ids)
+
+ if use_cache and past_key_values is None:
+ past_key_values = DynamicCache(config=self.config)
+
+ if position_ids is None:
+ past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+ position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens
+ position_ids = position_ids.unsqueeze(0)
+
+ # It may already have been prepared by e.g. `generate`
+ if not isinstance(causal_mask_mapping := attention_mask, dict):
+ # Prepare mask arguments
+ mask_kwargs = {
+ "config": self.config,
+ "inputs_embeds": inputs_embeds,
+ "attention_mask": attention_mask,
+ "past_key_values": past_key_values,
+ "position_ids": position_ids,
+ }
+ # Create the masks
+ causal_mask_mapping = {
+ "full_attention": create_causal_mask(**mask_kwargs),
+ "sliding_attention": create_sliding_window_causal_mask(**mask_kwargs),
+ }
+
+ # embed positions
+ hidden_states = inputs_embeds
+ position_embeddings = self.rotary_emb(hidden_states, position_ids)
+
+ for i, decoder_layer in enumerate(self.layers[: self.config.num_hidden_layers]):
+ hidden_states = decoder_layer(
+ hidden_states,
+ attention_mask=causal_mask_mapping[self.config.layer_types[i]],
+ position_embeddings=position_embeddings,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ **kwargs,
+ )
+
+ hidden_states = self.norm(hidden_states)
+
+ return BaseModelOutputWithPast(
+ last_hidden_state=hidden_states,
+ past_key_values=past_key_values,
+ )
+
+
+@auto_docstring
+class VaultGemmaForCausalLM(VaultGemmaPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}
+ _tp_plan = {"lm_head": "colwise_gather_output"}
+ _pp_plan = {"lm_head": (["hidden_states"], ["logits"])}
+
+ def __init__(self, config):
+ super().__init__(config)
+ self.model = VaultGemmaModel(config)
+ self.vocab_size = config.vocab_size
+ self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ logits_to_keep: int | torch.Tensor = 0,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> CausalLMOutputWithPast:
+ r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, VaultGemmaForCausalLM
+
+ >>> model = VaultGemmaForCausalLM.from_pretrained("google/gemma-2-9b")
+ >>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b")
+
+ >>> prompt = "What is your favorite condiment?"
+ >>> inputs = tokenizer(prompt, return_tensors="pt")
+
+ >>> # Generate
+ >>> generate_ids = model.generate(inputs.input_ids, max_length=30)
+ >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+ "What is your favorite condiment?"
+ ```"""
+ # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
+ outputs: BaseModelOutputWithPast = self.model(
+ input_ids=input_ids,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ hidden_states = outputs.last_hidden_state
+ # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+ slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+ logits = self.lm_head(hidden_states[:, slice_indices, :])
+ if self.config.final_logit_softcapping is not None:
+ logits = logits / self.config.final_logit_softcapping
+ logits = torch.tanh(logits)
+ logits = logits * self.config.final_logit_softcapping
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(logits, labels, self.vocab_size, **kwargs)
+
+ return CausalLMOutputWithPast(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = ["VaultGemmaForCausalLM", "VaultGemmaModel", "VaultGemmaPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/vaultgemma/modular_vaultgemma.py b/lib/python3.11/site-packages/transformers/models/vaultgemma/modular_vaultgemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a4ce67c9a553c5124ff2997defd008a86260f8f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vaultgemma/modular_vaultgemma.py
@@ -0,0 +1,110 @@
+# Copyright 2025 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 torch
+from huggingface_hub.dataclasses import strict
+
+from ...cache_utils import Cache
+from ...utils import auto_docstring
+from ..gemma2.configuration_gemma2 import Gemma2Config
+from ..gemma2.modeling_gemma2 import Gemma2Attention, Gemma2DecoderLayer, Gemma2ForCausalLM, Gemma2MLP, Gemma2RMSNorm
+
+
+@auto_docstring(checkpoint="google/vaultgemma-1b")
+@strict
+class VaultGemmaConfig(Gemma2Config):
+ r"""
+ query_pre_attn_scalar (`float`, *optional*, defaults to 256):
+ scaling factor used on the attention scores
+ final_logit_softcapping (`float`, *optional*, defaults to 30.0):
+ scaling factor when applying tanh softcapping on the logits.
+ attn_logit_softcapping (`float`, *optional*, defaults to 50.0):
+ scaling factor when applying tanh softcapping on the attention scores.
+
+ ```python
+ >>> from transformers import VaultGemmaModel, VaultGemmaConfig
+ >>> # Initializing a VaultGemma vaultgemma-7b style configuration
+ >>> configuration = VaultGemmaConfig()
+ >>> # Initializing a model from the vaultgemma-7b style configuration
+ >>> model = VaultGemmaModel(configuration)
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ use_bidirectional_attention = AttributeError()
+
+
+class VaultGemmaRMSNorm(Gemma2RMSNorm):
+ pass
+
+
+class VaultGemmaMLP(Gemma2MLP):
+ pass
+
+
+class VaultGemmaAttention(Gemma2Attention):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config: VaultGemmaConfig, layer_idx: int):
+ super().__init__()
+ self.is_causal = True
+
+
+class VaultGemmaDecoderLayer(Gemma2DecoderLayer):
+ def __init__(self, **super_kwargs):
+ super().__init__(**super_kwargs)
+ del self.post_attention_layernorm
+ del self.post_feedforward_layernorm
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ **kwargs,
+ ) -> tuple[torch.FloatTensor, tuple[torch.FloatTensor, torch.FloatTensor] | None]:
+ residual = hidden_states
+ hidden_states = self.input_layernorm(hidden_states)
+ # Self Attention
+ hidden_states, _ = self.self_attn(
+ hidden_states=hidden_states,
+ position_embeddings=position_embeddings,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ **kwargs,
+ )
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.pre_feedforward_layernorm(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = residual + hidden_states
+
+ return hidden_states
+
+
+class VaultGemmaForCausalLM(Gemma2ForCausalLM):
+ pass
+
+
+__all__ = [
+ "VaultGemmaConfig",
+ "VaultGemmaForCausalLM",
+ "VaultGemmaModel", # noqa: F822
+ "VaultGemmaPreTrainedModel", # noqa: F822
+]
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__init__.py b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c79b85ae96cff49e5c38362b248925b802d8e95
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__init__.py
@@ -0,0 +1,28 @@
+# Copyright 2026 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_vibevoice_acoustic_tokenizer import *
+ from .feature_extraction_vibevoice_acoustic_tokenizer import *
+ from .modeling_vibevoice_acoustic_tokenizer import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7577a4fc4077da6853362eefdb364933ea7a06b3
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/configuration_vibevoice_acoustic_tokenizer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/configuration_vibevoice_acoustic_tokenizer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4331e0c3959ef7e0e3b4654e106bae9c6043c936
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/configuration_vibevoice_acoustic_tokenizer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/feature_extraction_vibevoice_acoustic_tokenizer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/feature_extraction_vibevoice_acoustic_tokenizer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0828aebe85e8b90013e2c46b7f9df301330e307e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/feature_extraction_vibevoice_acoustic_tokenizer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/modeling_vibevoice_acoustic_tokenizer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/modeling_vibevoice_acoustic_tokenizer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..91c896c4bfe7cf2bfb4fb29f2f20cfa17bea298d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/modeling_vibevoice_acoustic_tokenizer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/modular_vibevoice_acoustic_tokenizer.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/modular_vibevoice_acoustic_tokenizer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f34025905256f3dba7e5a66ff7aec886afadd0db
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/__pycache__/modular_vibevoice_acoustic_tokenizer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/configuration_vibevoice_acoustic_tokenizer.py b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/configuration_vibevoice_acoustic_tokenizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..68601f82dc7f2ef92c019a897358ee571403e766
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/configuration_vibevoice_acoustic_tokenizer.py
@@ -0,0 +1,162 @@
+# Copyright 2026 The HuggingFace Inc. 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 math
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="microsoft/VibeVoice-1.5B")
+@strict
+class VibeVoiceAcousticTokenizerConfig(PreTrainedConfig):
+ r"""
+ channels (`int`, *optional*, defaults to 1):
+ Number of input channels.
+ hidden_size (`int`, *optional*, defaults to 64):
+ Dimensionality of latent representations.
+ kernel_size (`int`, *optional*, defaults to 7):
+ Kernel size for convolutional layers.
+ num_filters (`int`, *optional*, defaults to 32):
+ Number of filters in initial convolutional layer, and doubles after each downsampling.
+ downsampling_ratios (`List[int]`, *optional*, defaults to `[2, 2, 4, 5, 5, 8]`):
+ Downsampling ratios for each layer.
+ depths (`List[int]`, *optional*, defaults to `[3, 3, 3, 3, 3, 3, 8]`):
+ Number of ConvNeXt blocks at each stage.
+ ffn_expansion (`int`, *optional*, defaults to 4):
+ Expansion factor for feed-forward networks.
+ vae_std (`float`, *optional*, defaults to 0.625):
+ Standard deviation used for VAE sampling after encoder.
+
+ Example:
+
+ ```python
+ >>> from transformers import VibeVoiceAcousticTokenizerModel, VibeVoiceAcousticTokenizerConfig
+
+ >>> # Initializing a VibeVoice Acoustic Tokenizer configuration
+ >>> configuration = VibeVoiceAcousticTokenizerConfig()
+
+ >>> # Initializing a model (with random weights)
+ >>> model = VibeVoiceAcousticTokenizerModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "vibevoice_acoustic_tokenizer"
+
+ channels: int = 1
+ hidden_size: int = 64
+ kernel_size: int = 7
+ rms_norm_eps: float = 1e-5
+ layer_scale_init_value: float = 1e-6
+ initializer_range: float = 1e-2
+ num_filters: int = 32
+ downsampling_ratios: list[int] | tuple[int, ...] = (2, 2, 4, 5, 5, 8)
+ depths: list[int] | tuple[int, ...] = (3, 3, 3, 3, 3, 3, 8)
+ hidden_act: str = "gelu"
+ ffn_expansion: int = 4
+ vae_std: float = 0.625
+
+ @property
+ def hop_length(self):
+ return int(math.prod(self.downsampling_ratios))
+
+ @property
+ def encoder_config(self):
+ return VibeVoiceAcousticTokenizerEncoderConfig(**self.to_dict())
+
+ @property
+ def decoder_config(self):
+ config_dict = self.to_dict()
+ config_dict["depths"] = list(reversed(config_dict["depths"]))
+ return VibeVoiceAcousticTokenizerDecoderConfig(**config_dict)
+
+
+@auto_docstring(checkpoint="microsoft/VibeVoice-1.5B")
+@strict
+class VibeVoiceAcousticTokenizerEncoderConfig(VibeVoiceAcousticTokenizerConfig):
+ r"""
+ channels (`int`, *optional*, defaults to 1):
+ Number of input channels.
+ hidden_size (`int`, *optional*, defaults to 64):
+ Dimensionality of latent representations.
+ kernel_size (`int`, *optional*, defaults to 7):
+ Kernel size for convolutional layers.
+ num_filters (`int`, *optional*, defaults to 32):
+ Number of filters in initial convolutional layer, and doubles after each downsampling.
+ downsampling_ratios (`List[int]`, *optional*, defaults to `[2, 2, 4, 5, 5, 8]`):
+ Downsampling ratios for each layer.
+ depths (`List[int]`, *optional*, defaults to `[3, 3, 3, 3, 3, 3, 8]`):
+ Number of ConvNeXt blocks at each stage.
+ ffn_expansion (`int`, *optional*, defaults to 4):
+ Expansion factor for feed-forward networks.
+ vae_std (`float`, *optional*, defaults to 0.625):
+ Standard deviation used for VAE sampling after encoder.
+ """
+
+ model_type = "vibevoice_acoustic_tokenizer_encoder"
+ base_config_key = "encoder_config"
+
+ @property
+ def encoder_config(self):
+ return None
+
+
+@auto_docstring(checkpoint="microsoft/VibeVoice-1.5B")
+@strict
+class VibeVoiceAcousticTokenizerDecoderConfig(VibeVoiceAcousticTokenizerConfig):
+ r"""
+ channels (`int`, *optional*, defaults to 1):
+ Number of input channels.
+ hidden_size (`int`, *optional*, defaults to 64):
+ Dimensionality of latent representations.
+ kernel_size (`int`, *optional*, defaults to 7):
+ Kernel size for convolutional layers.
+ num_filters (`int`, *optional*, defaults to 32):
+ Number of filters in initial convolutional layer, and doubles after each downsampling.
+ downsampling_ratios (`List[int]`, *optional*, defaults to `[2, 2, 4, 5, 5, 8]`):
+ Downsampling ratios for each layer.
+ depths (`List[int]`, *optional*, defaults to `[3, 3, 3, 3, 3, 3, 8]`):
+ Number of ConvNeXt blocks at each stage.
+ ffn_expansion (`int`, *optional*, defaults to 4):
+ Expansion factor for feed-forward networks.
+ vae_std (`float`, *optional*, defaults to 0.625):
+ Standard deviation used for VAE sampling after encoder.
+ """
+
+ model_type = "vibevoice_acoustic_tokenizer_decoder"
+ base_config_key = "decoder_config"
+
+ @property
+ def encoder_config(self):
+ return None
+
+ @property
+ def decoder_config(self):
+ return None
+
+ @property
+ def upsampling_ratios(self):
+ return list(reversed(self.downsampling_ratios))
+
+
+__all__ = [
+ "VibeVoiceAcousticTokenizerConfig",
+ "VibeVoiceAcousticTokenizerEncoderConfig",
+ "VibeVoiceAcousticTokenizerDecoderConfig",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/feature_extraction_vibevoice_acoustic_tokenizer.py b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/feature_extraction_vibevoice_acoustic_tokenizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..859dc58e5873406f584d88d88ca92fe8f4378e27
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/feature_extraction_vibevoice_acoustic_tokenizer.py
@@ -0,0 +1,151 @@
+# Copyright 2026 The HuggingFace Inc. 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 ...audio_utils import AudioInput, make_list_of_audio
+from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
+from ...feature_extraction_utils import BatchFeature
+from ...utils import PaddingStrategy, logging
+from ...utils.import_utils import is_torch_available, requires
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+@requires(backends=("torch",))
+class VibeVoiceAcousticTokenizerFeatureExtractor(SequenceFeatureExtractor):
+ r"""
+ Constructs a VibeVoiceAcousticTokenizer feature extractor.
+
+ Args:
+ feature_size (`int`, *optional*, defaults to 1):
+ The number of channels.
+ sampling_rate (`int`, *optional*, defaults to 24000):
+ The sampling rate at which the audio waveform should be digitalized, expressed in hertz (Hz).
+ padding_value (`float`, *optional*, defaults to 0.0):
+ The value that is used for padding.
+ normalize_audio (`bool`, *optional*, defaults to `True`):
+ Whether to normalize audio to a target dB FS.
+ target_dB_FS (`float`, *optional*, defaults to -25):
+ Target dB FS for normalization.
+ eps (`float`, *optional*, defaults to 1e-06):
+ A small value to avoid division by zero when normalizing.
+
+ """
+
+ model_input_names = ["input_values", "padding_mask"]
+
+ def __init__(
+ self,
+ feature_size=1,
+ sampling_rate=24000,
+ padding_value=0.0,
+ normalize_audio=True,
+ target_dB_FS=-25,
+ eps=1e-6,
+ **kwargs,
+ ):
+ super().__init__(feature_size=feature_size, sampling_rate=sampling_rate, padding_value=padding_value, **kwargs)
+
+ self.normalize_audio = normalize_audio
+ self.target_dB_FS = target_dB_FS
+ self.eps = eps
+
+ def __call__(
+ self,
+ audio: AudioInput,
+ sampling_rate: int | None = None,
+ padding: bool | str | PaddingStrategy | None = True,
+ pad_to_multiple_of: int | None = None,
+ max_length: int | None = None,
+ return_attention_mask: bool | None = True,
+ return_tensors: str | None = "pt",
+ **kwargs,
+ ) -> BatchFeature:
+ """
+ Args:
+ audio (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`:
+ The sequence or batch of sequences to be processed. Each sequence can be a numpy array, a torch tensor,
+ a list of numpy arrays or a list of torch tensors.
+ sampling_rate (`int`, *optional*):
+ The sampling rate at which the `audio` input was sampled. It is strongly recommended to pass
+ `sampling_rate` at the forward call to prevent silent errors.
+ padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `True`):
+ Select a strategy to pad the returned sequences (according to the model's padding side and padding
+ index) among:
+
+ - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+ sequence if provided).
+ - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
+ acceptable input length for the model if that argument is not provided.
+ - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
+ lengths).
+ pad_to_multiple_of (`int`, *optional*):
+ If set will pad the sequence to a multiple of the provided value.
+
+ """
+ if sampling_rate is not None:
+ if sampling_rate != self.sampling_rate:
+ raise ValueError(
+ f"The model corresponding to this feature extractor: {self} was trained using a sampling rate of"
+ f" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"
+ f" {self.sampling_rate} and not {sampling_rate}."
+ )
+ else:
+ logger.warning(
+ f"It is strongly recommended to pass the `sampling_rate` argument to `{self.__class__.__name__}()`. "
+ "Failing to do so can result in silent errors that might be hard to debug."
+ )
+
+ if return_tensors != "pt":
+ raise ValueError(f"{self.__class__.__name__} only supports `return_tensors='pt'`.")
+
+ # Ensure batch of mono tensors
+ audio = make_list_of_audio(audio)
+ for idx, example in enumerate(audio):
+ example = torch.tensor(example, dtype=torch.float32)
+ if example.ndim != 1:
+ raise ValueError(f"Audio should be mono, got shape: {example.shape}")
+ audio[idx] = example
+
+ if self.normalize_audio:
+ for idx, example in enumerate(audio):
+ rms = torch.sqrt(torch.mean(example**2))
+ example *= 10 ** (self.target_dB_FS / 20) / (rms + self.eps)
+ max_val = torch.max(torch.abs(example))
+ if max_val > 1.0:
+ example = example / (max_val + self.eps)
+ audio[idx] = example
+
+ output_values = BatchFeature({"input_values": audio})
+ if padding or pad_to_multiple_of:
+ output_values = self.pad(
+ output_values,
+ padding=padding,
+ pad_to_multiple_of=pad_to_multiple_of,
+ return_attention_mask=return_attention_mask,
+ max_length=max_length,
+ )
+ if return_attention_mask:
+ output_values["padding_mask"] = output_values.pop("attention_mask")
+
+ # add channel dimension
+ output_values["input_values"] = output_values["input_values"][:, None, :]
+
+ return output_values
+
+
+__all__ = ["VibeVoiceAcousticTokenizerFeatureExtractor"]
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3b8376bed6175c578bd141e2d4a737ad0b969ab
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py
@@ -0,0 +1,577 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/vibevoice_acoustic_tokenizer/modular_vibevoice_acoustic_tokenizer.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_vibevoice_acoustic_tokenizer.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The HuggingFace Inc. 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 dataclasses import dataclass
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...integrations import use_kernel_forward_from_hub
+from ...modeling_utils import PreTrainedModel
+from ...utils import ModelOutput, auto_docstring, can_return_tuple, is_torchdynamo_compiling
+from ..auto.modeling_auto import AutoModel
+from .configuration_vibevoice_acoustic_tokenizer import (
+ VibeVoiceAcousticTokenizerConfig,
+ VibeVoiceAcousticTokenizerDecoderConfig,
+ VibeVoiceAcousticTokenizerEncoderConfig,
+)
+
+
+@auto_docstring
+@dataclass
+class VibeVoiceAcousticTokenizerOutput(ModelOutput):
+ r"""
+ audio (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Decoded audio.
+ latents (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Projected latents (continuous representations for acoustic tokens) at the output of the encoder.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*, returned when `use_cache=True` is passed):
+ A [`VibeVoiceAcousticTokenizerConv1dPaddingCache`] instance containing cached convolution states for each decoder
+ layer that can be passed to subsequent forward calls.
+ """
+
+ audio: torch.FloatTensor | None = None
+ latents: torch.FloatTensor | None = None
+ padding_cache: Optional["VibeVoiceAcousticTokenizerConv1dPaddingCache"] = None
+
+
+@auto_docstring
+@dataclass
+class VibeVoiceAcousticTokenizerEncoderOutput(ModelOutput):
+ r"""
+ latents (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Projected latents (continuous representations for acoustic tokens) at the output of the encoder.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*, returned when `use_cache=True` is passed):
+ A [`VibeVoiceAcousticTokenizerConv1dPaddingCache`] instance containing cached convolution states for each encoder
+ layer that can be passed to subsequent forward calls.
+ """
+
+ latents: torch.FloatTensor | None = None
+ padding_cache: Optional["VibeVoiceAcousticTokenizerConv1dPaddingCache"] = None
+
+
+@auto_docstring
+@dataclass
+class VibeVoiceAcousticTokenizerDecoderOutput(ModelOutput):
+ r"""
+ audio (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Decoded audio.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*, returned when `use_cache=True` is passed):
+ A [`VibeVoiceAcousticTokenizerConv1dPaddingCache`] instance containing cached convolution states for each decoder
+ layer that can be passed to subsequent forward calls.
+ """
+
+ audio: torch.FloatTensor | None = None
+ padding_cache: Optional["VibeVoiceAcousticTokenizerConv1dPaddingCache"] = None
+
+
+@use_kernel_forward_from_hub("RMSNorm")
+class VibeVoiceAcousticTokenizerRMSNorm(nn.Module):
+ def __init__(self, hidden_size, eps: float = 1e-6) -> None:
+ """
+ VibeVoiceAcousticTokenizerRMSNorm is equivalent to T5LayerNorm
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ input_dtype = hidden_states.dtype
+ hidden_states = hidden_states.to(torch.float32)
+ variance = hidden_states.pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+ return self.weight * hidden_states.to(input_dtype)
+
+ def extra_repr(self):
+ return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"
+
+
+class VibeVoiceAcousticTokenizerFeedForward(nn.Module):
+ def __init__(self, config, hidden_size):
+ super().__init__()
+ self.linear1 = nn.Linear(hidden_size, config.ffn_expansion * hidden_size)
+ self.activation = ACT2FN[config.hidden_act]
+ self.linear2 = nn.Linear(config.ffn_expansion * hidden_size, hidden_size)
+
+ def forward(self, hidden_states):
+ return self.linear2(self.activation(self.linear1(hidden_states)))
+
+
+class VibeVoiceAcousticTokenizerConv1dCacheLayer:
+ def __init__(self):
+ self.cache: torch.Tensor | None = None
+ self.is_initialized: bool = False
+
+ def lazy_initialization(self, hidden_states, conv_module):
+ self.left_pad = conv_module.left_pad
+ self.in_channels = conv_module.in_channels
+ self.cache = torch.zeros(
+ hidden_states.shape[0],
+ self.in_channels,
+ self.left_pad,
+ device=hidden_states.device,
+ dtype=hidden_states.dtype,
+ )
+
+ if not is_torchdynamo_compiling():
+ torch._dynamo.mark_static_address(self.cache)
+
+ self.is_initialized = True
+
+ def update(self, hidden_states, conv_module=None):
+ if not self.is_initialized and conv_module is not None:
+ self.lazy_initialization(hidden_states, conv_module)
+ elif not self.is_initialized:
+ raise ValueError(
+ "VibeVoiceAcousticTokenizerConv1dCacheLayer is not initialized. Make sure to provide conv_module to the update method."
+ )
+
+ # get the padding states
+ if self.left_pad > 0:
+ shortfall = max(0, self.left_pad - hidden_states.shape[-1])
+ if shortfall > 0:
+ padding_states = torch.cat([self.cache[:, :, -shortfall:], hidden_states], dim=-1)
+ else:
+ padding_states = hidden_states[:, :, -self.left_pad :]
+ else:
+ padding_states = torch.empty(
+ hidden_states.shape[0], self.in_channels, 0, dtype=hidden_states.dtype, device=hidden_states.device
+ )
+
+ current_cache = self.cache.clone()
+ self.cache.copy_(padding_states)
+
+ return current_cache
+
+
+class VibeVoiceAcousticTokenizerConv1dPaddingCache:
+ def __init__(self):
+ self.layers = {}
+
+ def update(self, hidden_states, cache_key, conv_module):
+ if cache_key not in self.layers:
+ self.layers[cache_key] = VibeVoiceAcousticTokenizerConv1dCacheLayer()
+
+ padding_states = self.layers[cache_key].update(hidden_states, conv_module)
+ padded_hidden_states = torch.cat([padding_states, hidden_states], dim=-1)
+ return padded_hidden_states
+
+
+# TODO: @eustlb, @ebezzam this should be latter factorized with other causalconv1d (e.g. VoxtralRealtimeCausalConv1d)
+class VibeVoiceAcousticTokenizerCausalConv1d(nn.Module):
+ """Conv1d with built-in causal padding and optional streaming support through a cache."""
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ cache_key: str,
+ stride: int = 1,
+ dilation: int = 1,
+ groups: int = 1,
+ ):
+ super().__init__()
+ self.conv = nn.Conv1d(in_channels, out_channels, kernel_size, stride, dilation=dilation, groups=groups)
+ self.causal_padding = (kernel_size - 1) * dilation - (stride - 1)
+ if self.causal_padding < 0:
+ raise ValueError(
+ f"Invalid causal padding {self.causal_padding} for kernel_size={kernel_size}, "
+ f"dilation={dilation}, stride={stride}."
+ )
+ self.cache_key = cache_key
+ self.in_channels = in_channels
+ self.left_pad = self.causal_padding
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ padding_cache: VibeVoiceAcousticTokenizerConv1dPaddingCache | None = None,
+ ) -> torch.Tensor:
+ if padding_cache is not None:
+ hidden_states = padding_cache.update(hidden_states, self.cache_key, self)
+ else:
+ hidden_states = nn.functional.pad(hidden_states, (self.left_pad, 0))
+
+ return self.conv(hidden_states)
+
+
+class VibeVoiceAcousticTokenizerCausalConvTranspose1d(nn.Module):
+ """ConvTranspose1d with built-in causal padding and optional streaming support through a cache."""
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ cache_key: str,
+ stride: int = 1,
+ ):
+ super().__init__()
+ self.convtr = nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride)
+
+ self.stride = stride
+ self.cache_key = cache_key
+ self.in_channels = in_channels
+ self.padding_total = kernel_size - stride
+ self.causal_padding = kernel_size - 1
+ self.left_pad = self.causal_padding
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ padding_cache: Optional["VibeVoiceAcousticTokenizerConv1dPaddingCache"] = None,
+ ) -> torch.Tensor:
+ time_dim = hidden_states.shape[-1]
+
+ if padding_cache is not None:
+ hidden_states = padding_cache.update(hidden_states, self.cache_key, self)
+ hidden_states = self.convtr(hidden_states)
+
+ # Remove extra padding at the right side
+ if self.padding_total > 0:
+ hidden_states = hidden_states[..., : -self.padding_total]
+
+ if padding_cache is not None:
+ # For first chunk return full output, for subsequent chunks return only new output
+ expected_new_output = time_dim * self.stride
+ if hidden_states.shape[2] >= expected_new_output:
+ hidden_states = hidden_states[:, :, -expected_new_output:]
+ return hidden_states
+
+
+class VibeVoiceAcousticTokenizerConvNext1dLayer(nn.Module):
+ """ConvNeXt-like block adapted for 1D convolutions."""
+
+ def __init__(self, config, hidden_size, dilation=1, stride=1, layer_idx=None):
+ super().__init__()
+
+ self.norm = VibeVoiceAcousticTokenizerRMSNorm(hidden_size, eps=config.rms_norm_eps)
+ self.ffn_norm = VibeVoiceAcousticTokenizerRMSNorm(hidden_size, eps=config.rms_norm_eps)
+ self.ffn = VibeVoiceAcousticTokenizerFeedForward(config, hidden_size)
+ self.gamma = nn.Parameter(config.layer_scale_init_value * torch.ones(hidden_size), requires_grad=True)
+ self.ffn_gamma = nn.Parameter(config.layer_scale_init_value * torch.ones(hidden_size), requires_grad=True)
+ self.mixer = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=hidden_size,
+ out_channels=hidden_size,
+ kernel_size=config.kernel_size,
+ cache_key=f"convnext_layer_{layer_idx}",
+ groups=hidden_size,
+ dilation=dilation,
+ stride=stride,
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ # mixer
+ residual = hidden_states
+ hidden_states = self.norm(hidden_states.transpose(1, 2)).transpose(1, 2)
+ hidden_states = self.mixer(hidden_states, padding_cache=padding_cache)
+ hidden_states = hidden_states * self.gamma.unsqueeze(-1)
+ hidden_states = residual + hidden_states
+
+ # ffn
+ residual = hidden_states
+ hidden_states = self.ffn_norm(hidden_states.transpose(1, 2))
+ hidden_states = self.ffn(hidden_states).transpose(1, 2)
+ hidden_states = hidden_states * self.ffn_gamma.unsqueeze(-1)
+ return residual + hidden_states
+
+
+class VibeVoiceAcousticTokenizerEncoderStem(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+
+ self.conv = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=config.channels,
+ out_channels=config.num_filters,
+ kernel_size=config.kernel_size,
+ cache_key="encoder_stem",
+ )
+ self.stage = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerConvNext1dLayer(
+ config,
+ hidden_size=config.num_filters,
+ layer_idx=layer_idx,
+ )
+ for layer_idx in range(1, config.depths[0] + 1)
+ ]
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ hidden_states = self.conv(hidden_states, padding_cache=padding_cache)
+ for block in self.stage:
+ hidden_states = block(hidden_states, padding_cache=padding_cache)
+ return hidden_states
+
+
+class VibeVoiceAcousticTokenizerEncoderLayer(nn.Module):
+ def __init__(self, config, stage_idx):
+ super().__init__()
+
+ depth_idx = stage_idx + 1 # first depth is for stem layer
+ layer_idx = sum(depth + 1 for depth in config.depths[:depth_idx])
+ intermediate_channels = int(config.num_filters * (2 ** (depth_idx)))
+
+ self.conv = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=int(config.num_filters * (2**stage_idx)),
+ out_channels=intermediate_channels,
+ kernel_size=int(config.downsampling_ratios[stage_idx] * 2),
+ cache_key=f"encoder_layer_{stage_idx}",
+ stride=config.downsampling_ratios[stage_idx],
+ )
+ self.stage = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerConvNext1dLayer(
+ config, hidden_size=intermediate_channels, layer_idx=layer_idx + offset
+ )
+ for offset in range(1, config.depths[depth_idx] + 1)
+ ]
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ hidden_states = self.conv(hidden_states, padding_cache=padding_cache)
+ for block in self.stage:
+ hidden_states = block(hidden_states, padding_cache=padding_cache)
+ return hidden_states
+
+
+@auto_docstring
+class VibeVoiceAcousticTokenizerPreTrainedModel(PreTrainedModel):
+ config: VibeVoiceAcousticTokenizerConfig
+ base_model_prefix = "vibevoice_acoustic_tokenizer"
+ main_input_name = "input_values"
+ _no_split_modules = ["VibeVoiceAcousticTokenizerEncoderModel", "VibeVoiceAcousticTokenizerDecoderModel"]
+
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, VibeVoiceAcousticTokenizerConvNext1dLayer):
+ init.constant_(module.gamma, self.config.layer_scale_init_value)
+ init.constant_(module.ffn_gamma, self.config.layer_scale_init_value)
+
+
+class VibeVoiceAcousticTokenizerEncoderModel(VibeVoiceAcousticTokenizerPreTrainedModel):
+ config: VibeVoiceAcousticTokenizerEncoderConfig
+
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.stem = VibeVoiceAcousticTokenizerEncoderStem(config)
+ self.conv_layers = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerEncoderLayer(config, stage_idx)
+ for stage_idx in range(len(config.downsampling_ratios))
+ ]
+ )
+ self.head = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=int(config.num_filters * (2 ** len(config.downsampling_ratios))),
+ out_channels=config.hidden_size,
+ kernel_size=config.kernel_size,
+ cache_key="encoder_head",
+ )
+ self.post_init()
+
+ def forward(self, hidden_states, padding_cache=None, use_cache=False, **kwargs):
+ if use_cache and padding_cache is None:
+ padding_cache = VibeVoiceAcousticTokenizerConv1dPaddingCache()
+
+ hidden_states = self.stem(hidden_states, padding_cache=padding_cache)
+ for layer in self.conv_layers:
+ hidden_states = layer(hidden_states, padding_cache=padding_cache)
+ hidden_states = self.head(hidden_states, padding_cache=padding_cache)
+ latents = hidden_states.permute(0, 2, 1)
+ return VibeVoiceAcousticTokenizerEncoderOutput(latents=latents, padding_cache=padding_cache)
+
+
+class VibeVoiceAcousticTokenizerDecoderStem(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+
+ intermediate_channels = int(config.num_filters * 2 ** (len(config.depths) - 1))
+ self.conv = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=config.hidden_size,
+ out_channels=intermediate_channels,
+ kernel_size=config.kernel_size,
+ cache_key="decoder_stem",
+ )
+ self.stage = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerConvNext1dLayer(
+ config,
+ hidden_size=intermediate_channels,
+ layer_idx=layer_idx,
+ )
+ for layer_idx in range(1, config.depths[0] + 1)
+ ]
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ hidden_states = self.conv(hidden_states, padding_cache=padding_cache)
+ for block in self.stage:
+ hidden_states = block(hidden_states, padding_cache=padding_cache)
+ return hidden_states
+
+
+class VibeVoiceAcousticTokenizerDecoderLayer(nn.Module):
+ def __init__(self, config, stage_idx):
+ super().__init__()
+
+ depth_idx = stage_idx + 1 # first depth is for stem layer
+ layer_idx = sum(depth + 1 for depth in config.depths[:depth_idx])
+ intermediate_channels = int(config.num_filters * (2 ** (len(config.depths) - 2 - stage_idx)))
+
+ self.convtr = VibeVoiceAcousticTokenizerCausalConvTranspose1d(
+ in_channels=int(config.num_filters * (2 ** (len(config.depths) - 1 - stage_idx))),
+ out_channels=intermediate_channels,
+ kernel_size=int(config.upsampling_ratios[stage_idx] * 2),
+ cache_key=f"decoder_layer_{stage_idx}",
+ stride=config.upsampling_ratios[stage_idx],
+ )
+ self.stage = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerConvNext1dLayer(
+ config, hidden_size=intermediate_channels, layer_idx=layer_idx + offset
+ )
+ for offset in range(1, config.depths[depth_idx] + 1)
+ ]
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ hidden_states = self.convtr(hidden_states, padding_cache=padding_cache)
+ for block in self.stage:
+ hidden_states = block(hidden_states, padding_cache=padding_cache)
+ return hidden_states
+
+
+class VibeVoiceAcousticTokenizerDecoderModel(VibeVoiceAcousticTokenizerPreTrainedModel):
+ config: VibeVoiceAcousticTokenizerDecoderConfig
+
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.stem = VibeVoiceAcousticTokenizerDecoderStem(config)
+ self.conv_layers = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerDecoderLayer(config, stage_idx)
+ for stage_idx in range(len(config.upsampling_ratios))
+ ]
+ )
+ self.head = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=config.num_filters,
+ out_channels=config.channels,
+ kernel_size=config.kernel_size,
+ cache_key="decoder_head",
+ )
+ self.post_init()
+
+ def forward(self, hidden_states, padding_cache=None, use_cache=False, **kwargs):
+ if use_cache and padding_cache is None:
+ padding_cache = VibeVoiceAcousticTokenizerConv1dPaddingCache()
+
+ hidden_states = self.stem(hidden_states, padding_cache=padding_cache)
+ for layer in self.conv_layers:
+ hidden_states = layer(hidden_states, padding_cache=padding_cache)
+ hidden_states = self.head(hidden_states, padding_cache=padding_cache)
+ return VibeVoiceAcousticTokenizerDecoderOutput(audio=hidden_states, padding_cache=padding_cache)
+
+
+@auto_docstring(
+ custom_intro="""
+ VibeVoice acoustic tokenizer with an encoder and decoder for continuous acoustic tokens.
+ """
+)
+class VibeVoiceAcousticTokenizerModel(VibeVoiceAcousticTokenizerPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.encoder = AutoModel.from_config(config.encoder_config)
+ self.decoder = AutoModel.from_config(config.decoder_config)
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def encode(self, input_values, padding_cache=None, use_cache=None, sample=True):
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Input audio waveform to be encoded into latent representation.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*):
+ Cache object for streaming mode to maintain convolution states across layers.
+ use_cache (`bool`, *optional*):
+ Whether to use caching for convolution states.
+ sample (`bool`, *optional*):
+ Whether to sample from the VAE. If False, no noise is added.
+ """
+ encoder_output = self.encoder(input_values, padding_cache=padding_cache, use_cache=use_cache)
+
+ if sample:
+ noise_std = self.config.vae_std * torch.randn(
+ encoder_output.latents.shape[0],
+ device=encoder_output.latents.device,
+ dtype=encoder_output.latents.dtype,
+ )
+ encoder_output.latents = encoder_output.latents + noise_std[:, None, None] * torch.randn_like(
+ encoder_output.latents
+ )
+ return encoder_output
+
+ @can_return_tuple
+ @auto_docstring
+ def decode(self, latents, padding_cache=None, use_cache=False):
+ r"""
+ latents (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Input latent representation to be decoded back into audio.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*):
+ Cache object for streaming mode to maintain convolution states across layers.
+ use_cache (`bool`, *optional*):
+ Whether to use caching for convolution states.
+ """
+ latents = latents.permute(0, 2, 1)
+ return self.decoder(latents, padding_cache=padding_cache, use_cache=use_cache)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(self, input_values, padding_cache=None, use_cache=False, sample=True, **kwargs):
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Input audio waveform to be encoded into latent representation.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*):
+ Cache object for streaming mode to maintain convolution states across layers. Note only used by decoder.
+ use_cache (`bool`, *optional*):
+ Whether to use caching for convolution states.
+ sample (`bool`, *optional*):
+ Whether to sample from the VAE latent distribution. If False, no noise is added to the latents.
+ """
+ encoder_output = self.encode(input_values, use_cache=use_cache, sample=sample)
+ decoder_output = self.decode(encoder_output.latents, padding_cache=padding_cache, use_cache=use_cache)
+ return VibeVoiceAcousticTokenizerOutput(
+ audio=decoder_output.audio,
+ latents=encoder_output.latents,
+ padding_cache=decoder_output.padding_cache,
+ )
+
+
+__all__ = [
+ "VibeVoiceAcousticTokenizerModel",
+ "VibeVoiceAcousticTokenizerEncoderModel",
+ "VibeVoiceAcousticTokenizerDecoderModel",
+ "VibeVoiceAcousticTokenizerPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/modular_vibevoice_acoustic_tokenizer.py b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/modular_vibevoice_acoustic_tokenizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ceeacd269de421d4e377d66f292d88e5368af71
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_acoustic_tokenizer/modular_vibevoice_acoustic_tokenizer.py
@@ -0,0 +1,499 @@
+# Copyright 2026 The HuggingFace Inc. 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 dataclasses import dataclass
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...modeling_utils import PreTrainedModel
+from ...utils import ModelOutput, auto_docstring, can_return_tuple
+from ..auto.modeling_auto import AutoModel
+from ..llama.modeling_llama import LlamaRMSNorm
+from ..voxtral_realtime.modeling_voxtral_realtime import VoxtralRealtimeConv1dPaddingCache
+from .configuration_vibevoice_acoustic_tokenizer import (
+ VibeVoiceAcousticTokenizerConfig,
+ VibeVoiceAcousticTokenizerDecoderConfig,
+ VibeVoiceAcousticTokenizerEncoderConfig,
+)
+
+
+@auto_docstring
+@dataclass
+class VibeVoiceAcousticTokenizerOutput(ModelOutput):
+ r"""
+ audio (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Decoded audio.
+ latents (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Projected latents (continuous representations for acoustic tokens) at the output of the encoder.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*, returned when `use_cache=True` is passed):
+ A [`VibeVoiceAcousticTokenizerConv1dPaddingCache`] instance containing cached convolution states for each decoder
+ layer that can be passed to subsequent forward calls.
+ """
+
+ audio: torch.FloatTensor | None = None
+ latents: torch.FloatTensor | None = None
+ padding_cache: Optional["VibeVoiceAcousticTokenizerConv1dPaddingCache"] = None
+
+
+@auto_docstring
+@dataclass
+class VibeVoiceAcousticTokenizerEncoderOutput(ModelOutput):
+ r"""
+ latents (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+ Projected latents (continuous representations for acoustic tokens) at the output of the encoder.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*, returned when `use_cache=True` is passed):
+ A [`VibeVoiceAcousticTokenizerConv1dPaddingCache`] instance containing cached convolution states for each encoder
+ layer that can be passed to subsequent forward calls.
+ """
+
+ latents: torch.FloatTensor | None = None
+ padding_cache: Optional["VibeVoiceAcousticTokenizerConv1dPaddingCache"] = None
+
+
+@auto_docstring
+@dataclass
+class VibeVoiceAcousticTokenizerDecoderOutput(ModelOutput):
+ r"""
+ audio (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Decoded audio.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*, returned when `use_cache=True` is passed):
+ A [`VibeVoiceAcousticTokenizerConv1dPaddingCache`] instance containing cached convolution states for each decoder
+ layer that can be passed to subsequent forward calls.
+ """
+
+ audio: torch.FloatTensor | None = None
+ padding_cache: Optional["VibeVoiceAcousticTokenizerConv1dPaddingCache"] = None
+
+
+class VibeVoiceAcousticTokenizerRMSNorm(LlamaRMSNorm):
+ pass
+
+
+class VibeVoiceAcousticTokenizerFeedForward(nn.Module):
+ def __init__(self, config, hidden_size):
+ super().__init__()
+ self.linear1 = nn.Linear(hidden_size, config.ffn_expansion * hidden_size)
+ self.activation = ACT2FN[config.hidden_act]
+ self.linear2 = nn.Linear(config.ffn_expansion * hidden_size, hidden_size)
+
+ def forward(self, hidden_states):
+ return self.linear2(self.activation(self.linear1(hidden_states)))
+
+
+class VibeVoiceAcousticTokenizerConv1dPaddingCache(VoxtralRealtimeConv1dPaddingCache):
+ pass
+
+
+# TODO: @eustlb, @ebezzam this should be latter factorized with other causalconv1d (e.g. VoxtralRealtimeCausalConv1d)
+class VibeVoiceAcousticTokenizerCausalConv1d(nn.Module):
+ """Conv1d with built-in causal padding and optional streaming support through a cache."""
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ cache_key: str,
+ stride: int = 1,
+ dilation: int = 1,
+ groups: int = 1,
+ ):
+ super().__init__()
+ self.conv = nn.Conv1d(in_channels, out_channels, kernel_size, stride, dilation=dilation, groups=groups)
+ self.causal_padding = (kernel_size - 1) * dilation - (stride - 1)
+ if self.causal_padding < 0:
+ raise ValueError(
+ f"Invalid causal padding {self.causal_padding} for kernel_size={kernel_size}, "
+ f"dilation={dilation}, stride={stride}."
+ )
+ self.cache_key = cache_key
+ self.in_channels = in_channels
+ self.left_pad = self.causal_padding
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ padding_cache: VibeVoiceAcousticTokenizerConv1dPaddingCache | None = None,
+ ) -> torch.Tensor:
+ if padding_cache is not None:
+ hidden_states = padding_cache.update(hidden_states, self.cache_key, self)
+ else:
+ hidden_states = nn.functional.pad(hidden_states, (self.left_pad, 0))
+
+ return self.conv(hidden_states)
+
+
+class VibeVoiceAcousticTokenizerCausalConvTranspose1d(nn.Module):
+ """ConvTranspose1d with built-in causal padding and optional streaming support through a cache."""
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ cache_key: str,
+ stride: int = 1,
+ ):
+ super().__init__()
+ self.convtr = nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride)
+
+ self.stride = stride
+ self.cache_key = cache_key
+ self.in_channels = in_channels
+ self.padding_total = kernel_size - stride
+ self.causal_padding = kernel_size - 1
+ self.left_pad = self.causal_padding
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ padding_cache: Optional["VibeVoiceAcousticTokenizerConv1dPaddingCache"] = None,
+ ) -> torch.Tensor:
+ time_dim = hidden_states.shape[-1]
+
+ if padding_cache is not None:
+ hidden_states = padding_cache.update(hidden_states, self.cache_key, self)
+ hidden_states = self.convtr(hidden_states)
+
+ # Remove extra padding at the right side
+ if self.padding_total > 0:
+ hidden_states = hidden_states[..., : -self.padding_total]
+
+ if padding_cache is not None:
+ # For first chunk return full output, for subsequent chunks return only new output
+ expected_new_output = time_dim * self.stride
+ if hidden_states.shape[2] >= expected_new_output:
+ hidden_states = hidden_states[:, :, -expected_new_output:]
+ return hidden_states
+
+
+class VibeVoiceAcousticTokenizerConvNext1dLayer(nn.Module):
+ """ConvNeXt-like block adapted for 1D convolutions."""
+
+ def __init__(self, config, hidden_size, dilation=1, stride=1, layer_idx=None):
+ super().__init__()
+
+ self.norm = VibeVoiceAcousticTokenizerRMSNorm(hidden_size, eps=config.rms_norm_eps)
+ self.ffn_norm = VibeVoiceAcousticTokenizerRMSNorm(hidden_size, eps=config.rms_norm_eps)
+ self.ffn = VibeVoiceAcousticTokenizerFeedForward(config, hidden_size)
+ self.gamma = nn.Parameter(config.layer_scale_init_value * torch.ones(hidden_size), requires_grad=True)
+ self.ffn_gamma = nn.Parameter(config.layer_scale_init_value * torch.ones(hidden_size), requires_grad=True)
+ self.mixer = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=hidden_size,
+ out_channels=hidden_size,
+ kernel_size=config.kernel_size,
+ cache_key=f"convnext_layer_{layer_idx}",
+ groups=hidden_size,
+ dilation=dilation,
+ stride=stride,
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ # mixer
+ residual = hidden_states
+ hidden_states = self.norm(hidden_states.transpose(1, 2)).transpose(1, 2)
+ hidden_states = self.mixer(hidden_states, padding_cache=padding_cache)
+ hidden_states = hidden_states * self.gamma.unsqueeze(-1)
+ hidden_states = residual + hidden_states
+
+ # ffn
+ residual = hidden_states
+ hidden_states = self.ffn_norm(hidden_states.transpose(1, 2))
+ hidden_states = self.ffn(hidden_states).transpose(1, 2)
+ hidden_states = hidden_states * self.ffn_gamma.unsqueeze(-1)
+ return residual + hidden_states
+
+
+class VibeVoiceAcousticTokenizerEncoderStem(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+
+ self.conv = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=config.channels,
+ out_channels=config.num_filters,
+ kernel_size=config.kernel_size,
+ cache_key="encoder_stem",
+ )
+ self.stage = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerConvNext1dLayer(
+ config,
+ hidden_size=config.num_filters,
+ layer_idx=layer_idx,
+ )
+ for layer_idx in range(1, config.depths[0] + 1)
+ ]
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ hidden_states = self.conv(hidden_states, padding_cache=padding_cache)
+ for block in self.stage:
+ hidden_states = block(hidden_states, padding_cache=padding_cache)
+ return hidden_states
+
+
+class VibeVoiceAcousticTokenizerEncoderLayer(nn.Module):
+ def __init__(self, config, stage_idx):
+ super().__init__()
+
+ depth_idx = stage_idx + 1 # first depth is for stem layer
+ layer_idx = sum(depth + 1 for depth in config.depths[:depth_idx])
+ intermediate_channels = int(config.num_filters * (2 ** (depth_idx)))
+
+ self.conv = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=int(config.num_filters * (2**stage_idx)),
+ out_channels=intermediate_channels,
+ kernel_size=int(config.downsampling_ratios[stage_idx] * 2),
+ cache_key=f"encoder_layer_{stage_idx}",
+ stride=config.downsampling_ratios[stage_idx],
+ )
+ self.stage = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerConvNext1dLayer(
+ config, hidden_size=intermediate_channels, layer_idx=layer_idx + offset
+ )
+ for offset in range(1, config.depths[depth_idx] + 1)
+ ]
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ hidden_states = self.conv(hidden_states, padding_cache=padding_cache)
+ for block in self.stage:
+ hidden_states = block(hidden_states, padding_cache=padding_cache)
+ return hidden_states
+
+
+@auto_docstring
+class VibeVoiceAcousticTokenizerPreTrainedModel(PreTrainedModel):
+ config: VibeVoiceAcousticTokenizerConfig
+ base_model_prefix = "vibevoice_acoustic_tokenizer"
+ main_input_name = "input_values"
+ _no_split_modules = ["VibeVoiceAcousticTokenizerEncoderModel", "VibeVoiceAcousticTokenizerDecoderModel"]
+
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, VibeVoiceAcousticTokenizerConvNext1dLayer):
+ init.constant_(module.gamma, self.config.layer_scale_init_value)
+ init.constant_(module.ffn_gamma, self.config.layer_scale_init_value)
+
+
+class VibeVoiceAcousticTokenizerEncoderModel(VibeVoiceAcousticTokenizerPreTrainedModel):
+ config: VibeVoiceAcousticTokenizerEncoderConfig
+
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.stem = VibeVoiceAcousticTokenizerEncoderStem(config)
+ self.conv_layers = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerEncoderLayer(config, stage_idx)
+ for stage_idx in range(len(config.downsampling_ratios))
+ ]
+ )
+ self.head = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=int(config.num_filters * (2 ** len(config.downsampling_ratios))),
+ out_channels=config.hidden_size,
+ kernel_size=config.kernel_size,
+ cache_key="encoder_head",
+ )
+ self.post_init()
+
+ def forward(self, hidden_states, padding_cache=None, use_cache=False, **kwargs):
+ if use_cache and padding_cache is None:
+ padding_cache = VibeVoiceAcousticTokenizerConv1dPaddingCache()
+
+ hidden_states = self.stem(hidden_states, padding_cache=padding_cache)
+ for layer in self.conv_layers:
+ hidden_states = layer(hidden_states, padding_cache=padding_cache)
+ hidden_states = self.head(hidden_states, padding_cache=padding_cache)
+ latents = hidden_states.permute(0, 2, 1)
+ return VibeVoiceAcousticTokenizerEncoderOutput(latents=latents, padding_cache=padding_cache)
+
+
+class VibeVoiceAcousticTokenizerDecoderStem(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+
+ intermediate_channels = int(config.num_filters * 2 ** (len(config.depths) - 1))
+ self.conv = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=config.hidden_size,
+ out_channels=intermediate_channels,
+ kernel_size=config.kernel_size,
+ cache_key="decoder_stem",
+ )
+ self.stage = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerConvNext1dLayer(
+ config,
+ hidden_size=intermediate_channels,
+ layer_idx=layer_idx,
+ )
+ for layer_idx in range(1, config.depths[0] + 1)
+ ]
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ hidden_states = self.conv(hidden_states, padding_cache=padding_cache)
+ for block in self.stage:
+ hidden_states = block(hidden_states, padding_cache=padding_cache)
+ return hidden_states
+
+
+class VibeVoiceAcousticTokenizerDecoderLayer(nn.Module):
+ def __init__(self, config, stage_idx):
+ super().__init__()
+
+ depth_idx = stage_idx + 1 # first depth is for stem layer
+ layer_idx = sum(depth + 1 for depth in config.depths[:depth_idx])
+ intermediate_channels = int(config.num_filters * (2 ** (len(config.depths) - 2 - stage_idx)))
+
+ self.convtr = VibeVoiceAcousticTokenizerCausalConvTranspose1d(
+ in_channels=int(config.num_filters * (2 ** (len(config.depths) - 1 - stage_idx))),
+ out_channels=intermediate_channels,
+ kernel_size=int(config.upsampling_ratios[stage_idx] * 2),
+ cache_key=f"decoder_layer_{stage_idx}",
+ stride=config.upsampling_ratios[stage_idx],
+ )
+ self.stage = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerConvNext1dLayer(
+ config, hidden_size=intermediate_channels, layer_idx=layer_idx + offset
+ )
+ for offset in range(1, config.depths[depth_idx] + 1)
+ ]
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ hidden_states = self.convtr(hidden_states, padding_cache=padding_cache)
+ for block in self.stage:
+ hidden_states = block(hidden_states, padding_cache=padding_cache)
+ return hidden_states
+
+
+class VibeVoiceAcousticTokenizerDecoderModel(VibeVoiceAcousticTokenizerPreTrainedModel):
+ config: VibeVoiceAcousticTokenizerDecoderConfig
+
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.stem = VibeVoiceAcousticTokenizerDecoderStem(config)
+ self.conv_layers = nn.ModuleList(
+ [
+ VibeVoiceAcousticTokenizerDecoderLayer(config, stage_idx)
+ for stage_idx in range(len(config.upsampling_ratios))
+ ]
+ )
+ self.head = VibeVoiceAcousticTokenizerCausalConv1d(
+ in_channels=config.num_filters,
+ out_channels=config.channels,
+ kernel_size=config.kernel_size,
+ cache_key="decoder_head",
+ )
+ self.post_init()
+
+ def forward(self, hidden_states, padding_cache=None, use_cache=False, **kwargs):
+ if use_cache and padding_cache is None:
+ padding_cache = VibeVoiceAcousticTokenizerConv1dPaddingCache()
+
+ hidden_states = self.stem(hidden_states, padding_cache=padding_cache)
+ for layer in self.conv_layers:
+ hidden_states = layer(hidden_states, padding_cache=padding_cache)
+ hidden_states = self.head(hidden_states, padding_cache=padding_cache)
+ return VibeVoiceAcousticTokenizerDecoderOutput(audio=hidden_states, padding_cache=padding_cache)
+
+
+@auto_docstring(
+ custom_intro="""
+ VibeVoice acoustic tokenizer with an encoder and decoder for continuous acoustic tokens.
+ """
+)
+class VibeVoiceAcousticTokenizerModel(VibeVoiceAcousticTokenizerPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.encoder = AutoModel.from_config(config.encoder_config)
+ self.decoder = AutoModel.from_config(config.decoder_config)
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def encode(self, input_values, padding_cache=None, use_cache=None, sample=True):
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Input audio waveform to be encoded into latent representation.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*):
+ Cache object for streaming mode to maintain convolution states across layers.
+ use_cache (`bool`, *optional*):
+ Whether to use caching for convolution states.
+ sample (`bool`, *optional*):
+ Whether to sample from the VAE. If False, no noise is added.
+ """
+ encoder_output = self.encoder(input_values, padding_cache=padding_cache, use_cache=use_cache)
+
+ if sample:
+ noise_std = self.config.vae_std * torch.randn(
+ encoder_output.latents.shape[0],
+ device=encoder_output.latents.device,
+ dtype=encoder_output.latents.dtype,
+ )
+ encoder_output.latents = encoder_output.latents + noise_std[:, None, None] * torch.randn_like(
+ encoder_output.latents
+ )
+ return encoder_output
+
+ @can_return_tuple
+ @auto_docstring
+ def decode(self, latents, padding_cache=None, use_cache=False):
+ r"""
+ latents (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Input latent representation to be decoded back into audio.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*):
+ Cache object for streaming mode to maintain convolution states across layers.
+ use_cache (`bool`, *optional*):
+ Whether to use caching for convolution states.
+ """
+ latents = latents.permute(0, 2, 1)
+ return self.decoder(latents, padding_cache=padding_cache, use_cache=use_cache)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(self, input_values, padding_cache=None, use_cache=False, sample=True, **kwargs):
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`):
+ Input audio waveform to be encoded into latent representation.
+ padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *optional*):
+ Cache object for streaming mode to maintain convolution states across layers. Note only used by decoder.
+ use_cache (`bool`, *optional*):
+ Whether to use caching for convolution states.
+ sample (`bool`, *optional*):
+ Whether to sample from the VAE latent distribution. If False, no noise is added to the latents.
+ """
+ encoder_output = self.encode(input_values, use_cache=use_cache, sample=sample)
+ decoder_output = self.decode(encoder_output.latents, padding_cache=padding_cache, use_cache=use_cache)
+ return VibeVoiceAcousticTokenizerOutput(
+ audio=decoder_output.audio,
+ latents=encoder_output.latents,
+ padding_cache=decoder_output.padding_cache,
+ )
+
+
+__all__ = [
+ "VibeVoiceAcousticTokenizerModel",
+ "VibeVoiceAcousticTokenizerEncoderModel",
+ "VibeVoiceAcousticTokenizerDecoderModel",
+ "VibeVoiceAcousticTokenizerPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__init__.py b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c5cdefa7d75bb967e8351db46ba766c0c8a5949
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2026 Microsoft and the HuggingFace Inc. 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_vibevoice_asr import *
+ from .modeling_vibevoice_asr import *
+ from .processing_vibevoice_asr import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55bbd2595bafce034e3334eeba586138df9d0996
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/configuration_vibevoice_asr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/configuration_vibevoice_asr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f67942a9bbbac698325b00e2659ff287cd82c46
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/configuration_vibevoice_asr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/modeling_vibevoice_asr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/modeling_vibevoice_asr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5de9a8d62d5fce24e5751496e5da4594454efbf
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/modeling_vibevoice_asr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/modular_vibevoice_asr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/modular_vibevoice_asr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c87d06ad3ff7055e68cd0d8391d452abe7b21176
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/modular_vibevoice_asr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/processing_vibevoice_asr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/processing_vibevoice_asr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ad37214ce0c3ab2ba0866f3ef329cdc60ae52a9d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/__pycache__/processing_vibevoice_asr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/configuration_vibevoice_asr.py b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/configuration_vibevoice_asr.py
new file mode 100644
index 0000000000000000000000000000000000000000..a673a5845871af1cede8d0b2f137b55137dd772a
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/configuration_vibevoice_asr.py
@@ -0,0 +1,111 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/vibevoice_asr/modular_vibevoice_asr.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_vibevoice_asr.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 Microsoft and the HuggingFace Inc. 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import CONFIG_MAPPING, AutoConfig
+
+
+@auto_docstring(checkpoint="microsoft/VibeVoice-ASR-HF")
+@strict
+class VibeVoiceAsrConfig(PreTrainedConfig):
+ r"""
+ acoustic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *optional*):
+ The config object or dictionary of the acoustic tokenizer. This tokenizer extracts acoustic features from audio.
+ semantic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *optional*):
+ The config object or dictionary of the semantic tokenizer. This tokenizer extracts semantic features from audio.
+ audio_bos_token_id (`int`, *optional*, defaults to 151646):
+ The audio begin-of-sequence token index.
+ audio_eos_token_id (`int`, *optional*, defaults to 151647):
+ The audio end-of-sequence token index.
+ acoustic_tokenizer_chunk_size (`int`, *optional*, defaults to 1440000):
+ The chunk size (in number of samples) to use when tokenizer audio inputs. Default corresponds to 60 seconds at 24kHz.
+
+ Example:
+
+ ```python
+ >>> from transformers import VibeVoiceAsrForConditionalGeneration, VibeVoiceAsrConfig, VibeVoiceAcousticTokenizerEncoderConfig, Qwen2Config
+
+ >>> # Initializing VibeVoice acoustic and semantic encoder configs
+ >>> acoustic_config = VibeVoiceAcousticTokenizerEncoderConfig()
+ >>> semantic_config = VibeVoiceAcousticTokenizerEncoderConfig(hidden_size=128)
+
+ >>> # Initializing a Qwen2 config
+ >>> text_config = Qwen2Config()
+
+ >>> # Initializing a VibeVoice ASR configuration
+ >>> configuration = VibeVoiceAsrConfig(acoustic_config, semantic_config, text_config)
+
+ >>> # Initializing a model from the vibevoice_asr style configuration
+ >>> model = VibeVoiceAsrForConditionalGeneration(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "vibevoice_asr"
+ sub_configs = {
+ "acoustic_tokenizer_encoder_config": AutoConfig,
+ "semantic_tokenizer_encoder_config": AutoConfig,
+ "text_config": AutoConfig,
+ }
+
+ acoustic_tokenizer_encoder_config: dict | PreTrainedConfig | None = None
+ semantic_tokenizer_encoder_config: dict | PreTrainedConfig | None = None
+ text_config: dict | PreTrainedConfig | None = None
+ audio_token_id: int = 151648
+ audio_bos_token_id: int = 151646
+ audio_eos_token_id: int = 151647
+ acoustic_tokenizer_chunk_size: int = 1440000
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.acoustic_tokenizer_encoder_config, dict):
+ self.acoustic_tokenizer_encoder_config["model_type"] = self.acoustic_tokenizer_encoder_config.get(
+ "model_type", "vibevoice_acoustic_tokenizer_encoder"
+ )
+ self.acoustic_tokenizer_encoder_config = CONFIG_MAPPING[
+ self.acoustic_tokenizer_encoder_config["model_type"]
+ ](**self.acoustic_tokenizer_encoder_config)
+ elif self.acoustic_tokenizer_encoder_config is None:
+ self.acoustic_tokenizer_encoder_config = CONFIG_MAPPING["vibevoice_acoustic_tokenizer_encoder"]()
+
+ if isinstance(self.semantic_tokenizer_encoder_config, dict):
+ self.semantic_tokenizer_encoder_config["model_type"] = self.semantic_tokenizer_encoder_config.get(
+ "model_type", "vibevoice_acoustic_tokenizer_encoder"
+ )
+ self.semantic_tokenizer_encoder_config = CONFIG_MAPPING[
+ self.semantic_tokenizer_encoder_config["model_type"]
+ ](**self.semantic_tokenizer_encoder_config)
+ elif self.semantic_tokenizer_encoder_config is None:
+ self.semantic_tokenizer_encoder_config = CONFIG_MAPPING["vibevoice_acoustic_tokenizer_encoder"](
+ hidden_size=128
+ )
+
+ if isinstance(self.text_config, dict):
+ self.text_config["model_type"] = self.text_config.get("model_type", "qwen2")
+ self.text_config = CONFIG_MAPPING[self.text_config["model_type"]](**self.text_config)
+ elif self.text_config is None:
+ self.text_config = CONFIG_MAPPING["qwen2"]()
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["VibeVoiceAsrConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py
new file mode 100644
index 0000000000000000000000000000000000000000..4eb523fd32188c947c2a5f603abf1623c2ec4269
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py
@@ -0,0 +1,465 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/vibevoice_asr/modular_vibevoice_asr.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_vibevoice_asr.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 Microsoft and the HuggingFace Inc. 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 torch
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache
+from ...generation import GenerationMixin
+from ...integrations import use_kernel_forward_from_hub
+from ...modeling_outputs import BaseModelOutputWithPooling, CausalLMOutputWithPast
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import (
+ TransformersKwargs,
+ auto_docstring,
+ can_return_tuple,
+ is_torchdynamo_compiling,
+ torch_compilable_check,
+)
+from ..auto import AutoModel, AutoModelForCausalLM
+from .configuration_vibevoice_asr import VibeVoiceAsrConfig
+
+
+@use_kernel_forward_from_hub("RMSNorm")
+class VibeVoiceAsrRMSNorm(nn.Module):
+ def __init__(self, hidden_size, eps: float = 1e-6) -> None:
+ """
+ VibeVoiceAsrRMSNorm is equivalent to T5LayerNorm
+ """
+ super().__init__()
+ self.weight = nn.Parameter(torch.ones(hidden_size))
+ self.variance_epsilon = eps
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ input_dtype = hidden_states.dtype
+ hidden_states = hidden_states.to(torch.float32)
+ variance = hidden_states.pow(2).mean(-1, keepdim=True)
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+ return self.weight * hidden_states.to(input_dtype)
+
+ def extra_repr(self):
+ return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"
+
+
+class VibeVoiceAsrMultiModalProjector(nn.Module):
+ def __init__(self, config: VibeVoiceAsrConfig):
+ super().__init__()
+ # Acoustic path
+ self.acoustic_linear_1 = nn.Linear(
+ config.acoustic_tokenizer_encoder_config.hidden_size, config.text_config.hidden_size
+ )
+ self.acoustic_norm = VibeVoiceAsrRMSNorm(config.text_config.hidden_size, eps=1e-6)
+ self.acoustic_linear_2 = nn.Linear(config.text_config.hidden_size, config.text_config.hidden_size)
+
+ # Semantic path
+ self.semantic_linear_1 = nn.Linear(
+ config.semantic_tokenizer_encoder_config.hidden_size, config.text_config.hidden_size
+ )
+ self.semantic_norm = VibeVoiceAsrRMSNorm(config.text_config.hidden_size, eps=1e-6)
+ self.semantic_linear_2 = nn.Linear(config.text_config.hidden_size, config.text_config.hidden_size)
+
+ def forward(self, acoustic_latents, semantic_latents):
+ acoustic_features = self.acoustic_linear_1(acoustic_latents)
+ acoustic_features = self.acoustic_norm(acoustic_features)
+ acoustic_features = self.acoustic_linear_2(acoustic_features)
+
+ semantic_features = self.semantic_linear_1(semantic_latents)
+ semantic_features = self.semantic_norm(semantic_features)
+ semantic_features = self.semantic_linear_2(semantic_features)
+
+ return acoustic_features + semantic_features
+
+
+class VibeVoiceAsrFeedForward(nn.Module):
+ def __init__(self, config, hidden_size):
+ super().__init__()
+ self.linear1 = nn.Linear(hidden_size, config.ffn_expansion * hidden_size)
+ self.activation = ACT2FN[config.hidden_act]
+ self.linear2 = nn.Linear(config.ffn_expansion * hidden_size, hidden_size)
+
+ def forward(self, hidden_states):
+ return self.linear2(self.activation(self.linear1(hidden_states)))
+
+
+class VibeVoiceAsrConv1dCacheLayer:
+ def __init__(self):
+ self.cache: torch.Tensor | None = None
+ self.is_initialized: bool = False
+
+ def lazy_initialization(self, hidden_states, conv_module):
+ self.left_pad = conv_module.left_pad
+ self.in_channels = conv_module.in_channels
+ self.cache = torch.zeros(
+ hidden_states.shape[0],
+ self.in_channels,
+ self.left_pad,
+ device=hidden_states.device,
+ dtype=hidden_states.dtype,
+ )
+
+ if not is_torchdynamo_compiling():
+ torch._dynamo.mark_static_address(self.cache)
+
+ self.is_initialized = True
+
+ def update(self, hidden_states, conv_module=None):
+ if not self.is_initialized and conv_module is not None:
+ self.lazy_initialization(hidden_states, conv_module)
+ elif not self.is_initialized:
+ raise ValueError(
+ "VibeVoiceAsrConv1dCacheLayer is not initialized. Make sure to provide conv_module to the update method."
+ )
+
+ # get the padding states
+ if self.left_pad > 0:
+ shortfall = max(0, self.left_pad - hidden_states.shape[-1])
+ if shortfall > 0:
+ padding_states = torch.cat([self.cache[:, :, -shortfall:], hidden_states], dim=-1)
+ else:
+ padding_states = hidden_states[:, :, -self.left_pad :]
+ else:
+ padding_states = torch.empty(
+ hidden_states.shape[0], self.in_channels, 0, dtype=hidden_states.dtype, device=hidden_states.device
+ )
+
+ current_cache = self.cache.clone()
+ self.cache.copy_(padding_states)
+
+ return current_cache
+
+
+class VibeVoiceAsrConv1dPaddingCache:
+ def __init__(self):
+ self.layers = {}
+
+ def update(self, hidden_states, cache_key, conv_module):
+ if cache_key not in self.layers:
+ self.layers[cache_key] = VibeVoiceAsrConv1dCacheLayer()
+
+ padding_states = self.layers[cache_key].update(hidden_states, conv_module)
+ padded_hidden_states = torch.cat([padding_states, hidden_states], dim=-1)
+ return padded_hidden_states
+
+
+# TODO: @eustlb, @ebezzam this should be latter factorized with other causalconv1d (e.g. VoxtralRealtimeCausalConv1d)
+class VibeVoiceAsrCausalConv1d(nn.Module):
+ """Conv1d with built-in causal padding and optional streaming support through a cache."""
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ cache_key: str,
+ stride: int = 1,
+ dilation: int = 1,
+ groups: int = 1,
+ ):
+ super().__init__()
+ self.conv = nn.Conv1d(in_channels, out_channels, kernel_size, stride, dilation=dilation, groups=groups)
+ self.causal_padding = (kernel_size - 1) * dilation - (stride - 1)
+ if self.causal_padding < 0:
+ raise ValueError(
+ f"Invalid causal padding {self.causal_padding} for kernel_size={kernel_size}, "
+ f"dilation={dilation}, stride={stride}."
+ )
+ self.cache_key = cache_key
+ self.in_channels = in_channels
+ self.left_pad = self.causal_padding
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ padding_cache: VibeVoiceAsrConv1dPaddingCache | None = None,
+ ) -> torch.Tensor:
+ if padding_cache is not None:
+ hidden_states = padding_cache.update(hidden_states, self.cache_key, self)
+ else:
+ hidden_states = nn.functional.pad(hidden_states, (self.left_pad, 0))
+
+ return self.conv(hidden_states)
+
+
+class VibeVoiceAsrConvNext1dLayer(nn.Module):
+ """ConvNeXt-like block adapted for 1D convolutions."""
+
+ def __init__(self, config, hidden_size, dilation=1, stride=1, layer_idx=None):
+ super().__init__()
+
+ self.norm = VibeVoiceAsrRMSNorm(hidden_size, eps=config.rms_norm_eps)
+ self.ffn_norm = VibeVoiceAsrRMSNorm(hidden_size, eps=config.rms_norm_eps)
+ self.ffn = VibeVoiceAsrFeedForward(config, hidden_size)
+ self.gamma = nn.Parameter(config.layer_scale_init_value * torch.ones(hidden_size), requires_grad=True)
+ self.ffn_gamma = nn.Parameter(config.layer_scale_init_value * torch.ones(hidden_size), requires_grad=True)
+ self.mixer = VibeVoiceAsrCausalConv1d(
+ in_channels=hidden_size,
+ out_channels=hidden_size,
+ kernel_size=config.kernel_size,
+ cache_key=f"convnext_layer_{layer_idx}",
+ groups=hidden_size,
+ dilation=dilation,
+ stride=stride,
+ )
+
+ def forward(self, hidden_states, padding_cache=None):
+ # mixer
+ residual = hidden_states
+ hidden_states = self.norm(hidden_states.transpose(1, 2)).transpose(1, 2)
+ hidden_states = self.mixer(hidden_states, padding_cache=padding_cache)
+ hidden_states = hidden_states * self.gamma.unsqueeze(-1)
+ hidden_states = residual + hidden_states
+
+ # ffn
+ residual = hidden_states
+ hidden_states = self.ffn_norm(hidden_states.transpose(1, 2))
+ hidden_states = self.ffn(hidden_states).transpose(1, 2)
+ hidden_states = hidden_states * self.ffn_gamma.unsqueeze(-1)
+ return residual + hidden_states
+
+
+@auto_docstring
+class VibeVoiceAsrPreTrainedModel(PreTrainedModel):
+ config: VibeVoiceAsrConfig
+ base_model_prefix = "model"
+ main_input_name = "input_ids"
+ _no_split_modules = None
+ input_modalities = ("audio", "text")
+ supports_gradient_checkpointing = True
+ _skip_keys_device_placement = ["past_key_values"]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, VibeVoiceAsrConvNext1dLayer):
+ init.constant_(module.gamma, self.config.layer_scale_init_value)
+ init.constant_(module.ffn_gamma, self.config.layer_scale_init_value)
+
+
+@auto_docstring(
+ custom_intro="""
+ The VibeVoice ASR model with pre-trained acoustic tokenizers and a language model.
+ """
+)
+class VibeVoiceAsrForConditionalGeneration(VibeVoiceAsrPreTrainedModel, GenerationMixin):
+ _keep_in_fp32_modules_strict = None
+ _supports_attention_backend = True
+ _tp_plan = None
+ _pp_plan = None
+
+ def __init__(self, config: VibeVoiceAsrConfig):
+ super().__init__(config)
+ self.vocab_size = config.text_config.vocab_size
+ self.language_model = AutoModelForCausalLM.from_config(config.text_config)
+ self.multi_modal_projector = VibeVoiceAsrMultiModalProjector(config)
+ self.acoustic_tokenizer_encoder = AutoModel.from_config(config.acoustic_tokenizer_encoder_config)
+ self.semantic_tokenizer_encoder = AutoModel.from_config(config.semantic_tokenizer_encoder_config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_output_embeddings(self):
+ return self.language_model.get_output_embeddings()
+
+ def set_output_embeddings(self, new_embeddings):
+ self.language_model.set_output_embeddings(new_embeddings)
+
+ def set_decoder(self, decoder):
+ self.language_model.set_decoder(decoder)
+
+ def get_decoder(self):
+ return self.language_model.get_decoder()
+
+ @can_return_tuple
+ @auto_docstring(custom_intro="Encode audio into embeddings that can be used by the language model.")
+ def get_audio_features(
+ self,
+ input_values: torch.FloatTensor,
+ padding_mask: torch.BoolTensor | None = None,
+ acoustic_tokenizer_chunk_size: int | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, num_samples)`):
+ Input audio tensor. Audio should be sampled at 24kHz.
+ padding_mask (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing operations on padding feature indices.
+ acoustic_tokenizer_chunk_size (`int`, *optional*):
+ Size of audio chunks to process at once through the tokenizers. Defaults to `config.acoustic_tokenizer_chunk_size`,
+ but can be modified to fit the available memory.
+ """
+
+ if acoustic_tokenizer_chunk_size is None:
+ acoustic_tokenizer_chunk_size = self.config.acoustic_tokenizer_chunk_size
+ else:
+ if acoustic_tokenizer_chunk_size % self.config.acoustic_tokenizer_encoder_config.hop_length != 0:
+ acoustic_tokenizer_chunk_size = int(
+ (acoustic_tokenizer_chunk_size // self.config.acoustic_tokenizer_encoder_config.hop_length)
+ * self.config.acoustic_tokenizer_encoder_config.hop_length
+ )
+ raise ValueError(
+ f"`acoustic_tokenizer_chunk_size` must be a multiple of hop length ({self.config.acoustic_tokenizer_encoder_config.hop_length}), {acoustic_tokenizer_chunk_size} is a valid option."
+ )
+
+ with torch.no_grad():
+ acoustic_encoder_cache, semantic_encoder_cache = None, None
+ acoustic_latents, semantic_latents = [], []
+
+ for chunk in torch.split(input_values, acoustic_tokenizer_chunk_size, dim=-1):
+ acoustic_encoder_output = self.acoustic_tokenizer_encoder(
+ chunk,
+ padding_cache=acoustic_encoder_cache,
+ use_cache=True,
+ )
+ acoustic_latents.append(acoustic_encoder_output.latents)
+ acoustic_encoder_cache = acoustic_encoder_output.padding_cache
+
+ semantic_encoder_output = self.semantic_tokenizer_encoder(
+ chunk,
+ padding_cache=semantic_encoder_cache,
+ use_cache=True,
+ )
+ semantic_latents.append(semantic_encoder_output.latents)
+ semantic_encoder_cache = semantic_encoder_output.padding_cache
+
+ acoustic_latents = torch.cat(acoustic_latents, dim=1)
+ semantic_latents = torch.cat(semantic_latents, dim=1)
+
+ # Sample acoustic tokens
+ noise_std = self.config.acoustic_tokenizer_encoder_config.vae_std * torch.randn(
+ acoustic_latents.shape[0], device=acoustic_latents.device, dtype=acoustic_latents.dtype
+ )
+ acoustic_latents = acoustic_latents + noise_std[:, None, None] * torch.randn_like(acoustic_latents)
+
+ combined_features = self.multi_modal_projector(acoustic_latents, semantic_latents)
+ if padding_mask is not None:
+ # Adjust padding mask according to tokenizer compression
+ num_audio_tokens = torch.ceil(
+ padding_mask.sum(dim=-1) / self.config.acoustic_tokenizer_encoder_config.hop_length
+ ).to(torch.int64)
+ padding_mask = torch.arange(num_audio_tokens.max(), device=combined_features.device) < num_audio_tokens[
+ :, None
+ ].to(combined_features.device)
+ combined_features = combined_features[padding_mask]
+
+ return BaseModelOutputWithPooling(last_hidden_state=acoustic_latents, pooler_output=combined_features)
+
+ def get_placeholder_mask(
+ self, input_ids: torch.LongTensor, inputs_embeds: torch.FloatTensor, audio_features: torch.FloatTensor
+ ):
+ """
+ Obtains multimodal placeholder mask from `input_ids` or `inputs_embeds`, and checks that the placeholder token count is
+ equal to the length of multimodal features. If the lengths are different, an error is raised.
+ """
+ if input_ids is None:
+ special_audio_mask = inputs_embeds == self.get_input_embeddings()(
+ torch.tensor(self.config.audio_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ special_audio_mask = special_audio_mask.all(-1)
+ else:
+ special_audio_mask = input_ids == self.config.audio_token_id
+
+ n_audio_tokens = special_audio_mask.sum()
+ n_audio_features = audio_features.shape[0]
+ special_audio_mask = special_audio_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+ torch_compilable_check(
+ inputs_embeds[special_audio_mask].numel() == audio_features.numel(),
+ f"Audio features and audio tokens do not match, tokens: {n_audio_tokens}, features: {n_audio_features}",
+ )
+ return special_audio_mask
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ input_values: torch.FloatTensor | None = None,
+ padding_mask: torch.BoolTensor | None = None,
+ acoustic_tokenizer_chunk_size: int | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> CausalLMOutputWithPast:
+ r"""
+ padding_mask (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing operations on padding feature indices.
+ acoustic_tokenizer_chunk_size (`int`, *optional*):
+ Size of audio chunks processed by the acoustic and semantic tokenizers. Defaults to
+ `config.acoustic_tokenizer_chunk_size`, but can be modified to fit the available memory.
+
+ Example:
+
+ ```python
+ >>> from transformers import VibeVoiceAsrForConditionalGeneration, AutoProcessor
+
+ >>> model_id = "microsoft/VibeVoice-ASR-HF"
+ >>> processor = AutoProcessor.from_pretrained(model_id)
+ >>> model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, dtype="auto", device_map="auto")
+
+ >>> inputs = processor.apply_transcription_request("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
+ >>> inputs = inputs.to(model.device, dtype=model.dtype)
+ >>> outputs = model.generate(**inputs)
+
+ >>> decoded_outputs = processor.batch_decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=True)
+ >>> print(decoded_outputs)
+ ```"""
+
+ if inputs_embeds is None:
+ inputs_embeds = self.get_input_embeddings()(input_ids)
+
+ if input_values is not None and input_ids is not None:
+ audio_embeds = self.get_audio_features(
+ input_values=input_values,
+ padding_mask=padding_mask,
+ acoustic_tokenizer_chunk_size=acoustic_tokenizer_chunk_size,
+ ).pooler_output
+
+ # Replace text-audio token placeholders with audio embeddings
+ audio_token_mask = (input_ids == self.config.audio_token_id).unsqueeze(-1)
+ inputs_embeds = inputs_embeds.masked_scatter(
+ audio_token_mask.to(inputs_embeds.device), audio_embeds.to(inputs_embeds.device)
+ )
+
+ return self.language_model(
+ inputs_embeds=inputs_embeds, attention_mask=attention_mask, past_key_values=past_key_values, **kwargs
+ )
+
+ def prepare_inputs_for_generation(self, *args, is_first_iteration=False, **kwargs):
+ input_values = kwargs.pop("input_values", None)
+ padding_mask = kwargs.pop("padding_mask", None)
+ acoustic_tokenizer_chunk_size = kwargs.pop("acoustic_tokenizer_chunk_size", None)
+
+ model_inputs = super().prepare_inputs_for_generation(*args, **kwargs)
+
+ if is_first_iteration:
+ if input_values is not None:
+ model_inputs["input_values"] = input_values
+ if padding_mask is not None:
+ model_inputs["padding_mask"] = padding_mask
+ if acoustic_tokenizer_chunk_size is not None:
+ model_inputs["acoustic_tokenizer_chunk_size"] = acoustic_tokenizer_chunk_size
+
+ return model_inputs
+
+
+__all__ = ["VibeVoiceAsrForConditionalGeneration", "VibeVoiceAsrPreTrainedModel"]
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/modular_vibevoice_asr.py b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/modular_vibevoice_asr.py
new file mode 100644
index 0000000000000000000000000000000000000000..52652de9adde9fe838dd7ce1ead8801b1a571b37
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/modular_vibevoice_asr.py
@@ -0,0 +1,331 @@
+# Copyright 2026 Microsoft and the HuggingFace Inc. 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 torch
+from huggingface_hub.dataclasses import strict
+from torch import nn
+
+from ...cache_utils import Cache
+from ...configuration_utils import PreTrainedConfig
+from ...modeling_outputs import BaseModelOutputWithPooling, CausalLMOutputWithPast
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, logging
+from ..audioflamingo3.modeling_audioflamingo3 import AudioFlamingo3ForConditionalGeneration
+from ..auto import CONFIG_MAPPING, AutoConfig, AutoModel
+from ..qwen2.modeling_qwen2 import Qwen2RMSNorm
+from ..vibevoice_acoustic_tokenizer.modeling_vibevoice_acoustic_tokenizer import (
+ VibeVoiceAcousticTokenizerPreTrainedModel,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="microsoft/VibeVoice-ASR-HF")
+@strict
+class VibeVoiceAsrConfig(PreTrainedConfig):
+ r"""
+ acoustic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *optional*):
+ The config object or dictionary of the acoustic tokenizer. This tokenizer extracts acoustic features from audio.
+ semantic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *optional*):
+ The config object or dictionary of the semantic tokenizer. This tokenizer extracts semantic features from audio.
+ audio_bos_token_id (`int`, *optional*, defaults to 151646):
+ The audio begin-of-sequence token index.
+ audio_eos_token_id (`int`, *optional*, defaults to 151647):
+ The audio end-of-sequence token index.
+ acoustic_tokenizer_chunk_size (`int`, *optional*, defaults to 1440000):
+ The chunk size (in number of samples) to use when tokenizer audio inputs. Default corresponds to 60 seconds at 24kHz.
+
+ Example:
+
+ ```python
+ >>> from transformers import VibeVoiceAsrForConditionalGeneration, VibeVoiceAsrConfig, VibeVoiceAcousticTokenizerEncoderConfig, Qwen2Config
+
+ >>> # Initializing VibeVoice acoustic and semantic encoder configs
+ >>> acoustic_config = VibeVoiceAcousticTokenizerEncoderConfig()
+ >>> semantic_config = VibeVoiceAcousticTokenizerEncoderConfig(hidden_size=128)
+
+ >>> # Initializing a Qwen2 config
+ >>> text_config = Qwen2Config()
+
+ >>> # Initializing a VibeVoice ASR configuration
+ >>> configuration = VibeVoiceAsrConfig(acoustic_config, semantic_config, text_config)
+
+ >>> # Initializing a model from the vibevoice_asr style configuration
+ >>> model = VibeVoiceAsrForConditionalGeneration(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "vibevoice_asr"
+ sub_configs = {
+ "acoustic_tokenizer_encoder_config": AutoConfig,
+ "semantic_tokenizer_encoder_config": AutoConfig,
+ "text_config": AutoConfig,
+ }
+
+ acoustic_tokenizer_encoder_config: dict | PreTrainedConfig | None = None
+ semantic_tokenizer_encoder_config: dict | PreTrainedConfig | None = None
+ text_config: dict | PreTrainedConfig | None = None
+ audio_token_id: int = 151648
+ audio_bos_token_id: int = 151646
+ audio_eos_token_id: int = 151647
+ acoustic_tokenizer_chunk_size: int = 1440000
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.acoustic_tokenizer_encoder_config, dict):
+ self.acoustic_tokenizer_encoder_config["model_type"] = self.acoustic_tokenizer_encoder_config.get(
+ "model_type", "vibevoice_acoustic_tokenizer_encoder"
+ )
+ self.acoustic_tokenizer_encoder_config = CONFIG_MAPPING[
+ self.acoustic_tokenizer_encoder_config["model_type"]
+ ](**self.acoustic_tokenizer_encoder_config)
+ elif self.acoustic_tokenizer_encoder_config is None:
+ self.acoustic_tokenizer_encoder_config = CONFIG_MAPPING["vibevoice_acoustic_tokenizer_encoder"]()
+
+ if isinstance(self.semantic_tokenizer_encoder_config, dict):
+ self.semantic_tokenizer_encoder_config["model_type"] = self.semantic_tokenizer_encoder_config.get(
+ "model_type", "vibevoice_acoustic_tokenizer_encoder"
+ )
+ self.semantic_tokenizer_encoder_config = CONFIG_MAPPING[
+ self.semantic_tokenizer_encoder_config["model_type"]
+ ](**self.semantic_tokenizer_encoder_config)
+ elif self.semantic_tokenizer_encoder_config is None:
+ self.semantic_tokenizer_encoder_config = CONFIG_MAPPING["vibevoice_acoustic_tokenizer_encoder"](
+ hidden_size=128
+ )
+
+ if isinstance(self.text_config, dict):
+ self.text_config["model_type"] = self.text_config.get("model_type", "qwen2")
+ self.text_config = CONFIG_MAPPING[self.text_config["model_type"]](**self.text_config)
+ elif self.text_config is None:
+ self.text_config = CONFIG_MAPPING["qwen2"]()
+
+ super().__post_init__(**kwargs)
+
+
+class VibeVoiceAsrRMSNorm(Qwen2RMSNorm):
+ pass
+
+
+class VibeVoiceAsrMultiModalProjector(nn.Module):
+ def __init__(self, config: VibeVoiceAsrConfig):
+ super().__init__()
+ # Acoustic path
+ self.acoustic_linear_1 = nn.Linear(
+ config.acoustic_tokenizer_encoder_config.hidden_size, config.text_config.hidden_size
+ )
+ self.acoustic_norm = VibeVoiceAsrRMSNorm(config.text_config.hidden_size, eps=1e-6)
+ self.acoustic_linear_2 = nn.Linear(config.text_config.hidden_size, config.text_config.hidden_size)
+
+ # Semantic path
+ self.semantic_linear_1 = nn.Linear(
+ config.semantic_tokenizer_encoder_config.hidden_size, config.text_config.hidden_size
+ )
+ self.semantic_norm = VibeVoiceAsrRMSNorm(config.text_config.hidden_size, eps=1e-6)
+ self.semantic_linear_2 = nn.Linear(config.text_config.hidden_size, config.text_config.hidden_size)
+
+ def forward(self, acoustic_latents, semantic_latents):
+ acoustic_features = self.acoustic_linear_1(acoustic_latents)
+ acoustic_features = self.acoustic_norm(acoustic_features)
+ acoustic_features = self.acoustic_linear_2(acoustic_features)
+
+ semantic_features = self.semantic_linear_1(semantic_latents)
+ semantic_features = self.semantic_norm(semantic_features)
+ semantic_features = self.semantic_linear_2(semantic_features)
+
+ return acoustic_features + semantic_features
+
+
+@auto_docstring
+class VibeVoiceAsrPreTrainedModel(VibeVoiceAcousticTokenizerPreTrainedModel):
+ config: VibeVoiceAsrConfig
+ base_model_prefix = "model"
+ main_input_name = "input_ids"
+ _no_split_modules = None
+ input_modalities = ("audio", "text")
+ supports_gradient_checkpointing = True
+ _skip_keys_device_placement = ["past_key_values"]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+
+
+@auto_docstring(
+ custom_intro="""
+ The VibeVoice ASR model with pre-trained acoustic tokenizers and a language model.
+ """
+)
+class VibeVoiceAsrForConditionalGeneration(AudioFlamingo3ForConditionalGeneration):
+ _supports_attention_backend = True
+
+ def __init__(self, config: VibeVoiceAsrConfig):
+ super().__init__(config)
+ self.acoustic_tokenizer_encoder = AutoModel.from_config(config.acoustic_tokenizer_encoder_config)
+ self.semantic_tokenizer_encoder = AutoModel.from_config(config.semantic_tokenizer_encoder_config)
+ del self.audio_tower
+
+ @can_return_tuple
+ @auto_docstring(custom_intro="Encode audio into embeddings that can be used by the language model.")
+ def get_audio_features(
+ self,
+ input_values: torch.FloatTensor,
+ padding_mask: torch.BoolTensor | None = None,
+ acoustic_tokenizer_chunk_size: int | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ):
+ r"""
+ input_values (`torch.FloatTensor` of shape `(batch_size, num_samples)`):
+ Input audio tensor. Audio should be sampled at 24kHz.
+ padding_mask (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing operations on padding feature indices.
+ acoustic_tokenizer_chunk_size (`int`, *optional*):
+ Size of audio chunks to process at once through the tokenizers. Defaults to `config.acoustic_tokenizer_chunk_size`,
+ but can be modified to fit the available memory.
+ """
+
+ if acoustic_tokenizer_chunk_size is None:
+ acoustic_tokenizer_chunk_size = self.config.acoustic_tokenizer_chunk_size
+ else:
+ if acoustic_tokenizer_chunk_size % self.config.acoustic_tokenizer_encoder_config.hop_length != 0:
+ acoustic_tokenizer_chunk_size = int(
+ (acoustic_tokenizer_chunk_size // self.config.acoustic_tokenizer_encoder_config.hop_length)
+ * self.config.acoustic_tokenizer_encoder_config.hop_length
+ )
+ raise ValueError(
+ f"`acoustic_tokenizer_chunk_size` must be a multiple of hop length ({self.config.acoustic_tokenizer_encoder_config.hop_length}), {acoustic_tokenizer_chunk_size} is a valid option."
+ )
+
+ with torch.no_grad():
+ acoustic_encoder_cache, semantic_encoder_cache = None, None
+ acoustic_latents, semantic_latents = [], []
+
+ for chunk in torch.split(input_values, acoustic_tokenizer_chunk_size, dim=-1):
+ acoustic_encoder_output = self.acoustic_tokenizer_encoder(
+ chunk,
+ padding_cache=acoustic_encoder_cache,
+ use_cache=True,
+ )
+ acoustic_latents.append(acoustic_encoder_output.latents)
+ acoustic_encoder_cache = acoustic_encoder_output.padding_cache
+
+ semantic_encoder_output = self.semantic_tokenizer_encoder(
+ chunk,
+ padding_cache=semantic_encoder_cache,
+ use_cache=True,
+ )
+ semantic_latents.append(semantic_encoder_output.latents)
+ semantic_encoder_cache = semantic_encoder_output.padding_cache
+
+ acoustic_latents = torch.cat(acoustic_latents, dim=1)
+ semantic_latents = torch.cat(semantic_latents, dim=1)
+
+ # Sample acoustic tokens
+ noise_std = self.config.acoustic_tokenizer_encoder_config.vae_std * torch.randn(
+ acoustic_latents.shape[0], device=acoustic_latents.device, dtype=acoustic_latents.dtype
+ )
+ acoustic_latents = acoustic_latents + noise_std[:, None, None] * torch.randn_like(acoustic_latents)
+
+ combined_features = self.multi_modal_projector(acoustic_latents, semantic_latents)
+ if padding_mask is not None:
+ # Adjust padding mask according to tokenizer compression
+ num_audio_tokens = torch.ceil(
+ padding_mask.sum(dim=-1) / self.config.acoustic_tokenizer_encoder_config.hop_length
+ ).to(torch.int64)
+ padding_mask = torch.arange(num_audio_tokens.max(), device=combined_features.device) < num_audio_tokens[
+ :, None
+ ].to(combined_features.device)
+ combined_features = combined_features[padding_mask]
+
+ return BaseModelOutputWithPooling(last_hidden_state=acoustic_latents, pooler_output=combined_features)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ input_values: torch.FloatTensor | None = None,
+ padding_mask: torch.BoolTensor | None = None,
+ acoustic_tokenizer_chunk_size: int | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> CausalLMOutputWithPast:
+ r"""
+ padding_mask (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Mask to avoid performing operations on padding feature indices.
+ acoustic_tokenizer_chunk_size (`int`, *optional*):
+ Size of audio chunks processed by the acoustic and semantic tokenizers. Defaults to
+ `config.acoustic_tokenizer_chunk_size`, but can be modified to fit the available memory.
+
+ Example:
+
+ ```python
+ >>> from transformers import VibeVoiceAsrForConditionalGeneration, AutoProcessor
+
+ >>> model_id = "microsoft/VibeVoice-ASR-HF"
+ >>> processor = AutoProcessor.from_pretrained(model_id)
+ >>> model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, dtype="auto", device_map="auto")
+
+ >>> inputs = processor.apply_transcription_request("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
+ >>> inputs = inputs.to(model.device, dtype=model.dtype)
+ >>> outputs = model.generate(**inputs)
+
+ >>> decoded_outputs = processor.batch_decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=True)
+ >>> print(decoded_outputs)
+ ```"""
+
+ if inputs_embeds is None:
+ inputs_embeds = self.get_input_embeddings()(input_ids)
+
+ if input_values is not None and input_ids is not None:
+ audio_embeds = self.get_audio_features(
+ input_values=input_values,
+ padding_mask=padding_mask,
+ acoustic_tokenizer_chunk_size=acoustic_tokenizer_chunk_size,
+ ).pooler_output
+
+ # Replace text-audio token placeholders with audio embeddings
+ audio_token_mask = (input_ids == self.config.audio_token_id).unsqueeze(-1)
+ inputs_embeds = inputs_embeds.masked_scatter(
+ audio_token_mask.to(inputs_embeds.device), audio_embeds.to(inputs_embeds.device)
+ )
+
+ return self.language_model(
+ inputs_embeds=inputs_embeds, attention_mask=attention_mask, past_key_values=past_key_values, **kwargs
+ )
+
+ def prepare_inputs_for_generation(self, *args, is_first_iteration=False, **kwargs):
+ input_values = kwargs.pop("input_values", None)
+ padding_mask = kwargs.pop("padding_mask", None)
+ acoustic_tokenizer_chunk_size = kwargs.pop("acoustic_tokenizer_chunk_size", None)
+
+ model_inputs = super().prepare_inputs_for_generation(*args, **kwargs)
+
+ if is_first_iteration:
+ if input_values is not None:
+ model_inputs["input_values"] = input_values
+ if padding_mask is not None:
+ model_inputs["padding_mask"] = padding_mask
+ if acoustic_tokenizer_chunk_size is not None:
+ model_inputs["acoustic_tokenizer_chunk_size"] = acoustic_tokenizer_chunk_size
+
+ return model_inputs
+
+
+__all__ = [
+ "VibeVoiceAsrConfig",
+ "VibeVoiceAsrForConditionalGeneration",
+ "VibeVoiceAsrPreTrainedModel",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/vibevoice_asr/processing_vibevoice_asr.py b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/processing_vibevoice_asr.py
new file mode 100644
index 0000000000000000000000000000000000000000..a694fbc99366995db511050ee49e73faca5e9573
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vibevoice_asr/processing_vibevoice_asr.py
@@ -0,0 +1,373 @@
+# Copyright 2026 Microsoft and the HuggingFace Inc. 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 json
+import re
+
+import numpy as np
+
+from ...audio_utils import AudioInput, make_list_of_audio
+from ...feature_extraction_utils import BatchFeature
+from ...processing_utils import ProcessingKwargs, ProcessorMixin, Unpack
+from ...tokenization_utils_base import TextInput
+from ...utils import is_torch_available, logging
+
+
+if is_torch_available():
+ import torch
+
+
+logger = logging.get_logger(__name__)
+
+
+class VibeVoiceAsrProcessorKwargs(ProcessingKwargs, total=False):
+ _defaults = {
+ "text_kwargs": {
+ "padding": True,
+ "padding_side": "left",
+ "add_special_tokens": False,
+ "return_tensors": "pt",
+ },
+ "audio_kwargs": {
+ "sampling_rate": 24000,
+ "pad_to_multiple_of": 3200, # tokenizer hop length
+ },
+ "common_kwargs": {
+ "return_attention_mask": True,
+ },
+ }
+
+
+class VibeVoiceAsrProcessor(ProcessorMixin):
+ r"""
+ Constructs a VibeVoice ASR processor which wraps [`VibeVoiceAcousticTokenizerFeatureExtractor`] and
+ [`Qwen2TokenizerFast`] into a single processor that inherits both the audio feature extraction and
+ tokenizer functionalities.
+
+ See the [`~VibeVoiceAsrProcessor.__call__`] for more information.
+
+ Args:
+ feature_extractor (`VibeVoiceAcousticTokenizerFeatureExtractor`):
+ The feature extractor for audio processing.
+ tokenizer (`Qwen2TokenizerFast`):
+ The tokenizer for text processing.
+ chat_template (`str`, *optional*):
+ A Jinja template which will be used to convert lists of messages in a chat into a tokenizable string.
+ audio_token (`str`, *optional*, defaults to `"<|box_start|>"`):
+ The audio token placeholder to use in the chat template.
+ audio_bos_token (`str`, *optional*, defaults to `"<|object_ref_start|>"`):
+ The audio begin-of-sequence token placeholder to use in the chat template.
+ audio_eos_token (`str`, *optional*, defaults to `"<|object_ref_end|>"`):
+ The audio end-of-sequence token placeholder to use in the chat template.
+ audio_duration_token (`str`, *optional*, defaults to `"<|AUDIO_DURATION|>"`):
+ The audio duration token placeholder to use in the chat template.
+ """
+
+ feature_extractor_class = "VibeVoiceAcousticTokenizerFeatureExtractor"
+ tokenizer_class = "Qwen2TokenizerFast"
+
+ def __init__(
+ self,
+ feature_extractor,
+ tokenizer,
+ chat_template=None,
+ audio_token="<|box_start|>",
+ audio_bos_token="<|object_ref_start|>",
+ audio_eos_token="<|object_ref_end|>",
+ audio_duration_token="<|AUDIO_DURATION|>",
+ ):
+ self.audio_token = audio_token
+ self.audio_token_id = tokenizer.convert_tokens_to_ids(audio_token)
+ self.audio_bos_token = audio_bos_token
+ self.audio_bos_token_id = tokenizer.convert_tokens_to_ids(audio_bos_token)
+ self.audio_eos_token = audio_eos_token
+ self.audio_eos_token_id = tokenizer.convert_tokens_to_ids(audio_eos_token)
+ self.audio_duration_token = audio_duration_token
+ super().__init__(feature_extractor, tokenizer, chat_template=chat_template)
+
+ def __call__(
+ self,
+ text: TextInput | list[TextInput],
+ audio: AudioInput,
+ output_labels: bool | None = False,
+ **kwargs: Unpack[VibeVoiceAsrProcessorKwargs],
+ ) -> BatchFeature:
+ """
+ Main method to process text inputs with optional audio samples for ASR.
+
+ This method processes text inputs (typically prepared by apply_chat_template) and optional audio samples
+ for transcription. It replaces the audio duration placeholder and expands audio token placeholders based
+ on the actual audio length.
+
+ Args:
+ text (`str`, `List[str]`):
+ The input text(s) to process, typically prepared by apply_chat_template with audio token placeholders.
+ audio (`List[Union[str, np.ndarray]]`):
+ Audio samples for transcription. Should match the number of audio token placeholders in text.
+ output_labels (bool, *optional*, default=False):
+ Whether to return labels for training.
+ **kwargs:
+ Additional keyword arguments passed to the tokenizer and feature extractor.
+
+ Returns:
+ [`BatchFeature`]: A dictionary with tokenized text (`input_ids`, `attention_mask`) and
+ audio features (`input_features`, `input_features_mask`).
+ """
+ output_kwargs = self._merge_kwargs(
+ VibeVoiceAsrProcessorKwargs,
+ tokenizer_init_kwargs=self.tokenizer.init_kwargs,
+ **kwargs,
+ )
+
+ text_kwargs = output_kwargs["text_kwargs"]
+ audio_kwargs = output_kwargs["audio_kwargs"]
+ return_tensors = text_kwargs.get("return_tensors", None)
+ if return_tensors != "pt":
+ raise ValueError(f"{self.__class__.__name__} only supports `return_tensors='pt'`.")
+
+ if isinstance(text, str):
+ text = [text]
+ elif not isinstance(text, (list, tuple)):
+ raise ValueError("text input must be a string or list of strings")
+
+ audio = make_list_of_audio(audio)
+ if len(text) != len(audio):
+ raise ValueError(f"Got {len(text)} text but {len(audio)} audios; they must match 1:1.")
+ data = self.feature_extractor(audio, **audio_kwargs)
+
+ # Replace audio duration placeholders in text
+ audio_lengths = data["padding_mask"].sum(dim=-1).cpu().numpy()
+ audio_durations = audio_lengths / self.feature_extractor.sampling_rate
+ audio_duration_pattern = re.compile(re.escape(self.audio_duration_token))
+ for i in range(len(text)):
+ text[i] = audio_duration_pattern.sub(f"{audio_durations[i]:.2f}", text[i])
+
+ # Expand audio tokens in text
+ num_audio_tokens = np.ceil(audio_lengths / audio_kwargs["pad_to_multiple_of"]).astype(int).tolist()
+ audio_token_pattern = re.compile(re.escape(self.audio_token))
+ for i, num_tokens in enumerate(num_audio_tokens):
+ text[i] = audio_token_pattern.sub(self.audio_token * num_tokens, text[i])
+
+ text_inputs = self.tokenizer(text, **text_kwargs)
+ data.update(text_inputs)
+
+ if output_labels:
+ labels = data["input_ids"].clone()
+ labels[labels == self.audio_token_id] = -100
+ labels[labels == self.audio_bos_token_id] = -100
+ labels[labels == self.audio_eos_token_id] = -100
+ labels[labels == self.tokenizer.pad_token_id] = -100
+ data["labels"] = labels
+
+ return BatchFeature(data=data, tensor_type=return_tensors)
+
+ def apply_transcription_request(
+ self,
+ audio: str | list[str] | AudioInput,
+ prompt: str | list[str] | None = None,
+ **kwargs: Unpack[VibeVoiceAsrProcessorKwargs],
+ ) -> BatchFeature:
+ """
+ Prepare inputs for automatic speech recognition without manually writing the chat template.
+
+ Args:
+ audio (`str`, `list[str]`, `np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`):
+ Audio to transcribe. Strings are interpreted as local paths or URLs and will be loaded automatically by
+ the chat template loader; NumPy arrays and PyTorch tensors are forwarded directly.
+ prompt (`str` or `list[str]`, *optional*):
+ Custom prompt(s) to include in the user turn as extra context. A list must be the same length as the
+ batch. When `None`, no additional context is provided.
+ **kwargs:
+ Additional keyword arguments forwarded to [`~VibeVoiceAsrProcessor.apply_chat_template`] (for example
+ `text_kwargs`, `audio_kwargs`, ...).
+
+ Returns:
+ [`BatchFeature`]: Processor outputs ready to be passed to [`VibeVoiceAsrForConditionalGeneration.generate`].
+ """
+
+ if isinstance(audio, str):
+ audio_items: list[str | np.ndarray] = [audio]
+ elif isinstance(audio, (list, tuple)) and audio and all(isinstance(el, str) for el in audio):
+ audio_items = list(audio)
+ else:
+ audio_items = list(make_list_of_audio(audio))
+ if is_torch_available():
+ audio_items = [el.detach().cpu().numpy() if isinstance(el, torch.Tensor) else el for el in audio_items]
+
+ batch_size = len(audio_items)
+ if batch_size == 0:
+ raise ValueError("`audio` must contain at least one sample.")
+
+ if prompt is None:
+ prompts = [None] * batch_size
+ elif isinstance(prompt, str):
+ prompts = [prompt] * batch_size
+ elif isinstance(prompt, (list, tuple)):
+ if len(prompt) != batch_size:
+ raise ValueError(
+ f"Received {len(prompt)} prompt(s) for {batch_size} audio sample(s); counts must match."
+ )
+ prompts = list(prompt)
+ else:
+ raise TypeError("`prompt` must be a string, a sequence of strings, or `None`.")
+
+ conversations = []
+ for prompt_text, audio_item in zip(prompts, audio_items):
+ content = []
+ if isinstance(audio_item, str):
+ content.append({"type": "audio", "path": audio_item})
+ else:
+ content.append({"type": "audio", "audio": audio_item})
+
+ if prompt_text is not None:
+ content.append({"type": "text", "text": prompt_text})
+
+ conversations.append([{"role": "user", "content": content}])
+
+ return self.apply_chat_template(
+ conversations,
+ tokenize=True,
+ add_generation_prompt=True,
+ return_dict=True,
+ **kwargs,
+ )
+
+ def decode(self, *args, return_format="raw", **kwargs):
+ """
+ Forward arguments to [`~PreTrainedTokenizer.decode`] and optionally parse the dict-like output.
+
+ VibeVoice ASR outputs transcriptions in a dictionary-like format, e.g.:
+ ```
+ [
+ 'assistant\n[{"Start":0.0,"End":7.56,"Speaker":0,"Content":"text"}]\n',
+ 'assistant\n[{"Start":0,"End":5.20,"Speaker":0,"Content":"text"}]\n'
+ ]
+ ```
+
+ Args:
+ return_format (`str`, *optional*, defaults to `"raw"`):
+ Options are:
+ - `"raw"`: Return a list of raw decoded strings from the tokenizer, without any parsing.
+ - `"parsed"`: Return a list of list of parsed dictionary objects for each speaker utterance with timestamps.
+ - `"transcription_only"`: Return a list of extracted transcription strings.
+
+ `skip_special_tokens` is automatically enforced (hard-set) to `True` for `"parsed"` and `"transcription_only"`.
+ """
+ return_types = ["raw", "parsed", "transcription_only"]
+ if return_format not in return_types:
+ raise ValueError(f"return_format must be one of {return_types}.")
+ if return_format != "raw":
+ kwargs["skip_special_tokens"] = True # for other formats this does not make sense, we can silently ignore
+
+ decoded = self.tokenizer.decode(*args, **kwargs)
+
+ if return_format == "parsed":
+ decoded = self.extract_speaker_dict(decoded)
+ elif return_format == "transcription_only":
+ decoded = self.extract_transcription(decoded)
+ return decoded
+
+ def extract_speaker_dict(self, text: str | list[str]) -> list[dict] | str | list[list[dict] | str]:
+ """
+ Extract speaker dictionary from raw output, returning original text on failure.
+
+ Args:
+ text (`str` or `list[str]`):
+ Single text or batch of texts to parse from the output of `decode` with `return_format="raw"`.
+
+ Returns:
+ Parsed output(s). For single input, returns `list[dict]` or `str`.
+ For batch input, returns `list[list[dict] | str]`.
+ """
+ is_single = isinstance(text, str)
+ if is_single:
+ text = [text]
+
+ speaker_dict = []
+ for t in text:
+ t = t.strip()
+ if t.startswith("assistant"):
+ t = t[len("assistant") :].strip()
+
+ if not t.startswith("["):
+ logger.warning("Output doesn't start with '[', likely not JSON array.")
+ speaker_dict.append(t)
+ continue
+
+ segments = json.loads(t)
+ if not isinstance(segments, list):
+ logger.warning(f"Expected list, got {type(segments).__name__}.")
+ speaker_dict.append(t)
+ continue
+
+ if segments and not all(isinstance(seg, dict) and "Content" in seg for seg in segments):
+ logger.warning("Not all segments have expected structure.")
+ speaker_dict.append(t)
+ continue
+
+ time_stamps_valid = True
+ for seg in segments:
+ if isinstance(seg, dict):
+ for key in ("Start", "End"):
+ val = seg.get(key, None)
+ if val is not None and not isinstance(val, float):
+ if isinstance(val, (int, float)):
+ seg[key] = float(val)
+ else:
+ logger.warning(f"Expected '{key}' to be a number, got {type(val).__name__}.")
+ time_stamps_valid = False
+ break
+ else:
+ logger.warning(f"Expected segment to be dict, got {type(seg).__name__}.")
+ time_stamps_valid = False
+ break
+
+ if not time_stamps_valid:
+ speaker_dict.append(t)
+ else:
+ speaker_dict.append(segments)
+
+ return speaker_dict[0] if is_single else speaker_dict
+
+ def extract_transcription(self, text: str | list[str]) -> str | list[str]:
+ """
+ Extract and concatenate 'Content' fields from the raw output, returning original text on failure.
+
+ Args:
+ text (`str` or `list[str]`):
+ Single text or batch of texts to parse from the output of `decode` with `return_format="raw"`.
+
+ Returns:
+ Extracted transcription(s). For single input, returns `str`.
+ For batch input, returns `list[str]`.
+ """
+ is_single = isinstance(text, str)
+ if is_single:
+ text = [text]
+
+ transcriptions = []
+ for t in text:
+ dict_output = self.extract_speaker_dict(t)
+
+ # If parsing failed, dict_output is the original string
+ if isinstance(dict_output, str):
+ transcriptions.append(dict_output)
+ else:
+ contents = [seg.get("Content", "") for seg in dict_output if isinstance(seg, dict)]
+ transcriptions.append(" ".join(contents).strip())
+
+ return transcriptions[0] if is_single else transcriptions
+
+
+__all__ = ["VibeVoiceAsrProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/__init__.py b/lib/python3.11/site-packages/transformers/models/video_llama_3/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..98a288550d36ad36376ee6503c8f87b7fb3be40b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llama_3/__init__.py
@@ -0,0 +1,31 @@
+# Copyright 2025 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_video_llama_3 import *
+ from .image_processing_pil_video_llama_3 import *
+ from .image_processing_video_llama_3 import *
+ from .modeling_video_llama_3 import *
+ from .processing_video_llama_3 import *
+ from .video_processing_video_llama_3 import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..213f91f2cc1ba1fabb708e710da951dace87be42
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/configuration_video_llama_3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/configuration_video_llama_3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fa191a94553f4660f1086daad33c0ca4b56cd7f3
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/configuration_video_llama_3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/image_processing_pil_video_llama_3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/image_processing_pil_video_llama_3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..559e59f2fc7ac0461459fb3249116a47580626a0
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/image_processing_pil_video_llama_3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/image_processing_video_llama_3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/image_processing_video_llama_3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7f06a1f2e276c3f8c6133599c3535e784b218d73
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/image_processing_video_llama_3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/modeling_video_llama_3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/modeling_video_llama_3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06b5083c73f12b2411b595169f2368a662d00886
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/modeling_video_llama_3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/modular_video_llama_3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/modular_video_llama_3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..afcf392e0db8f78efca3da870ba88bc89f3d03c3
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/modular_video_llama_3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/processing_video_llama_3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/processing_video_llama_3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e93714b99bf816c2f8d865abb8125ca2528a900
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/processing_video_llama_3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/video_processing_video_llama_3.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/video_processing_video_llama_3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e752b6f1e065380c5421dd58813089be341fffab
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llama_3/__pycache__/video_processing_video_llama_3.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/configuration_video_llama_3.py b/lib/python3.11/site-packages/transformers/models/video_llama_3/configuration_video_llama_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..55230680d477a31468bda588b00f74f328ded500
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llama_3/configuration_video_llama_3.py
@@ -0,0 +1,94 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/video_llama_3/modular_video_llama_3.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_video_llama_3.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import CONFIG_MAPPING, AutoConfig
+
+
+@auto_docstring(checkpoint="lkhl/VideoLLaMA3-2B-Image-HF")
+@strict
+class VideoLlama3VisionConfig(PreTrainedConfig):
+ r"""
+ Example:
+
+ ```python
+ >>> from transformers import VideoLlama3VisionConfig, VideoLlama3VisionModel
+
+ >>> # Initializing a VideoLlama3VisionConfig with google/video_llama_3-base-patch16-224 style configuration
+ >>> configuration = VideoLlama3VisionConfig()
+
+ >>> # Initializing a VideoLlama3VisionModel (with random weights) from the google/video_llama_3-base-patch16-224 style configuration
+ >>> model = VideoLlama3VisionModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "video_llama_3_vision"
+ base_config_key = "vision_config"
+
+ hidden_size: int = 768
+ intermediate_size: int = 3072
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ num_channels: int = 3
+ patch_size: int | list[int] | tuple[int, int] = 16
+ hidden_act: str = "gelu_pytorch_tanh"
+ layer_norm_eps: float = 1e-6
+ attention_dropout: float | int = 0.0
+ initializer_range: float = 0.02
+
+
+@auto_docstring(checkpoint="lkhl/VideoLLaMA3-2B-Image-HF")
+@strict
+class VideoLlama3Config(PreTrainedConfig):
+ model_type = "video_llama_3"
+ sub_configs = {"vision_config": VideoLlama3VisionConfig, "text_config": AutoConfig}
+ keys_to_ignore_at_inference = ["past_key_values"]
+
+ text_config: dict | PreTrainedConfig | None = None
+ vision_config: dict | PreTrainedConfig | None = None
+ image_token_id: int = 151655
+ video_token_id: int = 151656
+ tie_word_embeddings: bool = False
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.vision_config, dict):
+ self.vision_config = self.sub_configs["vision_config"](**self.vision_config)
+ elif self.vision_config is None:
+ self.vision_config = self.sub_configs["vision_config"]()
+
+ if isinstance(self.text_config, dict):
+ self.text_config = CONFIG_MAPPING[self.text_config["model_type"]](**self.text_config)
+ elif self.text_config is None:
+ self.text_config = CONFIG_MAPPING["qwen2"]()
+
+ # The default value is `False` but this config is used with many model types
+ # Attr `tie_word_embeddings` was saved in text config for those models, so we
+ # need an ugly workaround and forward-pass the attr from text config
+ if not self.tie_word_embeddings and self.text_config.tie_word_embeddings:
+ self.tie_word_embeddings = self.text_config.tie_word_embeddings
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["VideoLlama3VisionConfig", "VideoLlama3Config"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/image_processing_pil_video_llama_3.py b/lib/python3.11/site-packages/transformers/models/video_llama_3/image_processing_pil_video_llama_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..5272c7465b2bc5bf625ef868cae48cb797aecb64
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llama_3/image_processing_pil_video_llama_3.py
@@ -0,0 +1,263 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/video_llama_3/modular_video_llama_3.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_video_llama_3.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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 math
+from collections.abc import Iterable
+
+import numpy as np
+
+from ...feature_extraction_utils import BatchFeature
+from ...image_processing_backends import PilBackend
+from ...image_utils import IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ImageInput, PILImageResampling, SizeDict
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+class VideoLlama3ImageProcessorKwargs(ImagesKwargs, total=False):
+ r"""
+ min_pixels (`int`, *optional*, defaults to `56 * 56`):
+ The min pixels of the image to resize the image.
+ max_pixels (`int`, *optional*, defaults to `28 * 28 * 1280`):
+ The max pixels of the image to resize the image.
+ patch_size (`int`, *optional*, defaults to 14):
+ The spatial patch size of the vision encoder.
+ temporal_patch_size (`int`, *optional*, defaults to 2):
+ The temporal patch size of the vision encoder.
+ merge_size (`int`, *optional*, defaults to 2):
+ The merge size of the vision encoder to llm encoder.
+ """
+
+ min_pixels: int
+ max_pixels: int
+ patch_size: int
+ temporal_patch_size: int
+ merge_size: int
+
+
+def smart_resize(
+ height: int, width: int, factor: int = 28, min_pixels: int = 56 * 56, max_pixels: int = 14 * 14 * 4 * 1280
+):
+ """Rescales the image so that the following conditions are met:
+
+ 1. Both dimensions (height and width) are divisible by 'factor'.
+
+ 2. The total number of pixels is within the range ['min_pixels', 'max_pixels'].
+
+ 3. The aspect ratio of the image is maintained as closely as possible.
+
+ """
+ if max(height, width) / min(height, width) > 200:
+ raise ValueError(
+ f"absolute aspect ratio must be smaller than 200, got {max(height, width) / min(height, width)}"
+ )
+ h_bar = round(height / factor) * factor
+ w_bar = round(width / factor) * factor
+ if h_bar * w_bar > max_pixels:
+ beta = math.sqrt((height * width) / max_pixels)
+ h_bar = max(factor, math.floor(height / beta / factor) * factor)
+ w_bar = max(factor, math.floor(width / beta / factor) * factor)
+ elif h_bar * w_bar < min_pixels:
+ beta = math.sqrt(min_pixels / (height * width))
+ h_bar = math.ceil(height * beta / factor) * factor
+ w_bar = math.ceil(width * beta / factor) * factor
+ return h_bar, w_bar
+
+
+@auto_docstring
+class VideoLlama3ImageProcessorPil(PilBackend):
+ do_resize = True
+ resample = PILImageResampling.BICUBIC
+ size = {"shortest_edge": 56 * 56, "longest_edge": 28 * 28 * 1280}
+ default_to_square = False
+ do_rescale = True
+ do_normalize = True
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ do_convert_rgb = True
+ patch_size = 14
+ temporal_patch_size = 1
+ merge_size = 1
+ valid_kwargs = VideoLlama3ImageProcessorKwargs
+ model_input_names = [
+ "pixel_values",
+ "image_grid_thw",
+ "image_merge_sizes",
+ ]
+
+ def __init__(self, **kwargs: Unpack[VideoLlama3ImageProcessorKwargs]):
+ size = kwargs.pop("size", None)
+ min_pixels = kwargs.pop("min_pixels", None)
+ max_pixels = kwargs.pop("max_pixels", None)
+ # backward compatibility: override size with min_pixels and max_pixels if they are provided
+ size = self.size if size is None else size
+ if min_pixels is not None:
+ size["shortest_edge"] = min_pixels
+ size.pop("min_pixels", None)
+ if max_pixels is not None:
+ size["longest_edge"] = max_pixels
+ size.pop("max_pixels", None)
+ if "shortest_edge" not in size or "longest_edge" not in size:
+ raise ValueError("size must contain 'shortest_edge' and 'longest_edge' keys.")
+
+ super().__init__(size=size, **kwargs)
+
+ def _standardize_kwargs(
+ self,
+ size: int | Iterable[int] | dict[str, int] | SizeDict | None = None,
+ min_pixels: int | None = None,
+ max_pixels: int | None = None,
+ **kwargs,
+ ) -> dict:
+ if min_pixels is not None and max_pixels is not None:
+ size = SizeDict(shortest_edge=min_pixels, longest_edge=max_pixels)
+ kwargs = super()._standardize_kwargs(size=size, **kwargs)
+ size = kwargs.get("size", self.size)
+ if not size.shortest_edge or not size.longest_edge:
+ raise ValueError("size must contain 'shortest_edge' and 'longest_edge' keys.")
+ return kwargs
+
+ @auto_docstring
+ def preprocess(
+ self,
+ images: ImageInput,
+ **kwargs: Unpack[VideoLlama3ImageProcessorKwargs],
+ ) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def _preprocess(
+ self,
+ images: list[np.ndarray],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ patch_size: int,
+ temporal_patch_size: int,
+ merge_size: int,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ all_patches = []
+ all_grids = []
+
+ for image in images:
+ height, width = image.shape[-2:]
+ if do_resize:
+ resized_height, resized_width = smart_resize(
+ height,
+ width,
+ factor=patch_size * merge_size,
+ min_pixels=size.shortest_edge,
+ max_pixels=size.longest_edge,
+ )
+ image = self.resize(
+ image,
+ size=SizeDict(height=resized_height, width=resized_width),
+ resample=resample,
+ )
+ else:
+ resized_height, resized_width = height, width
+
+ if do_rescale:
+ image = self.rescale(image, rescale_factor)
+ if do_normalize:
+ image = self.normalize(image, image_mean, image_std)
+
+ patches = np.expand_dims(image, axis=0)
+ if patches.ndim == 4:
+ patches = np.expand_dims(patches, axis=1)
+ if patches.shape[1] % temporal_patch_size != 0:
+ repeats = np.repeat(
+ patches[:, -1:], temporal_patch_size - (patches.shape[1] % temporal_patch_size), axis=1
+ )
+ patches = np.concatenate([patches, repeats], axis=1)
+
+ batch_size, grid_t, channel = patches.shape[0], patches.shape[1] // temporal_patch_size, patches.shape[2]
+ grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
+
+ patches = patches.reshape(
+ batch_size,
+ grid_t,
+ temporal_patch_size,
+ channel,
+ grid_h // merge_size,
+ merge_size,
+ patch_size,
+ grid_w // merge_size,
+ merge_size,
+ patch_size,
+ )
+ patches = patches.transpose(0, 1, 4, 7, 5, 8, 3, 2, 6, 9)
+ flatten_patches = patches.reshape(
+ batch_size * grid_t * grid_h * grid_w,
+ channel * temporal_patch_size * patch_size * patch_size,
+ )
+
+ all_patches.append(flatten_patches)
+ all_grids.append([grid_t, grid_h, grid_w])
+
+ pixel_values = np.concatenate(all_patches, axis=0)
+ image_grid_thw = np.array(all_grids, dtype=np.int64)
+ image_merge_sizes = np.array([merge_size] * image_grid_thw.shape[0], dtype=np.int64)
+
+ return BatchFeature(
+ data={
+ "pixel_values": pixel_values,
+ "image_grid_thw": image_grid_thw,
+ "image_merge_sizes": image_merge_sizes,
+ },
+ tensor_type=return_tensors,
+ )
+
+ def get_number_of_image_patches(self, height: int, width: int, images_kwargs=None):
+ """
+ A utility that returns number of image patches for a given image size.
+
+ Note: Do not remove this method! It is used by vLLM to infer the number of patches and placeholders
+ without an image input.
+
+ Args:
+ height (`int`):
+ Height of the input image.
+ width (`int`):
+ Width of the input image.
+ images_kwargs (`dict`, *optional*)
+ Any kwargs to override defaults of the image processor.
+ Returns:
+ `int`: Number of image patches per image.
+ """
+ min_pixels = images_kwargs["min_pixels"] if "min_pixels" in images_kwargs else self.size["shortest_edge"]
+ max_pixels = images_kwargs["max_pixels"] if "max_pixels" in images_kwargs else self.size["longest_edge"]
+ patch_size = images_kwargs.get("patch_size", self.patch_size)
+ merge_size = images_kwargs.get("merge_size", self.merge_size)
+
+ factor = patch_size * merge_size
+ resized_height, resized_width = smart_resize(
+ height, width, factor, min_pixels=min_pixels, max_pixels=max_pixels
+ )
+ grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
+ return grid_h * grid_w
+
+
+__all__ = ["VideoLlama3ImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/image_processing_video_llama_3.py b/lib/python3.11/site-packages/transformers/models/video_llama_3/image_processing_video_llama_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..32f5e67f8a55bb0bcd1052ed51babe0d4b418133
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llama_3/image_processing_video_llama_3.py
@@ -0,0 +1,268 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/video_llama_3/modular_video_llama_3.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_video_llama_3.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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 math
+from collections.abc import Iterable
+
+import torch
+
+from ...feature_extraction_utils import BatchFeature
+from ...image_processing_backends import TorchvisionBackend
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ImageInput, PILImageResampling, SizeDict
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+class VideoLlama3ImageProcessorKwargs(ImagesKwargs, total=False):
+ r"""
+ min_pixels (`int`, *optional*, defaults to `56 * 56`):
+ The min pixels of the image to resize the image.
+ max_pixels (`int`, *optional*, defaults to `28 * 28 * 1280`):
+ The max pixels of the image to resize the image.
+ patch_size (`int`, *optional*, defaults to 14):
+ The spatial patch size of the vision encoder.
+ temporal_patch_size (`int`, *optional*, defaults to 2):
+ The temporal patch size of the vision encoder.
+ merge_size (`int`, *optional*, defaults to 2):
+ The merge size of the vision encoder to llm encoder.
+ """
+
+ min_pixels: int
+ max_pixels: int
+ patch_size: int
+ temporal_patch_size: int
+ merge_size: int
+
+
+def smart_resize(
+ height: int, width: int, factor: int = 28, min_pixels: int = 56 * 56, max_pixels: int = 14 * 14 * 4 * 1280
+):
+ """Rescales the image so that the following conditions are met:
+
+ 1. Both dimensions (height and width) are divisible by 'factor'.
+
+ 2. The total number of pixels is within the range ['min_pixels', 'max_pixels'].
+
+ 3. The aspect ratio of the image is maintained as closely as possible.
+
+ """
+ if max(height, width) / min(height, width) > 200:
+ raise ValueError(
+ f"absolute aspect ratio must be smaller than 200, got {max(height, width) / min(height, width)}"
+ )
+ h_bar = round(height / factor) * factor
+ w_bar = round(width / factor) * factor
+ if h_bar * w_bar > max_pixels:
+ beta = math.sqrt((height * width) / max_pixels)
+ h_bar = max(factor, math.floor(height / beta / factor) * factor)
+ w_bar = max(factor, math.floor(width / beta / factor) * factor)
+ elif h_bar * w_bar < min_pixels:
+ beta = math.sqrt(min_pixels / (height * width))
+ h_bar = math.ceil(height * beta / factor) * factor
+ w_bar = math.ceil(width * beta / factor) * factor
+ return h_bar, w_bar
+
+
+@auto_docstring
+class VideoLlama3ImageProcessor(TorchvisionBackend):
+ do_resize = True
+ resample = PILImageResampling.BICUBIC
+ size = {"shortest_edge": 56 * 56, "longest_edge": 28 * 28 * 1280}
+ default_to_square = False
+ do_rescale = True
+ do_normalize = True
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ do_convert_rgb = True
+ patch_size = 14
+ temporal_patch_size = 1
+ merge_size = 1
+ valid_kwargs = VideoLlama3ImageProcessorKwargs
+ model_input_names = [
+ "pixel_values",
+ "image_grid_thw",
+ "image_merge_sizes",
+ ]
+
+ def __init__(self, **kwargs: Unpack[VideoLlama3ImageProcessorKwargs]):
+ size = kwargs.pop("size", None)
+ min_pixels = kwargs.pop("min_pixels", None)
+ max_pixels = kwargs.pop("max_pixels", None)
+ # backward compatibility: override size with min_pixels and max_pixels if they are provided
+ size = self.size if size is None else size
+ if min_pixels is not None:
+ size["shortest_edge"] = min_pixels
+ size.pop("min_pixels", None)
+ if max_pixels is not None:
+ size["longest_edge"] = max_pixels
+ size.pop("max_pixels", None)
+ if "shortest_edge" not in size or "longest_edge" not in size:
+ raise ValueError("size must contain 'shortest_edge' and 'longest_edge' keys.")
+
+ super().__init__(size=size, **kwargs)
+
+ def _standardize_kwargs(
+ self,
+ size: int | Iterable[int] | dict[str, int] | SizeDict | None = None,
+ min_pixels: int | None = None,
+ max_pixels: int | None = None,
+ **kwargs,
+ ) -> dict:
+ if min_pixels is not None and max_pixels is not None:
+ size = SizeDict(shortest_edge=min_pixels, longest_edge=max_pixels)
+ kwargs = super()._standardize_kwargs(size=size, **kwargs)
+ size = kwargs.get("size", self.size)
+ if not size.shortest_edge or not size.longest_edge:
+ raise ValueError("size must contain 'shortest_edge' and 'longest_edge' keys.")
+ return kwargs
+
+ @auto_docstring
+ def preprocess(
+ self,
+ images: ImageInput,
+ **kwargs: Unpack[VideoLlama3ImageProcessorKwargs],
+ ) -> BatchFeature:
+ return super().preprocess(images, **kwargs)
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | int | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ patch_size: int,
+ temporal_patch_size: int,
+ merge_size: int,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+ resized_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ height, width = stacked_images.shape[-2:]
+ if do_resize:
+ resized_height, resized_width = smart_resize(
+ height,
+ width,
+ factor=patch_size * merge_size,
+ min_pixels=size.shortest_edge,
+ max_pixels=size.longest_edge,
+ )
+ stacked_images = self.resize(
+ image=stacked_images,
+ size=SizeDict(height=resized_height, width=resized_width),
+ resample=resample,
+ )
+ resized_images_grouped[shape] = stacked_images
+ resized_images = reorder_images(resized_images_grouped, grouped_images_index)
+
+ grouped_images, grouped_images_index = group_images_by_shape(resized_images, disable_grouping=disable_grouping)
+ processed_images_grouped = {}
+ processed_grids = {}
+ for shape, stacked_images in grouped_images.items():
+ resized_height, resized_width = stacked_images.shape[-2:]
+ patches = self.rescale_and_normalize(
+ stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ batch_size, channel = patches.shape[:2]
+ grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
+ patches = patches.reshape(
+ batch_size,
+ channel,
+ grid_h // merge_size,
+ merge_size,
+ patch_size,
+ grid_w // merge_size,
+ merge_size,
+ patch_size,
+ )
+ # Reorder dimensions to group grid and patch information for subsequent flattening.
+ # [batch, grid_h/merge, grid_w/merge, merge, merge, channel, patch, patch]
+ patches = patches.permute(0, 2, 5, 3, 6, 1, 4, 7)
+
+ flatten_patches = (
+ patches.unsqueeze(6)
+ .expand(-1, -1, -1, -1, -1, -1, temporal_patch_size, -1, -1)
+ .reshape(
+ batch_size,
+ grid_h * grid_w,
+ channel * temporal_patch_size * patch_size * patch_size,
+ )
+ )
+
+ processed_images_grouped[shape] = flatten_patches
+ processed_grids[shape] = [[1, grid_h, grid_w]] * batch_size
+
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index)
+ processed_grids_ordered = reorder_images(processed_grids, grouped_images_index)
+ pixel_values = torch.cat(processed_images, dim=0)
+ image_grid_thw = torch.tensor(processed_grids_ordered, dtype=torch.long)
+ image_merge_sizes = torch.tensor(
+ [merge_size] * image_grid_thw.size(0),
+ dtype=image_grid_thw.dtype,
+ device=image_grid_thw.device,
+ )
+
+ return BatchFeature(
+ data={
+ "pixel_values": pixel_values,
+ "image_grid_thw": image_grid_thw,
+ "image_merge_sizes": image_merge_sizes,
+ },
+ tensor_type=return_tensors,
+ )
+
+ def get_number_of_image_patches(self, height: int, width: int, images_kwargs=None):
+ """
+ A utility that returns number of image patches for a given image size.
+
+ Note: Do not remove this method! It is used by vLLM to infer the number of patches and placeholders
+ without an image input.
+
+ Args:
+ height (`int`):
+ Height of the input image.
+ width (`int`):
+ Width of the input image.
+ images_kwargs (`dict`, *optional*)
+ Any kwargs to override defaults of the image processor.
+ Returns:
+ `int`: Number of image patches per image.
+ """
+ min_pixels = images_kwargs["min_pixels"] if "min_pixels" in images_kwargs else self.size["shortest_edge"]
+ max_pixels = images_kwargs["max_pixels"] if "max_pixels" in images_kwargs else self.size["longest_edge"]
+ patch_size = images_kwargs.get("patch_size", self.patch_size)
+ merge_size = images_kwargs.get("merge_size", self.merge_size)
+
+ factor = patch_size * merge_size
+ resized_height, resized_width = smart_resize(
+ height, width, factor, min_pixels=min_pixels, max_pixels=max_pixels
+ )
+ grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
+ return grid_h * grid_w
+
+
+__all__ = ["VideoLlama3ImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/modeling_video_llama_3.py b/lib/python3.11/site-packages/transformers/models/video_llama_3/modeling_video_llama_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..b85d7efc2eded8c9cf8d0f6b45c1120aec9e754e
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llama_3/modeling_video_llama_3.py
@@ -0,0 +1,1088 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/video_llama_3/modular_video_llama_3.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_video_llama_3.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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 collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+import torch.nn as nn
+from torch.nn import LayerNorm
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache
+from ...generation import GenerationMixin
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling, ModelOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple, torch_compilable_check
+from ...utils.generic import accepts_precomputed_kwargs, is_flash_attention_requested, merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from ...vision_utils import get_vision_cu_seqlens, get_vision_position_ids
+from ..auto.modeling_auto import AutoModel
+from .configuration_video_llama_3 import VideoLlama3Config, VideoLlama3VisionConfig
+
+
+class VideoLlama3VisionRotaryEmbedding(nn.Module):
+ inv_freq: torch.Tensor # fix linting for `register_buffer`
+
+ def __init__(self, dim: int, theta: float = 10000.0) -> None:
+ super().__init__()
+ self.dim = dim
+ self.theta = theta
+ inv_freq = 1.0 / (theta ** (torch.arange(0, dim, 2, dtype=torch.float) / dim))
+ self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+ def forward(self, position_ids: torch.Tensor) -> torch.Tensor:
+ return (position_ids.unsqueeze(-1) * self.inv_freq).flatten(1)
+
+
+class VideoLlama3VisionEmbeddings(nn.Module):
+ def __init__(self, config: VideoLlama3VisionConfig) -> None:
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.patch_size = config.patch_size
+
+ self.patch_embedding = nn.Conv2d(
+ in_channels=config.num_channels,
+ out_channels=self.embed_dim,
+ kernel_size=self.patch_size,
+ stride=self.patch_size,
+ padding="valid",
+ )
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = hidden_states.view(-1, self.config.num_channels, self.patch_size, self.patch_size)
+ patch_embeds = self.patch_embedding(hidden_states)
+ embeddings = patch_embeds.view(-1, self.embed_dim)
+ return embeddings
+
+
+class VideoLlama3VisionMLP(nn.Module):
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.activation_fn = ACT2FN[config.hidden_act]
+ self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size)
+ self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.fc1(hidden_states)
+ hidden_states = self.activation_fn(hidden_states)
+ hidden_states = self.fc2(hidden_states)
+ return hidden_states
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float,
+ dropout: float = 0.0,
+ **kwargs,
+):
+ key_states = repeat_kv(key, module.num_key_value_groups)
+ value_states = repeat_kv(value, module.num_key_value_groups)
+
+ attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+ attn_output = torch.matmul(attn_weights, value_states)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+def rotate_half(x):
+ """Rotates half the hidden dims of the input."""
+ x1 = x[..., : x.shape[-1] // 2]
+ x2 = x[..., x.shape[-1] // 2 :]
+ return torch.cat((-x2, x1), dim=-1)
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+ """
+ This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+ num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+ """
+ batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+ if n_rep == 1:
+ return hidden_states
+ hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+ return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+def apply_rotary_pos_emb_vision(
+ q: torch.Tensor, k: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor
+) -> tuple[torch.Tensor, torch.Tensor]:
+ orig_q_dtype = q.dtype
+ orig_k_dtype = k.dtype
+ q, k = q.float(), k.float()
+ cos, sin = cos.unsqueeze(-2).float(), sin.unsqueeze(-2).float()
+ q_embed = (q * cos) + (rotate_half(q) * sin)
+ k_embed = (k * cos) + (rotate_half(k) * sin)
+ q_embed = q_embed.to(orig_q_dtype)
+ k_embed = k_embed.to(orig_k_dtype)
+ return q_embed, k_embed
+
+
+class VideoLlama3VisionAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.num_heads = config.num_attention_heads
+ self.head_dim = self.embed_dim // self.num_heads
+ if self.head_dim * self.num_heads != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+ f" {self.num_heads})."
+ )
+ self.is_causal = False
+
+ self.k_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.v_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.q_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.out_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.num_key_value_groups = 1
+ self.scaling = self.head_dim**-0.5
+ self.attention_dropout = config.attention_dropout
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ cu_seqlens: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ """
+ Args:
+ hidden_states (`torch.Tensor`):
+ Input to the layer of shape `(seq_len, embed_dim)`.
+ cu_seqlens (`torch.Tensor` of shape `(num_images_or_videos + 1,)`):
+ The cumulative sequence lengths of each image or video feature.
+ position_embeddings (`tuple(torch.Tensor, torch.Tensor)` of shape `(num_patches, head_dim // 2)`):
+ The cosine and sine position embeddings for vision attention.
+ """
+ seq_length = hidden_states.shape[0]
+ query_states = self.q_proj(hidden_states).view(seq_length, self.num_heads, self.head_dim)
+ key_states = self.k_proj(hidden_states).view(seq_length, self.num_heads, self.head_dim)
+ value_states = self.v_proj(hidden_states).view(seq_length, self.num_heads, self.head_dim)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb_vision(query_states, key_states, cos, sin)
+
+ query_states = query_states.transpose(0, 1).unsqueeze(0)
+ key_states = key_states.transpose(0, 1).unsqueeze(0)
+ value_states = value_states.transpose(0, 1).unsqueeze(0)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ if is_flash_attention_requested(self.config):
+ # Flash Attention 2: Use cu_seqlens for variable length attention
+ max_seqlen = (cu_seqlens[1:] - cu_seqlens[:-1]).max()
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask=None,
+ scaling=self.scaling,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ cu_seq_lens_q=cu_seqlens,
+ cu_seq_lens_k=cu_seqlens,
+ max_length_q=max_seqlen,
+ max_length_k=max_seqlen,
+ is_causal=False,
+ **kwargs,
+ )
+ else:
+ # Other implementations: Process each chunk separately
+ lengths = cu_seqlens[1:] - cu_seqlens[:-1]
+ splits = [
+ torch.split(tensor, lengths.tolist(), dim=2) for tensor in (query_states, key_states, value_states)
+ ]
+
+ attn_outputs, attn_weights = [], []
+ for q, k, v in zip(*splits):
+ attn_output, attn_weight = attention_interface(
+ self,
+ q,
+ k,
+ v,
+ attention_mask=None,
+ scaling=self.scaling,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ is_causal=False,
+ **kwargs,
+ )
+ attn_outputs.append(attn_output)
+ attn_weights.append(attn_weight)
+
+ attn_output = torch.cat(attn_outputs, dim=1)
+
+ attn_output = attn_output.reshape(seq_length, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+class VideoLlama3VisionEncoderLayer(GradientCheckpointingLayer):
+ def __init__(self, config: VideoLlama3VisionConfig):
+ super().__init__()
+ self.embed_dim = config.hidden_size
+ self.layer_norm1 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+ self.self_attn = VideoLlama3VisionAttention(config=config)
+ self.layer_norm2 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+ self.mlp = VideoLlama3VisionMLP(config=config)
+
+ @auto_docstring
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ cu_seqlens: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ r"""
+ cu_seqlens (`torch.Tensor` of shape `(num_images_or_videos + 1,)`):
+ The cumulative sequence lengths of each image or video feature.
+ position_embeddings (`tuple(torch.Tensor, torch.Tensor)` of shape `(num_patches, head_dim // 2)`):
+ The cosine and sine position embeddings for vision attention.
+ """
+ residual = hidden_states
+
+ hidden_states = self.layer_norm1(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states,
+ cu_seqlens=cu_seqlens,
+ position_embeddings=position_embeddings,
+ **kwargs,
+ )
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.layer_norm2(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = residual + hidden_states
+
+ return hidden_states
+
+
+class VideoLlama3VisionEncoder(nn.Module):
+ """
+ Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
+ [`VideoLlama3VisionEncoderLayer`].
+
+ Args:
+ config: VideoLlama3VisionConfig
+ """
+
+ def __init__(self, config: VideoLlama3VisionConfig):
+ super().__init__()
+ self.config = config
+ self.layers = nn.ModuleList([VideoLlama3VisionEncoderLayer(config) for _ in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ # Ignore copy
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ cu_seqlens: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutput:
+ r"""
+ cu_seqlens (`torch.Tensor` of shape `(num_images_or_videos + 1,)`):
+ The cumulative sequence lengths of each image or video feature.
+ position_embeddings (`tuple(torch.Tensor, torch.Tensor)` of shape `(num_patches, head_dim // 2)`):
+ The cosine and sine position embeddings for vision attention.
+ """
+ for encoder_layer in self.layers:
+ hidden_states = encoder_layer(
+ hidden_states,
+ cu_seqlens=cu_seqlens,
+ position_embeddings=position_embeddings,
+ **kwargs,
+ )
+
+ return BaseModelOutput(last_hidden_state=hidden_states)
+
+
+@auto_docstring
+class VideoLlama3PreTrainedModel(PreTrainedModel):
+ config: VideoLlama3Config
+ base_model_prefix = "model"
+ input_modalities = ("image", "video", "text")
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["VideoLlama3VisionEncoderLayer"]
+ _skip_keys_device_placement = ["past_key_values"]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+
+ _can_compile_fullgraph = True
+ _supports_attention_backend = True
+
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ if isinstance(module, VideoLlama3VisionRotaryEmbedding):
+ inv_freq = 1.0 / (module.theta ** (torch.arange(0, module.dim, 2, dtype=torch.float) / module.dim))
+ init.copy_(module.inv_freq, inv_freq)
+
+
+class VideoLlama3VisionModel(VideoLlama3PreTrainedModel):
+ config: VideoLlama3VisionConfig
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ _can_record_outputs = {
+ "hidden_states": VideoLlama3VisionEncoderLayer,
+ "attentions": VideoLlama3VisionAttention,
+ }
+
+ def __init__(self, config: VideoLlama3VisionConfig):
+ super().__init__(config)
+ head_dim = config.hidden_size // config.num_attention_heads
+
+ self.rotary_pos_emb = VideoLlama3VisionRotaryEmbedding(head_dim // 2)
+ self.embeddings = VideoLlama3VisionEmbeddings(config)
+ self.encoder = VideoLlama3VisionEncoder(config)
+ self.post_layernorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ self.post_init()
+
+ def get_input_embeddings(self) -> VideoLlama3VisionEmbeddings:
+ return self.embeddings.patch_embedding
+
+ def pixel_unshuffle(
+ self,
+ hidden_states: torch.Tensor,
+ grid_thw: torch.Tensor,
+ merge_sizes: torch.Tensor,
+ ):
+ hidden_states_chunks = hidden_states.split(grid_thw.prod(dim=1).tolist(), dim=0)
+ outputs = []
+
+ for hidden_states, (t, h, w), merge_size in zip(hidden_states_chunks, grid_thw, merge_sizes):
+ c = hidden_states.shape[-1]
+ hidden_states = hidden_states.view(t, h // merge_size, w // merge_size, merge_size, merge_size, c).permute(
+ 0, 1, 3, 2, 4, 5
+ )
+ hidden_states = hidden_states.reshape(t, h, w, c).permute(0, 3, 1, 2)
+ hidden_states = torch.nn.functional.interpolate(
+ hidden_states, size=(h // merge_size, w // merge_size), mode="bilinear"
+ )
+ hidden_states = hidden_states.permute(0, 2, 3, 1).view(-1, c)
+ outputs.append(hidden_states)
+
+ return torch.cat(outputs, dim=0)
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor,
+ grid_thw: torch.Tensor,
+ merge_sizes: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutput:
+ r"""
+ grid_thw (`torch.LongTensor` of shape `(num_images_or_videos, 3)`):
+ The temporal, height and width dimensions of feature shape for each image. Each row contains [t, h, w] values.
+ merge_sizes (`torch.Tensor` of shape `(num_images_or_videos,)`):
+ The spatial downsampling ratio of each image or video feature.
+ """
+ position_ids = get_vision_position_ids(grid_thw, merge_sizes, kwargs=kwargs)
+ cu_seqlens = get_vision_cu_seqlens(grid_thw, kwargs=kwargs)
+
+ hidden_states = self.embeddings(pixel_values.type(self.dtype))
+ rotary_pos_emb = self.rotary_pos_emb(position_ids)
+ emb = torch.cat((rotary_pos_emb, rotary_pos_emb), dim=-1)
+ position_embeddings = (emb.cos(), emb.sin())
+
+ encoder_outputs: BaseModelOutput = self.encoder(
+ hidden_states,
+ cu_seqlens=cu_seqlens,
+ position_embeddings=position_embeddings,
+ **kwargs,
+ )
+
+ last_hidden_state = encoder_outputs[0]
+ last_hidden_state = self.post_layernorm(last_hidden_state)
+ last_hidden_state = self.pixel_unshuffle(last_hidden_state, grid_thw, merge_sizes)
+
+ return BaseModelOutput(last_hidden_state=last_hidden_state)
+
+
+class VideoLlama3Projector(nn.Module):
+ def __init__(self, config: VideoLlama3Config) -> None:
+ super().__init__()
+ in_hidden_size = config.vision_config.hidden_size
+ out_hidden_size = config.text_config.hidden_size
+ self.readout = nn.Sequential(
+ nn.Linear(in_hidden_size, out_hidden_size),
+ nn.GELU(),
+ nn.Linear(out_hidden_size, out_hidden_size),
+ )
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.readout(hidden_states)
+ return hidden_states
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for VideoLLaMA3 outputs, with hidden states and attentions.
+ """
+)
+@dataclass
+class VideoLlama3ModelOutputWithPast(ModelOutput):
+ r"""
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
+ `(batch_size, num_heads, sequence_length, embed_size_per_head)`)
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
+ `past_key_values` input) to speed up sequential decoding.
+ image_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(num_images_features, hidden_size)`.
+ image_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ video_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(num_video_features, hidden_size)`.
+ video_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ """
+
+ last_hidden_state: torch.FloatTensor = None
+ past_key_values: list[torch.FloatTensor] | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+ image_hidden_states: torch.FloatTensor | None = None
+ video_hidden_states: torch.FloatTensor | None = None
+
+
+@auto_docstring
+class VideoLlama3Model(VideoLlama3PreTrainedModel):
+ base_model_prefix = "model"
+ # Reference: fix gemma3 grad acc #37208
+ accepts_loss_kwargs = False
+ _can_compile_fullgraph = False
+
+ def __init__(self, config: VideoLlama3Config):
+ super().__init__(config)
+ self.vision_model = AutoModel.from_config(config.vision_config)
+ self.projector = VideoLlama3Projector(config)
+ self.language_model = AutoModel.from_config(config.text_config)
+
+ self.post_init()
+
+ @accepts_precomputed_kwargs(modality="video")
+ @can_return_tuple
+ @auto_docstring
+ def get_video_features(
+ self,
+ pixel_values_videos: torch.FloatTensor,
+ video_grid_thw: torch.LongTensor,
+ video_merge_sizes: torch.LongTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values_videos (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input videos.
+ video_grid_thw (`torch.LongTensor` of shape `(num_videos, 3)`, *optional*):
+ The temporal, height and width of feature shape of each video in LLM.
+ video_merge_sizes (`torch.Tensor` of shape `(num_videos,)`):
+ The spatial downsampling ratio of each video feature.
+ """
+ return self.get_image_features(
+ pixel_values=pixel_values_videos,
+ image_grid_thw=video_grid_thw,
+ image_merge_sizes=video_merge_sizes,
+ **kwargs,
+ )
+
+ @accepts_precomputed_kwargs(modality="image")
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self,
+ pixel_values: torch.FloatTensor,
+ image_grid_thw: torch.LongTensor,
+ image_merge_sizes: torch.LongTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input images.
+ image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+ The temporal, height and width of feature shape of each image in LLM.
+ image_merge_sizes (`torch.Tensor` of shape `(num_images,)`):
+ The spatial downsampling ratio of each image feature.
+ """
+ vision_outputs = self.vision_model(
+ pixel_values=pixel_values,
+ grid_thw=image_grid_thw,
+ merge_sizes=image_merge_sizes,
+ return_dict=True,
+ **kwargs,
+ )
+ last_hidden_state = vision_outputs.last_hidden_state
+ image_embeds = self.projector(last_hidden_state)
+
+ split_sizes = image_grid_thw.prod(dim=1) // (image_merge_sizes**2)
+ image_embeds = torch.split(image_embeds, split_sizes.tolist())
+ vision_outputs.pooler_output = image_embeds
+
+ return vision_outputs
+
+ def get_placeholder_mask(
+ self,
+ input_ids: torch.LongTensor,
+ inputs_embeds: torch.FloatTensor,
+ image_features: torch.FloatTensor | None = None,
+ video_features: torch.FloatTensor | None = None,
+ ):
+ """
+ Obtains multimodal placeholder mask from `input_ids` or `inputs_embeds`, and checks that the placeholder token count is
+ equal to the length of multimodal features. If the lengths are different, an error is raised.
+ """
+ if input_ids is None:
+ special_image_mask = inputs_embeds == self.get_input_embeddings()(
+ torch.tensor(self.config.image_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ special_image_mask = special_image_mask.all(-1)
+ special_video_mask = inputs_embeds == self.get_input_embeddings()(
+ torch.tensor(self.config.video_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ special_video_mask = special_video_mask.all(-1)
+ else:
+ special_image_mask = input_ids == self.config.image_token_id
+ special_video_mask = input_ids == self.config.video_token_id
+
+ n_image_tokens = special_image_mask.sum()
+ special_image_mask = special_image_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+ if image_features is not None:
+ torch_compilable_check(
+ inputs_embeds[special_image_mask].numel() == image_features.numel(),
+ f"Image features and image tokens do not match, tokens: {n_image_tokens}, features: {image_features.shape[0]}",
+ )
+
+ n_video_tokens = special_video_mask.sum()
+ special_video_mask = special_video_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+ if video_features is not None:
+ torch_compilable_check(
+ inputs_embeds[special_video_mask].numel() == video_features.numel(),
+ f"Video features and video tokens do not match, tokens: {n_video_tokens}, features: {video_features.shape[0]}",
+ )
+ return special_image_mask, special_video_mask
+
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ pixel_values: torch.Tensor | None = None,
+ image_grid_thw: torch.LongTensor | None = None,
+ image_merge_sizes: torch.LongTensor | None = None,
+ pixel_values_videos: torch.FloatTensor | None = None,
+ video_grid_thw: torch.LongTensor | None = None,
+ video_merge_sizes: torch.LongTensor | None = None,
+ video_compression_mask: torch.BoolTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | VideoLlama3ModelOutputWithPast:
+ r"""
+ image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+ The temporal, height and width of feature shape of each image in LLM.
+ image_merge_sizes (`torch.Tensor` of shape `(num_images,)`):
+ The spatial downsampling ratio of each image feature.
+ video_grid_thw (`torch.Tensor` of shape `(num_videos, 3)`):
+ The temporal, height and width of feature shape of each video before vision encoder.
+ video_merge_sizes (`torch.Tensor` of shape `(num_videos,)`):
+ The spatial downsampling ratio of each video feature.
+ video_compression_mask (`torch.BoolTensor` of shape `(num_video_features,)`, *optional*):
+ The mask to indicate which video features are kept after token compression.
+ """
+
+ if inputs_embeds is None:
+ inputs_embeds = self.get_input_embeddings()(input_ids)
+
+ image_embeds = None
+ if pixel_values is not None:
+ image_embeds = self.get_image_features(
+ pixel_values, image_grid_thw, image_merge_sizes, return_dict=True, **kwargs
+ ).pooler_output
+ image_embeds = torch.cat(image_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+ image_mask, _ = self.get_placeholder_mask(
+ input_ids, inputs_embeds=inputs_embeds, image_features=image_embeds
+ )
+ inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+
+ video_embeds = None
+ if pixel_values_videos is not None:
+ video_embeds = self.get_video_features(
+ pixel_values_videos, video_grid_thw, video_merge_sizes, return_dict=True, **kwargs
+ ).pooler_output
+ video_embeds = torch.cat(video_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+ if video_compression_mask is not None:
+ video_embeds = video_embeds[video_compression_mask.to(video_embeds.device)]
+ _, video_mask = self.get_placeholder_mask(
+ input_ids, inputs_embeds=inputs_embeds, video_features=video_embeds
+ )
+ inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+ outputs = self.language_model(
+ input_ids=None,
+ position_ids=position_ids,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return VideoLlama3ModelOutputWithPast(
+ last_hidden_state=outputs.last_hidden_state,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ image_hidden_states=image_embeds,
+ video_hidden_states=video_embeds,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for VideoLLaMA3 causal language model (or autoregressive) outputs.
+ """
+)
+@dataclass
+class VideoLlama3CausalLMOutputWithPast(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+ Language modeling loss (for next-token prediction).
+ logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
+ Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
+ `(batch_size, num_heads, sequence_length, embed_size_per_head)`)
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
+ `past_key_values` input) to speed up sequential decoding.
+ image_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(num_images_features, hidden_size)`.
+ image_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ video_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(num_video_features, hidden_size)`.
+ video_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ past_key_values: list[torch.FloatTensor] | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+ image_hidden_states: torch.FloatTensor | None = None
+ video_hidden_states: torch.FloatTensor | None = None
+
+
+class VideoLlama3ForConditionalGeneration(VideoLlama3PreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"lm_head.weight": "model.language_model.embed_tokens.weight"}
+ _can_compile_fullgraph = False
+
+ def __init__(self, config: VideoLlama3Config):
+ super().__init__(config)
+ self.model = VideoLlama3Model(config)
+ self.lm_head = nn.Linear(config.text_config.hidden_size, config.text_config.vocab_size, bias=False)
+
+ self.post_init()
+
+ @auto_docstring
+ def get_video_features(
+ self,
+ pixel_values_videos: torch.FloatTensor,
+ video_grid_thw: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values_videos (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input videos.
+ video_grid_thw (`torch.LongTensor` of shape `(num_videos, 3)`, *optional*):
+ The temporal, height and width of feature shape of each video in LLM.
+ """
+ return self.model.get_video_features(pixel_values_videos, video_grid_thw, **kwargs)
+
+ @auto_docstring
+ def get_image_features(
+ self,
+ pixel_values: torch.FloatTensor,
+ image_grid_thw: torch.LongTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input images.
+ image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+ The temporal, height and width of feature shape of each image in LLM.
+ """
+ return self.model.get_image_features(pixel_values, image_grid_thw, **kwargs)
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ pixel_values: torch.Tensor | None = None,
+ image_grid_thw: torch.LongTensor | None = None,
+ image_merge_sizes: torch.LongTensor | None = None,
+ pixel_values_videos: torch.FloatTensor | None = None,
+ video_grid_thw: torch.LongTensor | None = None,
+ video_merge_sizes: torch.LongTensor | None = None,
+ video_compression_mask: torch.BoolTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | VideoLlama3CausalLMOutputWithPast:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+ image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+ The temporal, height and width of feature shape of each image in LLM.
+ image_merge_sizes (`torch.Tensor` of shape `(num_images,)`):
+ The spatial downsampling ratio of each image feature.
+ video_grid_thw (`torch.Tensor` of shape `(num_videos, 3)`):
+ The temporal, height and width of feature shape of each video before vision encoder.
+ video_merge_sizes (`torch.Tensor` of shape `(num_videos,)`):
+ The spatial downsampling ratio of each video feature.
+ video_compression_mask (`torch.BoolTensor` of shape `(num_video_features,)`, *optional*):
+ The mask to indicate which video features are kept after token compression.
+ """
+
+ outputs = self.model(
+ input_ids=input_ids,
+ pixel_values=pixel_values,
+ image_grid_thw=image_grid_thw,
+ image_merge_sizes=image_merge_sizes,
+ pixel_values_videos=pixel_values_videos,
+ video_grid_thw=video_grid_thw,
+ video_merge_sizes=video_merge_sizes,
+ video_compression_mask=video_compression_mask,
+ position_ids=position_ids,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ return_dict=True,
+ **kwargs,
+ )
+
+ hidden_states = outputs[0]
+ logits = self.lm_head(hidden_states)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(
+ logits=logits, labels=labels, vocab_size=self.config.text_config.vocab_size, **kwargs
+ )
+
+ return VideoLlama3CausalLMOutputWithPast(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ image_hidden_states=outputs.image_hidden_states,
+ video_hidden_states=outputs.video_hidden_states,
+ )
+
+ def prepare_inputs_for_generation(
+ self,
+ input_ids,
+ past_key_values=None,
+ attention_mask=None,
+ inputs_embeds=None,
+ position_ids=None,
+ use_cache=True,
+ pixel_values: torch.Tensor | None = None,
+ image_grid_thw: torch.LongTensor | None = None,
+ image_merge_sizes: torch.LongTensor | None = None,
+ pixel_values_videos: torch.FloatTensor | None = None,
+ video_grid_thw: torch.LongTensor | None = None,
+ video_merge_sizes: torch.LongTensor | None = None,
+ video_compression_mask: torch.BoolTensor | None = None,
+ is_first_iteration: bool | None = False,
+ **kwargs,
+ ):
+ # Overwritten -- in specific circumstances we don't want to forward image inputs to the model
+
+ model_inputs = super().prepare_inputs_for_generation(
+ input_ids,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ position_ids=position_ids,
+ pixel_values=pixel_values,
+ image_grid_thw=image_grid_thw,
+ image_merge_sizes=image_merge_sizes,
+ pixel_values_videos=pixel_values_videos,
+ video_grid_thw=video_grid_thw,
+ video_merge_sizes=video_merge_sizes,
+ video_compression_mask=video_compression_mask,
+ use_cache=use_cache,
+ is_first_iteration=is_first_iteration,
+ **kwargs,
+ )
+
+ if not is_first_iteration and use_cache:
+ model_inputs["pixel_values"] = None
+ model_inputs["pixel_values_videos"] = None
+
+ return model_inputs
+
+ def _get_image_nums_and_video_nums(
+ self,
+ input_ids: torch.LongTensor | None,
+ inputs_embeds: torch.Tensor | None = None,
+ image_grid_thw: torch.LongTensor | None = None,
+ image_merge_sizes: torch.LongTensor | None = None,
+ video_grid_thw: torch.LongTensor | None = None,
+ video_merge_sizes: torch.LongTensor | None = None,
+ video_compression_mask: torch.BoolTensor | None = None,
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ """
+ Get the number of images and videos for each sample to calculate the separation length of the sample tensor.
+ These parameters are not passed through the processor to avoid unpredictable impacts from interface modifications.
+
+ Args:
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary.
+
+ Returns:
+ image_nums (`torch.LongTensor` of shape `(batch_size, num_images_sample)`)
+ video_nums (`torch.LongTensor` of shape `(batch_size, num_videos_sample)`)
+ """
+ image_token_id = self.config.image_token_id
+ video_token_id = self.config.video_token_id
+
+ if inputs_embeds is not None:
+ image_mask = (
+ inputs_embeds
+ == self.get_input_embeddings()(
+ torch.tensor(image_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ )[..., 0]
+ video_mask = (
+ inputs_embeds
+ == self.get_input_embeddings()(
+ torch.tensor(video_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ )[..., 0]
+ else:
+ image_mask = input_ids == image_token_id
+ video_mask = input_ids == video_token_id
+
+ if image_grid_thw is not None:
+ num_image_features = image_grid_thw.prod(dim=1) // (image_merge_sizes**2)
+ else:
+ num_image_features = []
+
+ if video_grid_thw is not None:
+ num_video_features = video_grid_thw.prod(dim=1) // (video_merge_sizes**2)
+ if video_compression_mask is not None:
+ num_video_features = video_compression_mask.split(num_video_features.tolist())
+ num_video_features = [mask.sum() for mask in num_video_features]
+ else:
+ num_video_features = []
+
+ image_nums, video_nums = [], []
+ start_image_idx, start_video_idx = 0, 0
+
+ for num_image_tokens, num_video_tokens in zip(image_mask.sum(dim=1), video_mask.sum(dim=1)):
+ cu_num_features = 0
+ image_idx = start_image_idx
+ while image_idx < len(num_image_features) and cu_num_features < num_image_tokens:
+ cu_num_features += num_image_features[image_idx]
+ image_idx += 1
+ assert cu_num_features == num_image_tokens, (
+ "The number of image tokens does not match the number of image features."
+ )
+ image_nums.append(image_idx - start_image_idx)
+ start_image_idx = image_idx
+
+ cu_num_features = 0
+ video_idx = start_video_idx
+ while video_idx < len(num_video_features) and cu_num_features < num_video_tokens:
+ cu_num_features += num_video_features[video_idx]
+ video_idx += 1
+ assert cu_num_features == num_video_tokens, (
+ "The number of video tokens does not match the number of video features."
+ )
+ video_nums.append(video_idx - start_video_idx)
+ start_video_idx = video_idx
+
+ return image_nums, video_nums
+
+ def _expand_inputs_for_generation(
+ self,
+ expand_size: int = 1,
+ is_encoder_decoder: bool = False,
+ input_ids: torch.LongTensor | None = None,
+ **model_kwargs,
+ ) -> tuple[torch.LongTensor, dict[str, Any]]:
+ # Overwritten -- Support for expanding tensors without a batch size dimension
+ # e.g., pixel_values, image_grid_thw, pixel_values_videos, video_grid_thw, second_per_grid_t
+ # pixel_values.shape[0] is sum(seqlen_images for samples)
+ # image_grid_thw.shape[0] is sum(num_images for samples)
+
+ if expand_size == 1:
+ return input_ids, model_kwargs
+
+ visual_keys = [
+ "pixel_values",
+ "image_grid_thw",
+ "image_merge_sizes",
+ "pixel_values_videos",
+ "video_grid_thw",
+ "video_merge_sizes",
+ "video_compression_mask",
+ ]
+
+ def _repeat_interleave_samples(x, lengths, repeat_times):
+ samples = torch.split(x, lengths)
+ repeat_args = [repeat_times] + [1] * (x.dim() - 1)
+ result = torch.cat([sample.repeat(*repeat_args) for sample in samples], dim=0)
+ return result
+
+ def _expand_dict_for_generation_visual(dict_to_expand):
+ image_grid_thw = model_kwargs.get("image_grid_thw", None)
+ video_grid_thw = model_kwargs.get("video_grid_thw", None)
+ video_merge_sizes = model_kwargs.get("video_merge_sizes", None)
+ video_compression_mask = model_kwargs.get("video_compression_mask", None)
+
+ image_nums, video_nums = self._get_image_nums_and_video_nums(
+ input_ids,
+ inputs_embeds=model_kwargs.get("inputs_embeds", None),
+ image_grid_thw=image_grid_thw,
+ image_merge_sizes=model_kwargs.get("image_merge_sizes", None),
+ video_grid_thw=video_grid_thw,
+ video_merge_sizes=video_merge_sizes,
+ video_compression_mask=video_compression_mask,
+ )
+ for key in dict_to_expand:
+ if key == "pixel_values":
+ # split images into samples
+ samples = torch.split(image_grid_thw, list(image_nums))
+ # compute the sequence length of images for each sample
+ lengths = [torch.prod(sample, dim=1).sum() for sample in samples]
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "image_grid_thw":
+ # get the num of images for each sample
+ lengths = list(image_nums)
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "image_merge_sizes":
+ lengths = list(image_nums)
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "pixel_values_videos":
+ samples = torch.split(video_grid_thw, list(video_nums))
+ lengths = [torch.prod(sample, dim=1).sum() for sample in samples]
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "video_compression_mask":
+ samples = torch.split(video_grid_thw, list(video_nums))
+ merge_sizes = torch.split(video_merge_sizes, list(video_nums))
+ lengths = [
+ (torch.prod(sample, dim=1) // merge_size**2).sum()
+ for sample, merge_size in zip(samples, merge_sizes)
+ ]
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "video_grid_thw":
+ lengths = list(video_nums)
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "video_merge_sizes":
+ lengths = list(video_nums)
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+
+ return dict_to_expand
+
+ def _expand_dict_for_generation(dict_to_expand):
+ for key in dict_to_expand:
+ if (
+ dict_to_expand[key] is not None
+ and isinstance(dict_to_expand[key], torch.Tensor)
+ and key not in visual_keys
+ ):
+ dict_to_expand[key] = dict_to_expand[key].repeat_interleave(expand_size, dim=0)
+ return dict_to_expand
+
+ model_kwargs = _expand_dict_for_generation_visual(model_kwargs)
+
+ if input_ids is not None:
+ input_ids = input_ids.repeat_interleave(expand_size, dim=0)
+
+ model_kwargs = _expand_dict_for_generation(model_kwargs)
+
+ if is_encoder_decoder:
+ if model_kwargs.get("encoder_outputs") is None:
+ raise ValueError("If `is_encoder_decoder` is True, make sure that `encoder_outputs` is defined.")
+ model_kwargs["encoder_outputs"] = _expand_dict_for_generation(model_kwargs["encoder_outputs"])
+
+ return input_ids, model_kwargs
+
+
+__all__ = [
+ "VideoLlama3VisionModel",
+ "VideoLlama3PreTrainedModel",
+ "VideoLlama3Model",
+ "VideoLlama3ForConditionalGeneration",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/modular_video_llama_3.py b/lib/python3.11/site-packages/transformers/models/video_llama_3/modular_video_llama_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..2790b17a08b9217af6c87c5543f317bb8a4ffc5e
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llama_3/modular_video_llama_3.py
@@ -0,0 +1,1482 @@
+# Copyright 2025 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 collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Optional
+
+import numpy as np
+import torch
+import torch.nn as nn
+from huggingface_hub.dataclasses import strict
+from torch.nn import LayerNorm
+
+from ... import initialization as init
+from ...cache_utils import Cache
+from ...configuration_utils import PreTrainedConfig
+from ...feature_extraction_utils import BatchFeature
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ChannelDimension,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+ get_image_size,
+)
+from ...modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling, ModelOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...tokenization_utils_base import PreTokenizedInput, TextInput
+from ...utils import (
+ TensorType,
+ auto_docstring,
+ can_return_tuple,
+ logging,
+)
+from ...utils.generic import accepts_precomputed_kwargs, is_flash_attention_requested, merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from ...video_utils import (
+ VideoInput,
+ group_videos_by_shape,
+ reorder_videos,
+)
+from ...vision_utils import get_vision_cu_seqlens, get_vision_position_ids
+from ..auto import CONFIG_MAPPING, AutoConfig
+from ..auto.modeling_auto import AutoModel
+from ..qwen2_vl.image_processing_pil_qwen2_vl import Qwen2VLImageProcessorPil
+from ..qwen2_vl.image_processing_qwen2_vl import Qwen2VLImageProcessor, Qwen2VLImageProcessorKwargs, smart_resize
+from ..qwen2_vl.modeling_qwen2_vl import (
+ Qwen2VLForConditionalGeneration,
+ Qwen2VLModel,
+ Qwen2VLPreTrainedModel,
+ TransformersKwargs,
+ VisionRotaryEmbedding,
+ apply_rotary_pos_emb_vision,
+ eager_attention_forward,
+)
+from ..qwen2_vl.processing_qwen2_vl import (
+ Qwen2VLProcessor,
+ Qwen2VLProcessorKwargs,
+)
+from ..qwen2_vl.video_processing_qwen2_vl import (
+ Qwen2VLVideoProcessor,
+ Qwen2VLVideoProcessorInitKwargs,
+)
+from ..siglip.configuration_siglip import SiglipVisionConfig
+from ..siglip.modeling_siglip import (
+ SiglipAttention,
+ SiglipEncoder,
+ SiglipEncoderLayer,
+ SiglipMLP,
+)
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="lkhl/VideoLLaMA3-2B-Image-HF")
+@strict
+class VideoLlama3VisionConfig(SiglipVisionConfig):
+ model_type = "video_llama_3_vision"
+ base_config_key = "vision_config"
+ image_size = AttributeError()
+ initializer_range: float = 0.02
+
+
+@auto_docstring(checkpoint="lkhl/VideoLLaMA3-2B-Image-HF")
+@strict
+class VideoLlama3Config(PreTrainedConfig):
+ model_type = "video_llama_3"
+ sub_configs = {"vision_config": VideoLlama3VisionConfig, "text_config": AutoConfig}
+ keys_to_ignore_at_inference = ["past_key_values"]
+
+ text_config: dict | PreTrainedConfig | None = None
+ vision_config: dict | PreTrainedConfig | None = None
+ image_token_id: int = 151655
+ video_token_id: int = 151656
+ tie_word_embeddings: bool = False
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.vision_config, dict):
+ self.vision_config = self.sub_configs["vision_config"](**self.vision_config)
+ elif self.vision_config is None:
+ self.vision_config = self.sub_configs["vision_config"]()
+
+ if isinstance(self.text_config, dict):
+ self.text_config = CONFIG_MAPPING[self.text_config["model_type"]](**self.text_config)
+ elif self.text_config is None:
+ self.text_config = CONFIG_MAPPING["qwen2"]()
+
+ # The default value is `False` but this config is used with many model types
+ # Attr `tie_word_embeddings` was saved in text config for those models, so we
+ # need an ugly workaround and forward-pass the attr from text config
+ if not self.tie_word_embeddings and self.text_config.tie_word_embeddings:
+ self.tie_word_embeddings = self.text_config.tie_word_embeddings
+
+ super().__post_init__(**kwargs)
+
+
+class VideoLlama3VisionRotaryEmbedding(VisionRotaryEmbedding):
+ pass
+
+
+class VideoLlama3VisionEmbeddings(nn.Module):
+ def __init__(self, config: VideoLlama3VisionConfig) -> None:
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.patch_size = config.patch_size
+
+ self.patch_embedding = nn.Conv2d(
+ in_channels=config.num_channels,
+ out_channels=self.embed_dim,
+ kernel_size=self.patch_size,
+ stride=self.patch_size,
+ padding="valid",
+ )
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = hidden_states.view(-1, self.config.num_channels, self.patch_size, self.patch_size)
+ patch_embeds = self.patch_embedding(hidden_states)
+ embeddings = patch_embeds.view(-1, self.embed_dim)
+ return embeddings
+
+
+class VideoLlama3VisionMLP(SiglipMLP):
+ pass
+
+
+class VideoLlama3VisionAttention(SiglipAttention):
+ def __init__(self, config):
+ super().__init__(config)
+ self.num_key_value_groups = 1
+ self.scaling = self.head_dim**-0.5
+ self.attention_dropout = config.attention_dropout
+ del self.scale
+ del self.dropout
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ cu_seqlens: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ """
+ Args:
+ hidden_states (`torch.Tensor`):
+ Input to the layer of shape `(seq_len, embed_dim)`.
+ cu_seqlens (`torch.Tensor` of shape `(num_images_or_videos + 1,)`):
+ The cumulative sequence lengths of each image or video feature.
+ position_embeddings (`tuple(torch.Tensor, torch.Tensor)` of shape `(num_patches, head_dim // 2)`):
+ The cosine and sine position embeddings for vision attention.
+ """
+ seq_length = hidden_states.shape[0]
+ query_states = self.q_proj(hidden_states).view(seq_length, self.num_heads, self.head_dim)
+ key_states = self.k_proj(hidden_states).view(seq_length, self.num_heads, self.head_dim)
+ value_states = self.v_proj(hidden_states).view(seq_length, self.num_heads, self.head_dim)
+
+ cos, sin = position_embeddings
+ query_states, key_states = apply_rotary_pos_emb_vision(query_states, key_states, cos, sin)
+
+ query_states = query_states.transpose(0, 1).unsqueeze(0)
+ key_states = key_states.transpose(0, 1).unsqueeze(0)
+ value_states = value_states.transpose(0, 1).unsqueeze(0)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ if is_flash_attention_requested(self.config):
+ # Flash Attention 2: Use cu_seqlens for variable length attention
+ max_seqlen = (cu_seqlens[1:] - cu_seqlens[:-1]).max()
+ attn_output, attn_weights = attention_interface(
+ self,
+ query_states,
+ key_states,
+ value_states,
+ attention_mask=None,
+ scaling=self.scaling,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ cu_seq_lens_q=cu_seqlens,
+ cu_seq_lens_k=cu_seqlens,
+ max_length_q=max_seqlen,
+ max_length_k=max_seqlen,
+ is_causal=False,
+ **kwargs,
+ )
+ else:
+ # Other implementations: Process each chunk separately
+ lengths = cu_seqlens[1:] - cu_seqlens[:-1]
+ splits = [
+ torch.split(tensor, lengths.tolist(), dim=2) for tensor in (query_states, key_states, value_states)
+ ]
+
+ attn_outputs, attn_weights = [], []
+ for q, k, v in zip(*splits):
+ attn_output, attn_weight = attention_interface(
+ self,
+ q,
+ k,
+ v,
+ attention_mask=None,
+ scaling=self.scaling,
+ dropout=0.0 if not self.training else self.attention_dropout,
+ is_causal=False,
+ **kwargs,
+ )
+ attn_outputs.append(attn_output)
+ attn_weights.append(attn_weight)
+
+ attn_output = torch.cat(attn_outputs, dim=1)
+
+ attn_output = attn_output.reshape(seq_length, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+class VideoLlama3VisionEncoderLayer(SiglipEncoderLayer):
+ def __init__(self, config: VideoLlama3VisionConfig):
+ super().__init__(config)
+ self.self_attn = VideoLlama3VisionAttention(config=config)
+ self.mlp = VideoLlama3VisionMLP(config=config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ cu_seqlens: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ r"""
+ cu_seqlens (`torch.Tensor` of shape `(num_images_or_videos + 1,)`):
+ The cumulative sequence lengths of each image or video feature.
+ position_embeddings (`tuple(torch.Tensor, torch.Tensor)` of shape `(num_patches, head_dim // 2)`):
+ The cosine and sine position embeddings for vision attention.
+ """
+ residual = hidden_states
+
+ hidden_states = self.layer_norm1(hidden_states)
+ hidden_states, _ = self.self_attn(
+ hidden_states,
+ cu_seqlens=cu_seqlens,
+ position_embeddings=position_embeddings,
+ **kwargs,
+ )
+ hidden_states = residual + hidden_states
+
+ residual = hidden_states
+ hidden_states = self.layer_norm2(hidden_states)
+ hidden_states = self.mlp(hidden_states)
+ hidden_states = residual + hidden_states
+
+ return hidden_states
+
+
+class VideoLlama3VisionEncoder(SiglipEncoder):
+ def __init__(self, config: VideoLlama3VisionConfig):
+ super().__init__(config)
+ self.layers = nn.ModuleList([VideoLlama3VisionEncoderLayer(config) for _ in range(config.num_hidden_layers)])
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ cu_seqlens: torch.Tensor,
+ position_embeddings: tuple[torch.Tensor, torch.Tensor],
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutput:
+ r"""
+ cu_seqlens (`torch.Tensor` of shape `(num_images_or_videos + 1,)`):
+ The cumulative sequence lengths of each image or video feature.
+ position_embeddings (`tuple(torch.Tensor, torch.Tensor)` of shape `(num_patches, head_dim // 2)`):
+ The cosine and sine position embeddings for vision attention.
+ """
+ for encoder_layer in self.layers:
+ hidden_states = encoder_layer(
+ hidden_states,
+ cu_seqlens=cu_seqlens,
+ position_embeddings=position_embeddings,
+ **kwargs,
+ )
+
+ return BaseModelOutput(last_hidden_state=hidden_states)
+
+
+class VideoLlama3PreTrainedModel(Qwen2VLPreTrainedModel):
+ config: VideoLlama3Config
+ _no_split_modules = ["VideoLlama3VisionEncoderLayer"]
+
+ def _init_weights(self, module):
+ PreTrainedModel._init_weights(self, module)
+ if isinstance(module, VideoLlama3VisionRotaryEmbedding):
+ inv_freq = 1.0 / (module.theta ** (torch.arange(0, module.dim, 2, dtype=torch.float) / module.dim))
+ init.copy_(module.inv_freq, inv_freq)
+
+
+class VideoLlama3VisionModel(VideoLlama3PreTrainedModel):
+ config: VideoLlama3VisionConfig
+ main_input_name = "pixel_values"
+ input_modalities = ("image",)
+ _can_record_outputs = {
+ "hidden_states": VideoLlama3VisionEncoderLayer,
+ "attentions": VideoLlama3VisionAttention,
+ }
+
+ def __init__(self, config: VideoLlama3VisionConfig):
+ super().__init__(config)
+ head_dim = config.hidden_size // config.num_attention_heads
+
+ self.rotary_pos_emb = VideoLlama3VisionRotaryEmbedding(head_dim // 2)
+ self.embeddings = VideoLlama3VisionEmbeddings(config)
+ self.encoder = VideoLlama3VisionEncoder(config)
+ self.post_layernorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ self.post_init()
+
+ def get_input_embeddings(self) -> VideoLlama3VisionEmbeddings:
+ return self.embeddings.patch_embedding
+
+ def pixel_unshuffle(
+ self,
+ hidden_states: torch.Tensor,
+ grid_thw: torch.Tensor,
+ merge_sizes: torch.Tensor,
+ ):
+ hidden_states_chunks = hidden_states.split(grid_thw.prod(dim=1).tolist(), dim=0)
+ outputs = []
+
+ for hidden_states, (t, h, w), merge_size in zip(hidden_states_chunks, grid_thw, merge_sizes):
+ c = hidden_states.shape[-1]
+ hidden_states = hidden_states.view(t, h // merge_size, w // merge_size, merge_size, merge_size, c).permute(
+ 0, 1, 3, 2, 4, 5
+ )
+ hidden_states = hidden_states.reshape(t, h, w, c).permute(0, 3, 1, 2)
+ hidden_states = torch.nn.functional.interpolate(
+ hidden_states, size=(h // merge_size, w // merge_size), mode="bilinear"
+ )
+ hidden_states = hidden_states.permute(0, 2, 3, 1).view(-1, c)
+ outputs.append(hidden_states)
+
+ return torch.cat(outputs, dim=0)
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor,
+ grid_thw: torch.Tensor,
+ merge_sizes: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutput:
+ r"""
+ grid_thw (`torch.LongTensor` of shape `(num_images_or_videos, 3)`):
+ The temporal, height and width dimensions of feature shape for each image. Each row contains [t, h, w] values.
+ merge_sizes (`torch.Tensor` of shape `(num_images_or_videos,)`):
+ The spatial downsampling ratio of each image or video feature.
+ """
+ position_ids = get_vision_position_ids(grid_thw, merge_sizes, kwargs=kwargs)
+ cu_seqlens = get_vision_cu_seqlens(grid_thw, kwargs=kwargs)
+
+ hidden_states = self.embeddings(pixel_values.type(self.dtype))
+ rotary_pos_emb = self.rotary_pos_emb(position_ids)
+ emb = torch.cat((rotary_pos_emb, rotary_pos_emb), dim=-1)
+ position_embeddings = (emb.cos(), emb.sin())
+
+ encoder_outputs: BaseModelOutput = self.encoder(
+ hidden_states,
+ cu_seqlens=cu_seqlens,
+ position_embeddings=position_embeddings,
+ **kwargs,
+ )
+
+ last_hidden_state = encoder_outputs[0]
+ last_hidden_state = self.post_layernorm(last_hidden_state)
+ last_hidden_state = self.pixel_unshuffle(last_hidden_state, grid_thw, merge_sizes)
+
+ return BaseModelOutput(last_hidden_state=last_hidden_state)
+
+
+class VideoLlama3Projector(nn.Module):
+ def __init__(self, config: VideoLlama3Config) -> None:
+ super().__init__()
+ in_hidden_size = config.vision_config.hidden_size
+ out_hidden_size = config.text_config.hidden_size
+ self.readout = nn.Sequential(
+ nn.Linear(in_hidden_size, out_hidden_size),
+ nn.GELU(),
+ nn.Linear(out_hidden_size, out_hidden_size),
+ )
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.readout(hidden_states)
+ return hidden_states
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for VideoLLaMA3 outputs, with hidden states and attentions.
+ """
+)
+@dataclass
+class VideoLlama3ModelOutputWithPast(ModelOutput):
+ r"""
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
+ `(batch_size, num_heads, sequence_length, embed_size_per_head)`)
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
+ `past_key_values` input) to speed up sequential decoding.
+ image_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(num_images_features, hidden_size)`.
+ image_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ video_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(num_video_features, hidden_size)`.
+ video_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ """
+
+ last_hidden_state: torch.FloatTensor = None
+ past_key_values: list[torch.FloatTensor] | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+ image_hidden_states: torch.FloatTensor | None = None
+ video_hidden_states: torch.FloatTensor | None = None
+
+
+class VideoLlama3Model(Qwen2VLModel):
+ _can_compile_fullgraph = False
+
+ def __init__(self, config: VideoLlama3Config):
+ PreTrainedModel.__init__(self, config)
+ self.vision_model = AutoModel.from_config(config.vision_config)
+ self.projector = VideoLlama3Projector(config)
+ self.language_model = AutoModel.from_config(config.text_config)
+
+ self.post_init()
+
+ def get_rope_index(self):
+ raise AttributeError("Not needed for VideoLLaMA3")
+
+ def get_vision_position_ids(self):
+ raise AttributeError("Not needed for VideoLLaMA3")
+
+ def compute_3d_position_ids(self):
+ raise AttributeError("Not needed for VideoLLaMA3")
+
+ @accepts_precomputed_kwargs(modality="video")
+ @can_return_tuple
+ @auto_docstring
+ def get_video_features(
+ self,
+ pixel_values_videos: torch.FloatTensor,
+ video_grid_thw: torch.LongTensor,
+ video_merge_sizes: torch.LongTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values_videos (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input videos.
+ video_grid_thw (`torch.LongTensor` of shape `(num_videos, 3)`, *optional*):
+ The temporal, height and width of feature shape of each video in LLM.
+ video_merge_sizes (`torch.Tensor` of shape `(num_videos,)`):
+ The spatial downsampling ratio of each video feature.
+ """
+ return self.get_image_features(
+ pixel_values=pixel_values_videos,
+ image_grid_thw=video_grid_thw,
+ image_merge_sizes=video_merge_sizes,
+ **kwargs,
+ )
+
+ @accepts_precomputed_kwargs(modality="image")
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self,
+ pixel_values: torch.FloatTensor,
+ image_grid_thw: torch.LongTensor,
+ image_merge_sizes: torch.LongTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input images.
+ image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+ The temporal, height and width of feature shape of each image in LLM.
+ image_merge_sizes (`torch.Tensor` of shape `(num_images,)`):
+ The spatial downsampling ratio of each image feature.
+ """
+ vision_outputs = self.vision_model(
+ pixel_values=pixel_values,
+ grid_thw=image_grid_thw,
+ merge_sizes=image_merge_sizes,
+ return_dict=True,
+ **kwargs,
+ )
+ last_hidden_state = vision_outputs.last_hidden_state
+ image_embeds = self.projector(last_hidden_state)
+
+ split_sizes = image_grid_thw.prod(dim=1) // (image_merge_sizes**2)
+ image_embeds = torch.split(image_embeds, split_sizes.tolist())
+ vision_outputs.pooler_output = image_embeds
+
+ return vision_outputs
+
+ @can_return_tuple
+ def forward(
+ self,
+ input_ids: torch.LongTensor = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ use_cache: bool | None = None,
+ pixel_values: torch.Tensor | None = None,
+ image_grid_thw: torch.LongTensor | None = None,
+ image_merge_sizes: torch.LongTensor | None = None,
+ pixel_values_videos: torch.FloatTensor | None = None,
+ video_grid_thw: torch.LongTensor | None = None,
+ video_merge_sizes: torch.LongTensor | None = None,
+ video_compression_mask: torch.BoolTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | VideoLlama3ModelOutputWithPast:
+ r"""
+ image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+ The temporal, height and width of feature shape of each image in LLM.
+ image_merge_sizes (`torch.Tensor` of shape `(num_images,)`):
+ The spatial downsampling ratio of each image feature.
+ video_grid_thw (`torch.Tensor` of shape `(num_videos, 3)`):
+ The temporal, height and width of feature shape of each video before vision encoder.
+ video_merge_sizes (`torch.Tensor` of shape `(num_videos,)`):
+ The spatial downsampling ratio of each video feature.
+ video_compression_mask (`torch.BoolTensor` of shape `(num_video_features,)`, *optional*):
+ The mask to indicate which video features are kept after token compression.
+ """
+
+ if inputs_embeds is None:
+ inputs_embeds = self.get_input_embeddings()(input_ids)
+
+ image_embeds = None
+ if pixel_values is not None:
+ image_embeds = self.get_image_features(
+ pixel_values, image_grid_thw, image_merge_sizes, return_dict=True, **kwargs
+ ).pooler_output
+ image_embeds = torch.cat(image_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+ image_mask, _ = self.get_placeholder_mask(
+ input_ids, inputs_embeds=inputs_embeds, image_features=image_embeds
+ )
+ inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+
+ video_embeds = None
+ if pixel_values_videos is not None:
+ video_embeds = self.get_video_features(
+ pixel_values_videos, video_grid_thw, video_merge_sizes, return_dict=True, **kwargs
+ ).pooler_output
+ video_embeds = torch.cat(video_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+ if video_compression_mask is not None:
+ video_embeds = video_embeds[video_compression_mask.to(video_embeds.device)]
+ _, video_mask = self.get_placeholder_mask(
+ input_ids, inputs_embeds=inputs_embeds, video_features=video_embeds
+ )
+ inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+ outputs = self.language_model(
+ input_ids=None,
+ position_ids=position_ids,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return VideoLlama3ModelOutputWithPast(
+ last_hidden_state=outputs.last_hidden_state,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ image_hidden_states=image_embeds,
+ video_hidden_states=video_embeds,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for VideoLLaMA3 causal language model (or autoregressive) outputs.
+ """
+)
+@dataclass
+class VideoLlama3CausalLMOutputWithPast(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+ Language modeling loss (for next-token prediction).
+ logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
+ Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
+ `(batch_size, num_heads, sequence_length, embed_size_per_head)`)
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
+ `past_key_values` input) to speed up sequential decoding.
+ image_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(num_images_features, hidden_size)`.
+ image_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ video_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(num_video_features, hidden_size)`.
+ video_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ past_key_values: list[torch.FloatTensor] | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+ image_hidden_states: torch.FloatTensor | None = None
+ video_hidden_states: torch.FloatTensor | None = None
+
+
+class VideoLlama3ForConditionalGeneration(Qwen2VLForConditionalGeneration):
+ _can_compile_fullgraph = False
+
+ def __init__(self, config: VideoLlama3Config):
+ super().__init__(config) # just to add type hint on config
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ pixel_values: torch.Tensor | None = None,
+ image_grid_thw: torch.LongTensor | None = None,
+ image_merge_sizes: torch.LongTensor | None = None,
+ pixel_values_videos: torch.FloatTensor | None = None,
+ video_grid_thw: torch.LongTensor | None = None,
+ video_merge_sizes: torch.LongTensor | None = None,
+ video_compression_mask: torch.BoolTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | VideoLlama3CausalLMOutputWithPast:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+ image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+ The temporal, height and width of feature shape of each image in LLM.
+ image_merge_sizes (`torch.Tensor` of shape `(num_images,)`):
+ The spatial downsampling ratio of each image feature.
+ video_grid_thw (`torch.Tensor` of shape `(num_videos, 3)`):
+ The temporal, height and width of feature shape of each video before vision encoder.
+ video_merge_sizes (`torch.Tensor` of shape `(num_videos,)`):
+ The spatial downsampling ratio of each video feature.
+ video_compression_mask (`torch.BoolTensor` of shape `(num_video_features,)`, *optional*):
+ The mask to indicate which video features are kept after token compression.
+ """
+
+ outputs = self.model(
+ input_ids=input_ids,
+ pixel_values=pixel_values,
+ image_grid_thw=image_grid_thw,
+ image_merge_sizes=image_merge_sizes,
+ pixel_values_videos=pixel_values_videos,
+ video_grid_thw=video_grid_thw,
+ video_merge_sizes=video_merge_sizes,
+ video_compression_mask=video_compression_mask,
+ position_ids=position_ids,
+ attention_mask=attention_mask,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ return_dict=True,
+ **kwargs,
+ )
+
+ hidden_states = outputs[0]
+ logits = self.lm_head(hidden_states)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(
+ logits=logits, labels=labels, vocab_size=self.config.text_config.vocab_size, **kwargs
+ )
+
+ return VideoLlama3CausalLMOutputWithPast(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ image_hidden_states=outputs.image_hidden_states,
+ video_hidden_states=outputs.video_hidden_states,
+ )
+
+ def prepare_inputs_for_generation(
+ self,
+ input_ids,
+ past_key_values=None,
+ attention_mask=None,
+ inputs_embeds=None,
+ position_ids=None,
+ use_cache=True,
+ pixel_values: torch.Tensor | None = None,
+ image_grid_thw: torch.LongTensor | None = None,
+ image_merge_sizes: torch.LongTensor | None = None,
+ pixel_values_videos: torch.FloatTensor | None = None,
+ video_grid_thw: torch.LongTensor | None = None,
+ video_merge_sizes: torch.LongTensor | None = None,
+ video_compression_mask: torch.BoolTensor | None = None,
+ is_first_iteration: bool | None = False,
+ **kwargs,
+ ):
+ # Overwritten -- in specific circumstances we don't want to forward image inputs to the model
+
+ model_inputs = super().prepare_inputs_for_generation(
+ input_ids,
+ past_key_values=past_key_values,
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ position_ids=position_ids,
+ pixel_values=pixel_values,
+ image_grid_thw=image_grid_thw,
+ image_merge_sizes=image_merge_sizes,
+ pixel_values_videos=pixel_values_videos,
+ video_grid_thw=video_grid_thw,
+ video_merge_sizes=video_merge_sizes,
+ video_compression_mask=video_compression_mask,
+ use_cache=use_cache,
+ is_first_iteration=is_first_iteration,
+ **kwargs,
+ )
+
+ if not is_first_iteration and use_cache:
+ model_inputs["pixel_values"] = None
+ model_inputs["pixel_values_videos"] = None
+
+ return model_inputs
+
+ def _prepare_position_ids_for_generation(self):
+ raise AttributeError("Not needed for VideoLLaMA3")
+
+ def _get_image_nums_and_video_nums(
+ self,
+ input_ids: torch.LongTensor | None,
+ inputs_embeds: torch.Tensor | None = None,
+ image_grid_thw: torch.LongTensor | None = None,
+ image_merge_sizes: torch.LongTensor | None = None,
+ video_grid_thw: torch.LongTensor | None = None,
+ video_merge_sizes: torch.LongTensor | None = None,
+ video_compression_mask: torch.BoolTensor | None = None,
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ """
+ Get the number of images and videos for each sample to calculate the separation length of the sample tensor.
+ These parameters are not passed through the processor to avoid unpredictable impacts from interface modifications.
+
+ Args:
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ Indices of input sequence tokens in the vocabulary.
+
+ Returns:
+ image_nums (`torch.LongTensor` of shape `(batch_size, num_images_sample)`)
+ video_nums (`torch.LongTensor` of shape `(batch_size, num_videos_sample)`)
+ """
+ image_token_id = self.config.image_token_id
+ video_token_id = self.config.video_token_id
+
+ if inputs_embeds is not None:
+ image_mask = (
+ inputs_embeds
+ == self.get_input_embeddings()(
+ torch.tensor(image_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ )[..., 0]
+ video_mask = (
+ inputs_embeds
+ == self.get_input_embeddings()(
+ torch.tensor(video_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ )[..., 0]
+ else:
+ image_mask = input_ids == image_token_id
+ video_mask = input_ids == video_token_id
+
+ if image_grid_thw is not None:
+ num_image_features = image_grid_thw.prod(dim=1) // (image_merge_sizes**2)
+ else:
+ num_image_features = []
+
+ if video_grid_thw is not None:
+ num_video_features = video_grid_thw.prod(dim=1) // (video_merge_sizes**2)
+ if video_compression_mask is not None:
+ num_video_features = video_compression_mask.split(num_video_features.tolist())
+ num_video_features = [mask.sum() for mask in num_video_features]
+ else:
+ num_video_features = []
+
+ image_nums, video_nums = [], []
+ start_image_idx, start_video_idx = 0, 0
+
+ for num_image_tokens, num_video_tokens in zip(image_mask.sum(dim=1), video_mask.sum(dim=1)):
+ cu_num_features = 0
+ image_idx = start_image_idx
+ while image_idx < len(num_image_features) and cu_num_features < num_image_tokens:
+ cu_num_features += num_image_features[image_idx]
+ image_idx += 1
+ assert cu_num_features == num_image_tokens, (
+ "The number of image tokens does not match the number of image features."
+ )
+ image_nums.append(image_idx - start_image_idx)
+ start_image_idx = image_idx
+
+ cu_num_features = 0
+ video_idx = start_video_idx
+ while video_idx < len(num_video_features) and cu_num_features < num_video_tokens:
+ cu_num_features += num_video_features[video_idx]
+ video_idx += 1
+ assert cu_num_features == num_video_tokens, (
+ "The number of video tokens does not match the number of video features."
+ )
+ video_nums.append(video_idx - start_video_idx)
+ start_video_idx = video_idx
+
+ return image_nums, video_nums
+
+ def _expand_inputs_for_generation(
+ self,
+ expand_size: int = 1,
+ is_encoder_decoder: bool = False,
+ input_ids: torch.LongTensor | None = None,
+ **model_kwargs,
+ ) -> tuple[torch.LongTensor, dict[str, Any]]:
+ # Overwritten -- Support for expanding tensors without a batch size dimension
+ # e.g., pixel_values, image_grid_thw, pixel_values_videos, video_grid_thw, second_per_grid_t
+ # pixel_values.shape[0] is sum(seqlen_images for samples)
+ # image_grid_thw.shape[0] is sum(num_images for samples)
+
+ if expand_size == 1:
+ return input_ids, model_kwargs
+
+ visual_keys = [
+ "pixel_values",
+ "image_grid_thw",
+ "image_merge_sizes",
+ "pixel_values_videos",
+ "video_grid_thw",
+ "video_merge_sizes",
+ "video_compression_mask",
+ ]
+
+ def _repeat_interleave_samples(x, lengths, repeat_times):
+ samples = torch.split(x, lengths)
+ repeat_args = [repeat_times] + [1] * (x.dim() - 1)
+ result = torch.cat([sample.repeat(*repeat_args) for sample in samples], dim=0)
+ return result
+
+ def _expand_dict_for_generation_visual(dict_to_expand):
+ image_grid_thw = model_kwargs.get("image_grid_thw", None)
+ video_grid_thw = model_kwargs.get("video_grid_thw", None)
+ video_merge_sizes = model_kwargs.get("video_merge_sizes", None)
+ video_compression_mask = model_kwargs.get("video_compression_mask", None)
+
+ image_nums, video_nums = self._get_image_nums_and_video_nums(
+ input_ids,
+ inputs_embeds=model_kwargs.get("inputs_embeds", None),
+ image_grid_thw=image_grid_thw,
+ image_merge_sizes=model_kwargs.get("image_merge_sizes", None),
+ video_grid_thw=video_grid_thw,
+ video_merge_sizes=video_merge_sizes,
+ video_compression_mask=video_compression_mask,
+ )
+ for key in dict_to_expand:
+ if key == "pixel_values":
+ # split images into samples
+ samples = torch.split(image_grid_thw, list(image_nums))
+ # compute the sequence length of images for each sample
+ lengths = [torch.prod(sample, dim=1).sum() for sample in samples]
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "image_grid_thw":
+ # get the num of images for each sample
+ lengths = list(image_nums)
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "image_merge_sizes":
+ lengths = list(image_nums)
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "pixel_values_videos":
+ samples = torch.split(video_grid_thw, list(video_nums))
+ lengths = [torch.prod(sample, dim=1).sum() for sample in samples]
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "video_compression_mask":
+ samples = torch.split(video_grid_thw, list(video_nums))
+ merge_sizes = torch.split(video_merge_sizes, list(video_nums))
+ lengths = [
+ (torch.prod(sample, dim=1) // merge_size**2).sum()
+ for sample, merge_size in zip(samples, merge_sizes)
+ ]
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "video_grid_thw":
+ lengths = list(video_nums)
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+ elif key == "video_merge_sizes":
+ lengths = list(video_nums)
+ dict_to_expand[key] = _repeat_interleave_samples(
+ dict_to_expand[key], lengths=lengths, repeat_times=expand_size
+ )
+
+ return dict_to_expand
+
+ def _expand_dict_for_generation(dict_to_expand):
+ for key in dict_to_expand:
+ if (
+ dict_to_expand[key] is not None
+ and isinstance(dict_to_expand[key], torch.Tensor)
+ and key not in visual_keys
+ ):
+ dict_to_expand[key] = dict_to_expand[key].repeat_interleave(expand_size, dim=0)
+ return dict_to_expand
+
+ model_kwargs = _expand_dict_for_generation_visual(model_kwargs)
+
+ if input_ids is not None:
+ input_ids = input_ids.repeat_interleave(expand_size, dim=0)
+
+ model_kwargs = _expand_dict_for_generation(model_kwargs)
+
+ if is_encoder_decoder:
+ if model_kwargs.get("encoder_outputs") is None:
+ raise ValueError("If `is_encoder_decoder` is True, make sure that `encoder_outputs` is defined.")
+ model_kwargs["encoder_outputs"] = _expand_dict_for_generation(model_kwargs["encoder_outputs"])
+
+ return input_ids, model_kwargs
+
+
+class VideoLlama3ProcessorKwargs(Qwen2VLProcessorKwargs):
+ _defaults = {
+ "text_kwargs": {
+ "padding": False,
+ "return_mm_token_type_ids": False,
+ },
+ "videos_kwargs": {"return_metadata": True},
+ }
+
+
+class VideoLlama3Processor(Qwen2VLProcessor):
+ def __call__(
+ self,
+ images: ImageInput = None,
+ text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] = None,
+ videos: VideoInput = None,
+ **kwargs: Unpack[VideoLlama3ProcessorKwargs],
+ ) -> BatchFeature:
+ output_kwargs = self._merge_kwargs(
+ VideoLlama3ProcessorKwargs,
+ tokenizer_init_kwargs=self.tokenizer.init_kwargs,
+ **kwargs,
+ )
+
+ image_inputs = videos_inputs = {}
+ if images is not None:
+ image_inputs = self.image_processor(images=images, **output_kwargs["images_kwargs"])
+ image_grid_thw = image_inputs["image_grid_thw"]
+ image_merge_sizes = image_inputs["image_merge_sizes"]
+ else:
+ image_grid_thw = image_merge_sizes = []
+
+ if videos is not None:
+ videos_inputs = self.video_processor(videos=videos, **output_kwargs["videos_kwargs"])
+ num_video_tokens = [
+ grid_thw.prod() // merge_size**2
+ for grid_thw, merge_size in zip(videos_inputs["video_grid_thw"], videos_inputs["video_merge_sizes"])
+ ]
+ video_compression_masks = videos_inputs["video_compression_mask"].split(num_video_tokens)
+ if not kwargs.get("return_metadata"):
+ video_metadata = videos_inputs.pop("video_metadata")
+ else:
+ video_metadata = videos_inputs["video_metadata"]
+ timestamps = []
+ for metadata in video_metadata:
+ if metadata.fps is None:
+ logger.warning_once(
+ "VideoLLaMA4 requires frame timestamps to construct prompts, but the `fps` of the input video could not be inferred. "
+ "Probably `video_metadata` was missing from inputs and you passed pre-sampled frames. "
+ "Defaulting to `fps=1`. Please provide `video_metadata` for more accurate results."
+ )
+ metadata.fps = 1 if metadata.fps is None else metadata.fps
+ timestamps.append(metadata.timestamps)
+ else:
+ video_compression_masks = timestamps = []
+
+ if not isinstance(text, list):
+ text = [text]
+
+ text = text.copy() # below lines change text in-place
+
+ if images is not None:
+ image_index = 0
+ for i in range(len(text)):
+ while self.image_token in text[i]:
+ num_image_tokens = image_grid_thw[image_index].prod() // (image_merge_sizes[image_index] ** 2)
+ text[i] = text[i].replace(self.image_token, "<|placeholder|>" * num_image_tokens, 1)
+ image_index += 1
+ text[i] = text[i].replace("<|placeholder|>", self.image_token)
+
+ if videos is not None:
+ video_index = 0
+ for i in range(len(text)):
+ while self.video_token in text[i]:
+ frame_compression_masks = video_compression_masks[video_index].split(
+ len(video_compression_masks[video_index]) // len(timestamps[video_index])
+ )
+ num_frame_tokens = [x.sum() for x in frame_compression_masks]
+ frame_prompts = [
+ f"Time {t:.1f}s:" + "<|placeholder|>" * n
+ for n, t in zip(num_frame_tokens, timestamps[video_index])
+ ]
+ text[i] = text[i].replace(self.video_token, ",".join(frame_prompts), 1)
+ video_index += 1
+ text[i] = text[i].replace("<|placeholder|>", self.video_token)
+
+ return_tensors = output_kwargs["text_kwargs"].pop("return_tensors", None)
+ return_mm_token_type_ids = output_kwargs["text_kwargs"].pop("return_mm_token_type_ids", False)
+ text_inputs = self.tokenizer(text, **output_kwargs["text_kwargs"], return_tensors=None)
+ self._check_special_mm_tokens(text, text_inputs, modalities=["image", "video"])
+
+ if return_mm_token_type_ids:
+ text_inputs["mm_token_type_ids"] = self.create_mm_token_type_ids(text_inputs["input_ids"])
+ return BatchFeature(data={**text_inputs, **image_inputs, **videos_inputs}, tensor_type=return_tensors)
+
+ def model_input_names(self):
+ raise AttributeError("VideoLlama doesn't need to override it")
+
+
+class VideoLlama3ImageProcessorKwargs(Qwen2VLImageProcessorKwargs):
+ pass
+
+
+class VideoLlama3ImageProcessorPil(Qwen2VLImageProcessorPil):
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ temporal_patch_size = 1
+ merge_size = 1
+ valid_kwargs = VideoLlama3ImageProcessorKwargs
+ model_input_names = [
+ "pixel_values",
+ "image_grid_thw",
+ "image_merge_sizes",
+ ]
+
+ def _preprocess(
+ self,
+ images: list[np.ndarray],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ patch_size: int,
+ temporal_patch_size: int,
+ merge_size: int,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ all_patches = []
+ all_grids = []
+
+ for image in images:
+ height, width = image.shape[-2:]
+ if do_resize:
+ resized_height, resized_width = smart_resize(
+ height,
+ width,
+ factor=patch_size * merge_size,
+ min_pixels=size.shortest_edge,
+ max_pixels=size.longest_edge,
+ )
+ image = self.resize(
+ image,
+ size=SizeDict(height=resized_height, width=resized_width),
+ resample=resample,
+ )
+ else:
+ resized_height, resized_width = height, width
+
+ if do_rescale:
+ image = self.rescale(image, rescale_factor)
+ if do_normalize:
+ image = self.normalize(image, image_mean, image_std)
+
+ patches = np.expand_dims(image, axis=0)
+ if patches.ndim == 4:
+ patches = np.expand_dims(patches, axis=1)
+ if patches.shape[1] % temporal_patch_size != 0:
+ repeats = np.repeat(
+ patches[:, -1:], temporal_patch_size - (patches.shape[1] % temporal_patch_size), axis=1
+ )
+ patches = np.concatenate([patches, repeats], axis=1)
+
+ batch_size, grid_t, channel = patches.shape[0], patches.shape[1] // temporal_patch_size, patches.shape[2]
+ grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
+
+ patches = patches.reshape(
+ batch_size,
+ grid_t,
+ temporal_patch_size,
+ channel,
+ grid_h // merge_size,
+ merge_size,
+ patch_size,
+ grid_w // merge_size,
+ merge_size,
+ patch_size,
+ )
+ patches = patches.transpose(0, 1, 4, 7, 5, 8, 3, 2, 6, 9)
+ flatten_patches = patches.reshape(
+ batch_size * grid_t * grid_h * grid_w,
+ channel * temporal_patch_size * patch_size * patch_size,
+ )
+
+ all_patches.append(flatten_patches)
+ all_grids.append([grid_t, grid_h, grid_w])
+
+ pixel_values = np.concatenate(all_patches, axis=0)
+ image_grid_thw = np.array(all_grids, dtype=np.int64)
+ image_merge_sizes = np.array([merge_size] * image_grid_thw.shape[0], dtype=np.int64)
+
+ return BatchFeature(
+ data={
+ "pixel_values": pixel_values,
+ "image_grid_thw": image_grid_thw,
+ "image_merge_sizes": image_merge_sizes,
+ },
+ tensor_type=return_tensors,
+ )
+
+
+class VideoLlama3ImageProcessor(Qwen2VLImageProcessor):
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ temporal_patch_size = 1
+ merge_size = 1
+ valid_kwargs = VideoLlama3ImageProcessorKwargs
+ model_input_names = [
+ "pixel_values",
+ "image_grid_thw",
+ "image_merge_sizes",
+ ]
+
+ def _preprocess(
+ self,
+ images: list["torch.Tensor"],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | int | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ patch_size: int,
+ temporal_patch_size: int,
+ merge_size: int,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+ resized_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ height, width = stacked_images.shape[-2:]
+ if do_resize:
+ resized_height, resized_width = smart_resize(
+ height,
+ width,
+ factor=patch_size * merge_size,
+ min_pixels=size.shortest_edge,
+ max_pixels=size.longest_edge,
+ )
+ stacked_images = self.resize(
+ image=stacked_images,
+ size=SizeDict(height=resized_height, width=resized_width),
+ resample=resample,
+ )
+ resized_images_grouped[shape] = stacked_images
+ resized_images = reorder_images(resized_images_grouped, grouped_images_index)
+
+ grouped_images, grouped_images_index = group_images_by_shape(resized_images, disable_grouping=disable_grouping)
+ processed_images_grouped = {}
+ processed_grids = {}
+ for shape, stacked_images in grouped_images.items():
+ resized_height, resized_width = stacked_images.shape[-2:]
+ patches = self.rescale_and_normalize(
+ stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ batch_size, channel = patches.shape[:2]
+ grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
+ patches = patches.reshape(
+ batch_size,
+ channel,
+ grid_h // merge_size,
+ merge_size,
+ patch_size,
+ grid_w // merge_size,
+ merge_size,
+ patch_size,
+ )
+ # Reorder dimensions to group grid and patch information for subsequent flattening.
+ # [batch, grid_h/merge, grid_w/merge, merge, merge, channel, patch, patch]
+ patches = patches.permute(0, 2, 5, 3, 6, 1, 4, 7)
+
+ flatten_patches = (
+ patches.unsqueeze(6)
+ .expand(-1, -1, -1, -1, -1, -1, temporal_patch_size, -1, -1)
+ .reshape(
+ batch_size,
+ grid_h * grid_w,
+ channel * temporal_patch_size * patch_size * patch_size,
+ )
+ )
+
+ processed_images_grouped[shape] = flatten_patches
+ processed_grids[shape] = [[1, grid_h, grid_w]] * batch_size
+
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index)
+ processed_grids_ordered = reorder_images(processed_grids, grouped_images_index)
+ pixel_values = torch.cat(processed_images, dim=0)
+ image_grid_thw = torch.tensor(processed_grids_ordered, dtype=torch.long)
+ image_merge_sizes = torch.tensor(
+ [merge_size] * image_grid_thw.size(0),
+ dtype=image_grid_thw.dtype,
+ device=image_grid_thw.device,
+ )
+
+ return BatchFeature(
+ data={
+ "pixel_values": pixel_values,
+ "image_grid_thw": image_grid_thw,
+ "image_merge_sizes": image_merge_sizes,
+ },
+ tensor_type=return_tensors,
+ )
+
+
+class VideoLlama3VideoProcessorInitKwargs(Qwen2VLVideoProcessorInitKwargs):
+ use_token_compression: bool | None
+
+
+class VideoLlama3VideoProcessor(Qwen2VLVideoProcessor):
+ use_token_compression = True
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ temporal_patch_size = 1
+ max_frames = 180
+ return_metadata = True
+ valid_kwargs = VideoLlama3VideoProcessorInitKwargs
+ model_input_names = ["pixel_values_videos", "video_grid_thw", "video_merge_sizes", "video_compression_mask"]
+
+ def _get_compression_mask(
+ self,
+ pixel_values_videos: torch.FloatTensor,
+ video_grid_thw: torch.LongTensor,
+ video_merge_sizes: torch.LongTensor,
+ threshold: float | None = 0.1,
+ min_tokens: int | None = 1,
+ ) -> torch.BoolTensor:
+ """
+ Get the compression mask for video tokens based on pixel differences.
+ Args:
+ pixel_values_videos (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input videos.
+ video_grid_thw (`torch.LongTensor` of shape `(num_videos, 3)`, *optional*):
+ The temporal, height and width of feature shape of each video in LLM.
+ video_merge_sizes (`torch.Tensor` of shape `(num_videos,)`):
+ The spatial downsampling ratio of each video feature.
+ threshold (`float`, *optional*, defaults to 0.1):
+ The threshold to determine whether a token should be kept based on pixel differences.
+ min_tokens (`int`, *optional*, defaults to 1):
+ The minimum number of tokens to keep for each frame.
+ """
+ videos = pixel_values_videos.split(video_grid_thw.prod(dim=1).tolist(), dim=0)
+ compression_masks = []
+
+ for images, grid_size, merge_size in zip(videos, video_grid_thw, video_merge_sizes):
+ t, h, w = grid_size
+ if t == 1:
+ num_tokens = images.size(0) // (merge_size**2)
+ compression_masks.append(torch.ones((num_tokens,), dtype=torch.bool, device=images.device))
+ else:
+ # NOTE: video token compressor
+ images = images.view(t, (h // merge_size) * (w // merge_size), -1)
+
+ pixel_diff = images[1:] - images[:-1]
+ pixel_diff = torch.abs(pixel_diff).mean(dim=-1) * 255
+ pixel_diff = torch.cat([torch.full_like(pixel_diff[0:1], threshold + 1), pixel_diff], dim=0)
+ mask = pixel_diff > threshold
+ padding_ids = torch.nonzero(mask.sum(dim=1) < min_tokens)[:, 0]
+ mask[padding_ids, :min_tokens] = 1
+ compression_masks.append(mask.flatten())
+
+ return torch.cat(compression_masks)
+
+ def _preprocess(
+ self,
+ videos: list["torch.Tensor"],
+ do_convert_rgb: bool,
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | int | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ patch_size: int | None = None,
+ temporal_patch_size: int | None = None,
+ merge_size: int | None = None,
+ use_token_compression: bool | None = None,
+ return_tensors: str | TensorType | None = None,
+ device: Optional["torch.Tensor"] = None,
+ **kwargs,
+ ):
+ # Group videos by size for batched resizing
+ grouped_videos, grouped_videos_index = group_videos_by_shape(videos)
+ resized_videos_grouped = {}
+ for shape, stacked_videos in grouped_videos.items():
+ height, width = get_image_size(stacked_videos[0], channel_dim=ChannelDimension.FIRST)
+ resized_height, resized_width = height, width
+ if do_resize:
+ resized_height, resized_width = smart_resize(
+ height,
+ width,
+ factor=patch_size * merge_size,
+ min_pixels=size["shortest_edge"],
+ max_pixels=size["longest_edge"] // shape[0],
+ )
+ stacked_videos = self.resize(
+ image=stacked_videos,
+ size=SizeDict(height=resized_height, width=resized_width),
+ resample=resample,
+ )
+ resized_videos_grouped[shape] = stacked_videos
+ resized_videos = reorder_videos(resized_videos_grouped, grouped_videos_index)
+
+ # Group videos by size for further processing
+ # Needed in case do_resize is False, or resize returns videos with different sizes
+ grouped_videos, grouped_videos_index = group_videos_by_shape(resized_videos)
+ processed_videos_grouped = {}
+ processed_grids = {}
+ for shape, stacked_videos in grouped_videos.items():
+ resized_height, resized_width = get_image_size(stacked_videos[0], channel_dim=ChannelDimension.FIRST)
+
+ # Fused rescale and normalize
+ stacked_videos = self.rescale_and_normalize(
+ stacked_videos, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ patches = stacked_videos
+
+ # Check that videos have `num_frames` divisible by `temporal_patch_size`
+ if patches.shape[1] % temporal_patch_size != 0:
+ repeats = patches[:, -1:].repeat(1, self.temporal_patch_size - 1, 1, 1, 1)
+ patches = torch.cat([patches, repeats], dim=1)
+
+ batch_size, grid_t, channel = patches.shape[:3]
+ grid_t = grid_t // temporal_patch_size
+ grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
+
+ patches = patches.view(
+ batch_size,
+ grid_t,
+ temporal_patch_size,
+ channel,
+ grid_h // merge_size,
+ merge_size,
+ patch_size,
+ grid_w // merge_size,
+ merge_size,
+ patch_size,
+ )
+ patches = patches.permute(0, 1, 4, 7, 5, 8, 3, 2, 6, 9)
+ flatten_patches = patches.reshape(
+ batch_size,
+ grid_t * grid_h * grid_w,
+ channel * temporal_patch_size * patch_size * patch_size,
+ )
+
+ processed_videos_grouped[shape] = flatten_patches
+ processed_grids[shape] = [[grid_t, grid_h, grid_w]] * batch_size
+
+ processed_videos = reorder_videos(processed_videos_grouped, grouped_videos_index)
+ processed_grids = reorder_videos(processed_grids, grouped_videos_index)
+ pixel_values_videos = torch.cat(processed_videos, dim=0)
+ video_grid_thw = torch.tensor(processed_grids)
+ video_merge_sizes = torch.full(
+ (video_grid_thw.size(0),), merge_size, dtype=video_grid_thw.dtype, device=video_grid_thw.device
+ )
+
+ if use_token_compression:
+ video_compression_mask = self._get_compression_mask(
+ pixel_values_videos=pixel_values_videos,
+ video_grid_thw=video_grid_thw,
+ video_merge_sizes=video_merge_sizes,
+ )
+ else:
+ num_video_tokens = video_grid_thw.prod(-1).sum() // (merge_size**2)
+ video_compression_mask = torch.ones(
+ (num_video_tokens,), dtype=torch.bool, device=pixel_values_videos.device
+ )
+
+ return BatchFeature(
+ data={
+ "pixel_values_videos": pixel_values_videos,
+ "video_grid_thw": video_grid_thw,
+ "video_merge_sizes": video_merge_sizes,
+ "video_compression_mask": video_compression_mask,
+ },
+ tensor_type=return_tensors,
+ )
+
+
+__all__ = [
+ "VideoLlama3VisionConfig",
+ "VideoLlama3Config",
+ "VideoLlama3VisionModel",
+ "VideoLlama3PreTrainedModel",
+ "VideoLlama3Model",
+ "VideoLlama3ForConditionalGeneration",
+ "VideoLlama3Processor",
+ "VideoLlama3ImageProcessor",
+ "VideoLlama3ImageProcessorPil",
+ "VideoLlama3VideoProcessor",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/processing_video_llama_3.py b/lib/python3.11/site-packages/transformers/models/video_llama_3/processing_video_llama_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..7916d7e41d8e0d933f3a541019253e44938a1a0e
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llama_3/processing_video_llama_3.py
@@ -0,0 +1,222 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/video_llama_3/modular_video_llama_3.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_video_llama_3.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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 ...feature_extraction_utils import BatchFeature
+from ...image_utils import ImageInput
+from ...processing_utils import MultiModalData, ProcessingKwargs, ProcessorMixin, Unpack
+from ...tokenization_utils_base import PreTokenizedInput, TextInput
+from ...utils import auto_docstring, logging
+from ...video_utils import VideoInput
+
+
+logger = logging.get_logger(__name__)
+
+
+class VideoLlama3ProcessorKwargs(ProcessingKwargs, total=False):
+ _defaults = {
+ "text_kwargs": {
+ "padding": False,
+ "return_mm_token_type_ids": False,
+ },
+ "videos_kwargs": {"return_metadata": True},
+ }
+
+
+@auto_docstring
+class VideoLlama3Processor(ProcessorMixin):
+ def __init__(self, image_processor=None, tokenizer=None, video_processor=None, chat_template=None, **kwargs):
+ self.image_token = "<|image_pad|>" if not hasattr(tokenizer, "image_token") else tokenizer.image_token
+ self.video_token = "<|video_pad|>" if not hasattr(tokenizer, "video_token") else tokenizer.video_token
+ self.image_token_id = (
+ tokenizer.image_token_id
+ if getattr(tokenizer, "image_token_id", None)
+ else tokenizer.convert_tokens_to_ids(self.image_token)
+ )
+ self.video_token_id = (
+ tokenizer.video_token_id
+ if getattr(tokenizer, "video_token_id", None)
+ else tokenizer.convert_tokens_to_ids(self.video_token)
+ )
+ super().__init__(image_processor, tokenizer, video_processor, chat_template=chat_template)
+
+ @auto_docstring
+ def __call__(
+ self,
+ images: ImageInput = None,
+ text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] = None,
+ videos: VideoInput = None,
+ **kwargs: Unpack[VideoLlama3ProcessorKwargs],
+ ) -> BatchFeature:
+ r"""
+ Returns:
+ [`BatchFeature`]: A [`BatchFeature`] with the following fields:
+
+ - **input_ids** -- List of token ids to be fed to a model. Returned when `text` is not `None`.
+ - **attention_mask** -- List of indices specifying which tokens should be attended to by the model (when
+ `return_attention_mask=True` or if *"attention_mask"* is in `self.model_input_names` and if `text` is not
+ `None`).
+ - **pixel_values** -- Pixel values to be fed to a model. Returned when `images` is not `None`.
+ - **pixel_values_videos** -- Pixel values of videos to be fed to a model. Returned when `videos` is not `None`.
+ - **image_grid_thw** -- List of image 3D grid in LLM. Returned when `images` is not `None`.
+ - **video_grid_thw** -- List of video 3D grid in LLM. Returned when `videos` is not `None`.
+ """
+ output_kwargs = self._merge_kwargs(
+ VideoLlama3ProcessorKwargs,
+ tokenizer_init_kwargs=self.tokenizer.init_kwargs,
+ **kwargs,
+ )
+
+ image_inputs = videos_inputs = {}
+ if images is not None:
+ image_inputs = self.image_processor(images=images, **output_kwargs["images_kwargs"])
+ image_grid_thw = image_inputs["image_grid_thw"]
+ image_merge_sizes = image_inputs["image_merge_sizes"]
+ else:
+ image_grid_thw = image_merge_sizes = []
+
+ if videos is not None:
+ videos_inputs = self.video_processor(videos=videos, **output_kwargs["videos_kwargs"])
+ num_video_tokens = [
+ grid_thw.prod() // merge_size**2
+ for grid_thw, merge_size in zip(videos_inputs["video_grid_thw"], videos_inputs["video_merge_sizes"])
+ ]
+ video_compression_masks = videos_inputs["video_compression_mask"].split(num_video_tokens)
+ if not kwargs.get("return_metadata"):
+ video_metadata = videos_inputs.pop("video_metadata")
+ else:
+ video_metadata = videos_inputs["video_metadata"]
+ timestamps = []
+ for metadata in video_metadata:
+ if metadata.fps is None:
+ logger.warning_once(
+ "VideoLLaMA4 requires frame timestamps to construct prompts, but the `fps` of the input video could not be inferred. "
+ "Probably `video_metadata` was missing from inputs and you passed pre-sampled frames. "
+ "Defaulting to `fps=1`. Please provide `video_metadata` for more accurate results."
+ )
+ metadata.fps = 1 if metadata.fps is None else metadata.fps
+ timestamps.append(metadata.timestamps)
+ else:
+ video_compression_masks = timestamps = []
+
+ if not isinstance(text, list):
+ text = [text]
+
+ text = text.copy() # below lines change text in-place
+
+ if images is not None:
+ image_index = 0
+ for i in range(len(text)):
+ while self.image_token in text[i]:
+ num_image_tokens = image_grid_thw[image_index].prod() // (image_merge_sizes[image_index] ** 2)
+ text[i] = text[i].replace(self.image_token, "<|placeholder|>" * num_image_tokens, 1)
+ image_index += 1
+ text[i] = text[i].replace("<|placeholder|>", self.image_token)
+
+ if videos is not None:
+ video_index = 0
+ for i in range(len(text)):
+ while self.video_token in text[i]:
+ frame_compression_masks = video_compression_masks[video_index].split(
+ len(video_compression_masks[video_index]) // len(timestamps[video_index])
+ )
+ num_frame_tokens = [x.sum() for x in frame_compression_masks]
+ frame_prompts = [
+ f"Time {t:.1f}s:" + "<|placeholder|>" * n
+ for n, t in zip(num_frame_tokens, timestamps[video_index])
+ ]
+ text[i] = text[i].replace(self.video_token, ",".join(frame_prompts), 1)
+ video_index += 1
+ text[i] = text[i].replace("<|placeholder|>", self.video_token)
+
+ return_tensors = output_kwargs["text_kwargs"].pop("return_tensors", None)
+ return_mm_token_type_ids = output_kwargs["text_kwargs"].pop("return_mm_token_type_ids", False)
+ text_inputs = self.tokenizer(text, **output_kwargs["text_kwargs"], return_tensors=None)
+ self._check_special_mm_tokens(text, text_inputs, modalities=["image", "video"])
+
+ if return_mm_token_type_ids:
+ text_inputs["mm_token_type_ids"] = self.create_mm_token_type_ids(text_inputs["input_ids"])
+ return BatchFeature(data={**text_inputs, **image_inputs, **videos_inputs}, tensor_type=return_tensors)
+
+ def _get_num_multimodal_tokens(self, image_sizes=None, video_sizes=None, **kwargs):
+ """
+ Computes the number of placeholder tokens needed for multimodal inputs with the given sizes.
+ Args:
+ image_sizes (`list[list[int]]`, *optional*):
+ The input sizes formatted as (height, width) per each image.
+ video_sizes (`list[list[int]]`, *optional*):
+ The input sizes formatted as (num_frames, height, width) per each video.
+ Returns:
+ `MultiModalData`: A `MultiModalData` object holding number of tokens per each of the provided
+ input modalities, along with other useful data.
+ """
+
+ vision_data = {}
+ if image_sizes is not None:
+ images_kwargs = VideoLlama3ProcessorKwargs._defaults.get("images_kwargs", {})
+ images_kwargs.update(kwargs)
+ merge_size = images_kwargs.get("merge_size", None) or self.image_processor.merge_size
+
+ num_image_patches = [
+ self.image_processor.get_number_of_image_patches(*image_size, images_kwargs)
+ for image_size in image_sizes
+ ]
+ num_image_tokens = [(num_patches // merge_size**2) for num_patches in num_image_patches]
+ vision_data.update({"num_image_tokens": num_image_tokens, "num_image_patches": num_image_patches})
+
+ if video_sizes is not None:
+ videos_kwargs = VideoLlama3ProcessorKwargs._defaults.get("videos_kwargs", {})
+ videos_kwargs.update(kwargs)
+ num_video_patches = [
+ self.video_processor.get_number_of_video_patches(*video_size, videos_kwargs)
+ for video_size in video_sizes
+ ]
+ num_video_tokens = [(num_patches // merge_size**2) for num_patches in num_video_patches]
+ vision_data["num_video_tokens"] = num_video_tokens
+
+ return MultiModalData(**vision_data)
+
+ def post_process_image_text_to_text(
+ self, generated_outputs, skip_special_tokens=True, clean_up_tokenization_spaces=False, **kwargs
+ ):
+ """
+ Post-process the output of the model to decode the text.
+
+ Args:
+ generated_outputs (`torch.Tensor` or `np.ndarray`):
+ The output of the model `generate` function. The output is expected to be a tensor of shape `(batch_size, sequence_length)`
+ or `(sequence_length,)`.
+ skip_special_tokens (`bool`, *optional*, defaults to `True`):
+ Whether or not to remove special tokens in the output. Argument passed to the tokenizer's `batch_decode` method.
+ clean_up_tokenization_spaces (`bool`, *optional*, defaults to `False`):
+ Whether or not to clean up the tokenization spaces. Argument passed to the tokenizer's `batch_decode` method.
+ **kwargs:
+ Additional arguments to be passed to the tokenizer's `batch_decode method`.
+
+ Returns:
+ `list[str]`: The decoded text.
+ """
+ return self.tokenizer.batch_decode(
+ generated_outputs,
+ skip_special_tokens=skip_special_tokens,
+ clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+ **kwargs,
+ )
+
+
+__all__ = ["VideoLlama3Processor"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llama_3/video_processing_video_llama_3.py b/lib/python3.11/site-packages/transformers/models/video_llama_3/video_processing_video_llama_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6a04c8f0be663d29a181c929e0ca3b0f2749d21
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llama_3/video_processing_video_llama_3.py
@@ -0,0 +1,386 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/video_llama_3/modular_video_llama_3.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_video_llama_3.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 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 math
+from typing import Optional
+
+import torch
+
+from ...feature_extraction_utils import BatchFeature
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ChannelDimension,
+ PILImageResampling,
+ SizeDict,
+ get_image_size,
+)
+from ...processing_utils import Unpack, VideosKwargs
+from ...utils import TensorType, add_start_docstrings
+from ...video_processing_utils import BASE_VIDEO_PROCESSOR_DOCSTRING, BaseVideoProcessor
+from ...video_utils import VideoMetadata, group_videos_by_shape, reorder_videos
+from .image_processing_video_llama_3 import smart_resize
+
+
+class VideoLlama3VideoProcessorInitKwargs(VideosKwargs, total=False):
+ min_pixels: int
+ max_pixels: int
+ patch_size: int
+ temporal_patch_size: int
+ merge_size: int
+ min_frames: int
+ max_frames: int
+ use_token_compression: bool | None
+
+
+@add_start_docstrings(
+ "Constructs a fast Qwen2-VL image processor that dynamically resizes videos based on the original videos.",
+ BASE_VIDEO_PROCESSOR_DOCSTRING,
+ """
+ min_pixels (`int`, *optional*, defaults to `56 * 56`):
+ The min pixels of the image to resize the image.
+ max_pixels (`int`, *optional*, defaults to `28 * 28 * 1280`):
+ The max pixels of the image to resize the image.
+ patch_size (`int`, *optional*, defaults to 14):
+ The spacial patch size of the vision encoder.
+ temporal_patch_size (`int`, *optional*, defaults to 2):
+ The temporal patch size of the vision encoder.
+ merge_size (`int`, *optional*, defaults to 2):
+ The merge size of the vision encoder to llm encoder.
+ min_frames (`int`, *optional*, defaults to 4):
+ The minimum number of frames that can be sampled.
+ max_frames (`int`, *optional*, defaults to 768):
+ The maximum number of frames that can be sampled.
+ """,
+)
+class VideoLlama3VideoProcessor(BaseVideoProcessor):
+ resample = PILImageResampling.BICUBIC
+ size = {"shortest_edge": 128 * 28 * 28, "longest_edge": 28 * 28 * 768}
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ do_convert_rgb = True
+ patch_size = 14
+ temporal_patch_size = 1
+ merge_size = 2
+ min_frames = 4
+ max_frames = 180
+ do_sample_frames = False # Set to False for BC, recommended to set `True` in new models
+ valid_kwargs = VideoLlama3VideoProcessorInitKwargs
+ model_input_names = ["pixel_values_videos", "video_grid_thw", "video_merge_sizes", "video_compression_mask"]
+ use_token_compression = True
+ return_metadata = True
+
+ def __init__(self, **kwargs: Unpack[VideoLlama3VideoProcessorInitKwargs]):
+ size = kwargs.pop("size", None)
+ min_pixels = kwargs.pop("min_pixels", None)
+ max_pixels = kwargs.pop("max_pixels", None)
+ # backward compatibility: override size with min_pixels and max_pixels if they are provided
+ size = self.size if size is None else size
+ if min_pixels is not None:
+ size["shortest_edge"] = min_pixels
+ size.pop("min_pixels", None)
+ if max_pixels is not None:
+ size["longest_edge"] = max_pixels
+ size.pop("max_pixels", None)
+ if "shortest_edge" not in size or "longest_edge" not in size:
+ raise ValueError("size must contain 'shortest_edge' and 'longest_edge' keys.")
+
+ super().__init__(size=size, **kwargs)
+
+ def _standardize_kwargs(
+ self,
+ size: SizeDict | None = None,
+ min_pixels: int | None = None,
+ max_pixels: int | None = None,
+ **kwargs,
+ ) -> dict:
+ if min_pixels is not None and max_pixels is not None:
+ size = SizeDict(shortest_edge=min_pixels, longest_edge=max_pixels)
+ kwargs = super()._standardize_kwargs(size=size, **kwargs)
+ size = kwargs.get("size", self.size)
+ if not size.shortest_edge or not size.longest_edge:
+ raise ValueError("size must contain 'shortest_edge' and 'longest_edge' keys.")
+ return kwargs
+
+ def sample_frames(
+ self,
+ metadata: VideoMetadata,
+ temporal_patch_size: int | None = None,
+ min_frames: int | None = None,
+ max_frames: int | None = None,
+ num_frames: int | None = None,
+ fps: int | float | None = None,
+ **kwargs,
+ ):
+ """
+ Default sampling function which uniformly samples the desired number of frames between 0 and total number of frames.
+ If `fps` is passed along with metadata, `fps` frames per second are sampled uniformty. Arguments `num_frames`
+ and `fps` are mutually exclusive.
+
+ Args:
+ metadata (`VideoMetadata`):
+ Metadata of the video containing information about total duration, fps and total number of frames.
+ temporal_patch_size (`int`, *optional*):
+ The temporal patch size of the vision encoder. Number of sampled frames will be rounded to be divisible by frame factor.
+ min_frames (`int`, *optional*):
+ The minimum number of frames that can be sampled.
+ max_frames (`int`, *optional*):
+ The maximum number of frames that can be sampled.
+ num_frames (`int`, *optional*):
+ Maximum number of frames to sample. Defaults to `self.num_frames`.
+ fps (`int` or `float`, *optional*):
+ Target frames to sample per second. Defaults to `self.fps`.
+
+ Returns:
+ np.ndarray:
+ Indices to sample video frames.
+ """
+ if fps is not None and num_frames is not None:
+ raise ValueError("`num_frames` and `fps` are mutually exclusive arguments, please use only one!")
+
+ num_frames = num_frames if num_frames is not None else self.num_frames
+ fps = fps if fps is not None else self.fps
+ temporal_patch_size = temporal_patch_size if temporal_patch_size is not None else self.temporal_patch_size
+ min_frames = min_frames if min_frames is not None else self.min_frames
+ max_frames = max_frames if max_frames is not None else self.max_frames
+ total_num_frames = metadata.total_num_frames
+
+ # If num_frames is not given but fps is, calculate num_frames from fps
+ if num_frames is not None:
+ num_frames = round(num_frames / temporal_patch_size) * temporal_patch_size
+ elif fps is not None:
+ if metadata is None or metadata.fps is None:
+ raise ValueError(
+ "Asked to sample `fps` frames per second but no video metadata was provided which is required when sampling with `fps`. "
+ "Please pass in `VideoMetadata` object or use a fixed `num_frames` per input video"
+ )
+ max_frames = math.floor(min(max_frames, total_num_frames) / temporal_patch_size) * temporal_patch_size
+ num_frames = total_num_frames / metadata.fps * fps
+ num_frames = min(max(num_frames, min_frames), max_frames, total_num_frames)
+ num_frames = math.floor(num_frames / temporal_patch_size) * temporal_patch_size
+
+ if num_frames > total_num_frames:
+ raise ValueError(
+ f"Video can't be sampled. The inferred `num_frames={num_frames}` exceeds `total_num_frames={total_num_frames}`. "
+ "Decrease `num_frames` or `fps` for sampling."
+ )
+
+ if num_frames is not None:
+ indices = torch.arange(0, total_num_frames, total_num_frames / num_frames).int()
+ else:
+ indices = torch.arange(0, total_num_frames).int()
+
+ return indices
+
+ def _preprocess(
+ self,
+ videos: list["torch.Tensor"],
+ do_convert_rgb: bool,
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | int | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ patch_size: int | None = None,
+ temporal_patch_size: int | None = None,
+ merge_size: int | None = None,
+ use_token_compression: bool | None = None,
+ return_tensors: str | TensorType | None = None,
+ device: Optional["torch.Tensor"] = None,
+ **kwargs,
+ ):
+ # Group videos by size for batched resizing
+ grouped_videos, grouped_videos_index = group_videos_by_shape(videos)
+ resized_videos_grouped = {}
+ for shape, stacked_videos in grouped_videos.items():
+ height, width = get_image_size(stacked_videos[0], channel_dim=ChannelDimension.FIRST)
+ resized_height, resized_width = height, width
+ if do_resize:
+ resized_height, resized_width = smart_resize(
+ height,
+ width,
+ factor=patch_size * merge_size,
+ min_pixels=size["shortest_edge"],
+ max_pixels=size["longest_edge"] // shape[0],
+ )
+ stacked_videos = self.resize(
+ image=stacked_videos,
+ size=SizeDict(height=resized_height, width=resized_width),
+ resample=resample,
+ )
+ resized_videos_grouped[shape] = stacked_videos
+ resized_videos = reorder_videos(resized_videos_grouped, grouped_videos_index)
+
+ # Group videos by size for further processing
+ # Needed in case do_resize is False, or resize returns videos with different sizes
+ grouped_videos, grouped_videos_index = group_videos_by_shape(resized_videos)
+ processed_videos_grouped = {}
+ processed_grids = {}
+ for shape, stacked_videos in grouped_videos.items():
+ resized_height, resized_width = get_image_size(stacked_videos[0], channel_dim=ChannelDimension.FIRST)
+
+ # Fused rescale and normalize
+ stacked_videos = self.rescale_and_normalize(
+ stacked_videos, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ patches = stacked_videos
+
+ # Check that videos have `num_frames` divisible by `temporal_patch_size`
+ if patches.shape[1] % temporal_patch_size != 0:
+ repeats = patches[:, -1:].repeat(1, self.temporal_patch_size - 1, 1, 1, 1)
+ patches = torch.cat([patches, repeats], dim=1)
+
+ batch_size, grid_t, channel = patches.shape[:3]
+ grid_t = grid_t // temporal_patch_size
+ grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
+
+ patches = patches.view(
+ batch_size,
+ grid_t,
+ temporal_patch_size,
+ channel,
+ grid_h // merge_size,
+ merge_size,
+ patch_size,
+ grid_w // merge_size,
+ merge_size,
+ patch_size,
+ )
+ patches = patches.permute(0, 1, 4, 7, 5, 8, 3, 2, 6, 9)
+ flatten_patches = patches.reshape(
+ batch_size,
+ grid_t * grid_h * grid_w,
+ channel * temporal_patch_size * patch_size * patch_size,
+ )
+
+ processed_videos_grouped[shape] = flatten_patches
+ processed_grids[shape] = [[grid_t, grid_h, grid_w]] * batch_size
+
+ processed_videos = reorder_videos(processed_videos_grouped, grouped_videos_index)
+ processed_grids = reorder_videos(processed_grids, grouped_videos_index)
+ pixel_values_videos = torch.cat(processed_videos, dim=0)
+ video_grid_thw = torch.tensor(processed_grids)
+ video_merge_sizes = torch.full(
+ (video_grid_thw.size(0),), merge_size, dtype=video_grid_thw.dtype, device=video_grid_thw.device
+ )
+
+ if use_token_compression:
+ video_compression_mask = self._get_compression_mask(
+ pixel_values_videos=pixel_values_videos,
+ video_grid_thw=video_grid_thw,
+ video_merge_sizes=video_merge_sizes,
+ )
+ else:
+ num_video_tokens = video_grid_thw.prod(-1).sum() // (merge_size**2)
+ video_compression_mask = torch.ones(
+ (num_video_tokens,), dtype=torch.bool, device=pixel_values_videos.device
+ )
+
+ return BatchFeature(
+ data={
+ "pixel_values_videos": pixel_values_videos,
+ "video_grid_thw": video_grid_thw,
+ "video_merge_sizes": video_merge_sizes,
+ "video_compression_mask": video_compression_mask,
+ },
+ tensor_type=return_tensors,
+ )
+
+ def get_num_of_video_patches(self, num_frames: int, height: int, width: int, videos_kwargs=None):
+ """
+ A utility that returns number of video patches a given video size.
+
+ Args:
+ num_frames (`int`):
+ Number of frames in the input video.
+ height (`int`):
+ Height of the input video.
+ width (`int`):
+ Width of the input video.
+ videos_kwargs (`dict`, *optional*)
+ Any kwargs to override defaults of the video processor.
+ Returns:
+ `Tuple(int, int)`: Number of placeholder tokens required and number of patches per image.
+ """
+ min_pixels = videos_kwargs.get("min_pixels", None) or self.size["shortest_edge"]
+ max_pixels = videos_kwargs.get("max_pixels", None) or self.size["longest_edge"]
+ patch_size = videos_kwargs.get("patch_size", None) or self.patch_size
+ merge_size = videos_kwargs.get("merge_size", None) or self.merge_size
+ temporal_patch_size = videos_kwargs.get("temporal_patch_size", None) or self.temporal_patch_size
+
+ factor = patch_size * merge_size
+ resized_height, resized_width = smart_resize(
+ height, width, factor, min_pixels=min_pixels, max_pixels=max_pixels
+ )
+ grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
+ grid_t = num_frames // temporal_patch_size
+ return grid_t * grid_h * grid_w
+
+ def _get_compression_mask(
+ self,
+ pixel_values_videos: torch.FloatTensor,
+ video_grid_thw: torch.LongTensor,
+ video_merge_sizes: torch.LongTensor,
+ threshold: float | None = 0.1,
+ min_tokens: int | None = 1,
+ ) -> torch.BoolTensor:
+ """
+ Get the compression mask for video tokens based on pixel differences.
+ Args:
+ pixel_values_videos (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)`):
+ The tensors corresponding to the input videos.
+ video_grid_thw (`torch.LongTensor` of shape `(num_videos, 3)`, *optional*):
+ The temporal, height and width of feature shape of each video in LLM.
+ video_merge_sizes (`torch.Tensor` of shape `(num_videos,)`):
+ The spatial downsampling ratio of each video feature.
+ threshold (`float`, *optional*, defaults to 0.1):
+ The threshold to determine whether a token should be kept based on pixel differences.
+ min_tokens (`int`, *optional*, defaults to 1):
+ The minimum number of tokens to keep for each frame.
+ """
+ videos = pixel_values_videos.split(video_grid_thw.prod(dim=1).tolist(), dim=0)
+ compression_masks = []
+
+ for images, grid_size, merge_size in zip(videos, video_grid_thw, video_merge_sizes):
+ t, h, w = grid_size
+ if t == 1:
+ num_tokens = images.size(0) // (merge_size**2)
+ compression_masks.append(torch.ones((num_tokens,), dtype=torch.bool, device=images.device))
+ else:
+ # NOTE: video token compressor
+ images = images.view(t, (h // merge_size) * (w // merge_size), -1)
+
+ pixel_diff = images[1:] - images[:-1]
+ pixel_diff = torch.abs(pixel_diff).mean(dim=-1) * 255
+ pixel_diff = torch.cat([torch.full_like(pixel_diff[0:1], threshold + 1), pixel_diff], dim=0)
+ mask = pixel_diff > threshold
+ padding_ids = torch.nonzero(mask.sum(dim=1) < min_tokens)[:, 0]
+ mask[padding_ids, :min_tokens] = 1
+ compression_masks.append(mask.flatten())
+
+ return torch.cat(compression_masks)
+
+
+__all__ = ["VideoLlama3VideoProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/__init__.py b/lib/python3.11/site-packages/transformers/models/video_llava/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb5f5971a167997ffc89de76d5cc5ba3d8216b4b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llava/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2024 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_video_llava import *
+ from .image_processing_video_llava import *
+ from .modeling_video_llava import *
+ from .processing_video_llava import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dbd5a5453762bcb40cfe697d182fa287929492af
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/configuration_video_llava.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/configuration_video_llava.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..568e928cb0d2e6a00169f992b06b62ca40274635
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/configuration_video_llava.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/image_processing_video_llava.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/image_processing_video_llava.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8ec6deea26f3790ec783b51a44c5883a94149fae
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/image_processing_video_llava.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/modeling_video_llava.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/modeling_video_llava.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8d181dd50938fb28ff19707aa8e0a58f366ed65f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/modeling_video_llava.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/processing_video_llava.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/processing_video_llava.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..665cbfe75ccbf2400cdeb10d7121e7c1fbca07d8
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/processing_video_llava.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/video_processing_video_llava.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/video_processing_video_llava.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4a27ff8c92e4ea893ae55a905f2b1c1245762f78
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/video_llava/__pycache__/video_processing_video_llava.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/configuration_video_llava.py b/lib/python3.11/site-packages/transformers/models/video_llava/configuration_video_llava.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b02aa2a24bf351104e2637e9ffb9125fb53ebaa
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llava/configuration_video_llava.py
@@ -0,0 +1,100 @@
+# Copyright 2024 Microsoft Research & University of Wisconsin-Madison and the HuggingFace Inc. 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.
+"""VideoLlava model configuration"""
+
+from typing import Literal
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring, logging
+from ..auto import CONFIG_MAPPING, AutoConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="LanguageBind/Video-LLaVA-7B-hf")
+@strict
+class VideoLlavaConfig(PreTrainedConfig):
+ r"""
+ Example:
+
+ ```python
+ >>> from transformers import VideoLlavaForConditionalGeneration, VideoLlavaConfig, CLIPVisionConfig, LlamaConfig
+
+ >>> # Initializing a CLIP-vision config
+ >>> vision_config = CLIPVisionConfig()
+
+ >>> # Initializing a Llama config
+ >>> text_config = LlamaConfig()
+
+ >>> # Initializing a VideoLlava video_llava-1.5-7b style configuration
+ >>> configuration = VideoLlavaConfig(vision_config, text_config)
+
+ >>> # Initializing a model from the video_llava-1.5-7b style configuration
+ >>> model = VideoLlavaForConditionalGeneration(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "video_llava"
+ attribute_map = {
+ "image_token_id": "image_token_index",
+ "video_token_id": "video_token_index",
+ }
+ sub_configs = {"text_config": AutoConfig, "vision_config": AutoConfig}
+
+ vision_config: dict | PreTrainedConfig | None = None
+ text_config: dict | PreTrainedConfig | None = None
+ image_token_index: int = 32000
+ video_token_index: int = 32001
+ projector_hidden_act: str = "gelu"
+ vision_feature_select_strategy: Literal["default", "full"] = "default"
+ vision_feature_layer: int | list[int] = -2
+ image_seq_length: int = 256
+ video_seq_length: int = 2056
+ multimodal_projector_bias: bool = True
+ tie_word_embeddings: bool = False
+
+ def __post_init__(self, **kwargs):
+ if isinstance(self.vision_config, dict):
+ if "model_type" not in self.vision_config:
+ self.vision_config["model_type"] = "clip_vision_model"
+ logger.warning("Key=`model_type` not found in vision config, setting it to `clip_vision_model`")
+ self.vision_config = CONFIG_MAPPING[self.vision_config["model_type"]](**self.vision_config)
+ elif self.vision_config is None:
+ self.vision_config = CONFIG_MAPPING["clip_vision_model"](
+ intermediate_size=4096,
+ hidden_size=1024,
+ patch_size=14,
+ image_size=224,
+ num_hidden_layers=24,
+ num_attention_heads=16,
+ vocab_size=32000,
+ projection_dim=768,
+ )
+
+ if isinstance(self.text_config, dict):
+ if "model_type" not in self.text_config:
+ self.text_config["model_type"] = "llama"
+ logger.warning("Key=`model_type` not found in text config, setting it to `llama`")
+ self.text_config = CONFIG_MAPPING[self.text_config["model_type"]](**self.text_config)
+ elif self.text_config is None:
+ self.text_config = CONFIG_MAPPING["llama"]()
+
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["VideoLlavaConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/image_processing_video_llava.py b/lib/python3.11/site-packages/transformers/models/video_llava/image_processing_video_llava.py
new file mode 100644
index 0000000000000000000000000000000000000000..d462a00d026022575663cfb1491c6c37c4dc8eb9
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llava/image_processing_video_llava.py
@@ -0,0 +1,344 @@
+# Copyright 2024 The HuggingFace Inc. 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.
+"""Image processor class for Video-LLaVA."""
+
+import numpy as np
+
+from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
+from ...image_transforms import (
+ convert_to_rgb,
+ get_resize_output_image_size,
+ resize,
+ to_channel_dimension_format,
+)
+from ...image_utils import (
+ OPENAI_CLIP_MEAN,
+ OPENAI_CLIP_STD,
+ ChannelDimension,
+ ImageInput,
+ PILImageResampling,
+ infer_channel_dimension_format,
+ is_scaled_image,
+ make_flat_list_of_images,
+ to_numpy_array,
+ valid_images,
+ validate_preprocess_arguments,
+)
+from ...utils import TensorType, filter_out_non_signature_kwargs, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class VideoLlavaImageProcessor(BaseImageProcessor):
+ r"""
+ Constructs a CLIP image processor.
+
+ Args:
+ do_resize (`bool`, *optional*, defaults to `True`):
+ Whether to resize the image's (height, width) dimensions to the specified `size`. Can be overridden by
+ `do_resize` in the `preprocess` method.
+ size (`dict[str, int]` *optional*, defaults to `{"shortest_edge": 224}`):
+ Size of the image after resizing. The shortest edge of the image is resized to size["shortest_edge"], with
+ the longest edge resized to keep the input aspect ratio. Can be overridden by `size` in the `preprocess`
+ method.
+ resample (`PILImageResampling`, *optional*, defaults to `Resampling.BICUBIC`):
+ Resampling filter to use if resizing the image. Can be overridden by `resample` in the `preprocess` method.
+ do_center_crop (`bool`, *optional*, defaults to `True`):
+ Whether to center crop the image to the specified `crop_size`. Can be overridden by `do_center_crop` in the
+ `preprocess` method.
+ crop_size (`dict[str, int]` *optional*, defaults to 224):
+ Size of the output image after applying `center_crop`. Can be overridden by `crop_size` in the `preprocess`
+ method.
+ do_rescale (`bool`, *optional*, defaults to `True`):
+ Whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by `do_rescale` in
+ the `preprocess` method.
+ rescale_factor (`int` or `float`, *optional*, defaults to `1/255`):
+ Scale factor to use if rescaling the image. Can be overridden by `rescale_factor` in the `preprocess`
+ method.
+ do_normalize (`bool`, *optional*, defaults to `True`):
+ Whether to normalize the image. Can be overridden by `do_normalize` in the `preprocess` method.
+ image_mean (`float` or `list[float]`, *optional*, defaults to `[0.48145466, 0.4578275, 0.40821073]`):
+ Mean to use if normalizing the image. This is a float or list of floats the length of the number of
+ channels in the image. Can be overridden by the `image_mean` parameter in the `preprocess` method.
+ image_std (`float` or `list[float]`, *optional*, defaults to `[0.26862954, 0.26130258, 0.27577711]`):
+ Standard deviation to use if normalizing the image. This is a float or list of floats the length of the
+ number of channels in the image. Can be overridden by the `image_std` parameter in the `preprocess` method.
+ Can be overridden by the `image_std` parameter in the `preprocess` method.
+ do_convert_rgb (`bool`, *optional*, defaults to `True`):
+ Whether to convert the image to RGB.
+ """
+
+ model_input_names = ["pixel_values"]
+
+ def __init__(
+ self,
+ do_resize: bool = True,
+ size: dict[str, int] | None = None,
+ resample: PILImageResampling = PILImageResampling.BICUBIC,
+ do_center_crop: bool = True,
+ crop_size: dict[str, int] | None = None,
+ do_rescale: bool = True,
+ rescale_factor: int | float = 1 / 255,
+ do_normalize: bool = True,
+ image_mean: float | list[float] | None = None,
+ image_std: float | list[float] | None = None,
+ do_convert_rgb: bool = True,
+ **kwargs,
+ ) -> None:
+ super().__init__(**kwargs)
+ size = size if size is not None else {"shortest_edge": 224}
+ size = get_size_dict(size, default_to_square=False)
+ crop_size = crop_size if crop_size is not None else {"height": 224, "width": 224}
+ crop_size = get_size_dict(crop_size, default_to_square=True, param_name="crop_size")
+
+ self.do_resize = do_resize
+ self.size = size
+ self.resample = resample
+ self.do_center_crop = do_center_crop
+ self.crop_size = crop_size
+ self.do_rescale = do_rescale
+ self.rescale_factor = rescale_factor
+ self.do_normalize = do_normalize
+ self.image_mean = image_mean if image_mean is not None else OPENAI_CLIP_MEAN
+ self.image_std = image_std if image_std is not None else OPENAI_CLIP_STD
+ self.do_convert_rgb = do_convert_rgb
+
+ def resize(
+ self,
+ image: np.ndarray,
+ size: dict[str, int],
+ resample: PILImageResampling = PILImageResampling.BICUBIC,
+ data_format: str | ChannelDimension | None = None,
+ input_data_format: str | ChannelDimension | None = None,
+ **kwargs,
+ ) -> np.ndarray:
+ """
+ Resize an image. The shortest edge of the image is resized to size["shortest_edge"], with the longest edge
+ resized to keep the input aspect ratio.
+
+ Args:
+ image (`np.ndarray`):
+ Image to resize.
+ size (`dict[str, int]`):
+ Size of the output image.
+ resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BICUBIC`):
+ Resampling filter to use when resiizing the image.
+ data_format (`str` or `ChannelDimension`, *optional*):
+ The channel dimension format of the image. If not provided, it will be the same as the input image.
+ input_data_format (`ChannelDimension` or `str`, *optional*):
+ The channel dimension format of the input image. If not provided, it will be inferred.
+ """
+ default_to_square = True
+ if "shortest_edge" in size:
+ size = size["shortest_edge"]
+ default_to_square = False
+ elif "height" in size and "width" in size:
+ size = (size["height"], size["width"])
+ else:
+ raise ValueError("Size must contain either 'shortest_edge' or 'height' and 'width'.")
+
+ output_size = get_resize_output_image_size(
+ image,
+ size=size,
+ default_to_square=default_to_square,
+ input_data_format=input_data_format,
+ )
+ return resize(
+ image,
+ size=output_size,
+ resample=resample,
+ data_format=data_format,
+ input_data_format=input_data_format,
+ **kwargs,
+ )
+
+ @filter_out_non_signature_kwargs()
+ def preprocess(
+ self,
+ images: list[ImageInput] | None = None,
+ do_resize: bool | None = None,
+ size: dict[str, int] | None = None,
+ resample: PILImageResampling | None = None,
+ do_center_crop: bool | None = None,
+ crop_size: int | None = None,
+ do_rescale: bool | None = None,
+ rescale_factor: float | None = None,
+ do_normalize: bool | None = None,
+ image_mean: float | list[float] | None = None,
+ image_std: float | list[float] | None = None,
+ do_convert_rgb: bool | None = None,
+ return_tensors: str | TensorType | None = None,
+ data_format: ChannelDimension | None = ChannelDimension.FIRST,
+ input_data_format: str | ChannelDimension | None = None,
+ ) -> BatchFeature:
+ """
+ Preprocess an image or batch of images.
+
+ Args:
+ images (`ImageInput`, *optional*):
+ List of images to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If
+ passing in images with pixel values between 0 and 1, set `do_rescale=False`.
+ do_resize (`bool`, *optional*, defaults to `self.do_resize`):
+ Whether to resize the image.
+ size (`dict[str, int]`, *optional*, defaults to `self.size`):
+ Size of the image after resizing. Shortest edge of the image is resized to size["shortest_edge"], with
+ the longest edge resized to keep the input aspect ratio.
+ resample (`int`, *optional*, defaults to `self.resample`):
+ Resampling filter to use if resizing the image. This can be one of the enum `PILImageResampling`. Only
+ has an effect if `do_resize` is set to `True`.
+ do_center_crop (`bool`, *optional*, defaults to `self.do_center_crop`):
+ Whether to center crop the image.
+ crop_size (`dict[str, int]`, *optional*, defaults to `self.crop_size`):
+ Size of the center crop. Only has an effect if `do_center_crop` is set to `True`.
+ do_rescale (`bool`, *optional*, defaults to `self.do_rescale`):
+ Whether to rescale the image.
+ rescale_factor (`float`, *optional*, defaults to `self.rescale_factor`):
+ Rescale factor to rescale the image by if `do_rescale` is set to `True`.
+ do_normalize (`bool`, *optional*, defaults to `self.do_normalize`):
+ Whether to normalize the image.
+ image_mean (`float` or `list[float]`, *optional*, defaults to `self.image_mean`):
+ Image mean to use for normalization. Only has an effect if `do_normalize` is set to `True`.
+ image_std (`float` or `list[float]`, *optional*, defaults to `self.image_std`):
+ Image standard deviation to use for normalization. Only has an effect if `do_normalize` is set to
+ `True`.
+ do_convert_rgb (`bool`, *optional*, defaults to `self.do_convert_rgb`):
+ Whether to convert the image to RGB.
+ return_tensors (`str` or `TensorType`, *optional*):
+ The type of tensors to return. Can be one of:
+ - Unset: Return a list of `np.ndarray`.
+ - `TensorType.PYTORCH` or `'pt'`: Return a batch of type `torch.Tensor`.
+ - `TensorType.NUMPY` or `'np'`: Return a batch of type `np.ndarray`.
+ data_format (`ChannelDimension` or `str`, *optional*, defaults to `ChannelDimension.FIRST`):
+ The channel dimension format for the output image. Can be one of:
+ - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
+ - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
+ - Unset: Use the channel dimension format of the input image.
+ input_data_format (`ChannelDimension` or `str`, *optional*):
+ The channel dimension format for the input image. If unset, the channel dimension format is inferred
+ from the input image. Can be one of:
+ - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
+ - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
+ - `"none"` or `ChannelDimension.NONE`: image in (height, width) format.
+ """
+ do_resize = do_resize if do_resize is not None else self.do_resize
+ size = size if size is not None else self.size
+ size = get_size_dict(size, param_name="size", default_to_square=False)
+ resample = resample if resample is not None else self.resample
+ do_center_crop = do_center_crop if do_center_crop is not None else self.do_center_crop
+ crop_size = crop_size if crop_size is not None else self.crop_size
+ crop_size = get_size_dict(crop_size, param_name="crop_size", default_to_square=True)
+ do_rescale = do_rescale if do_rescale is not None else self.do_rescale
+ rescale_factor = rescale_factor if rescale_factor is not None else self.rescale_factor
+ do_normalize = do_normalize if do_normalize is not None else self.do_normalize
+ image_mean = image_mean if image_mean is not None else self.image_mean
+ image_std = image_std if image_std is not None else self.image_std
+ do_convert_rgb = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
+
+ if images is not None:
+ images = self.fetch_images(images)
+ images = make_flat_list_of_images(images)
+
+ if images is not None and not valid_images(images):
+ raise ValueError("Invalid input type. Must be of type PIL.Image.Image, numpy.ndarray, or torch.Tensor")
+
+ pixel_values_images = [
+ self._preprocess_image(
+ image=image,
+ do_resize=do_resize,
+ size=size,
+ resample=resample,
+ do_rescale=do_rescale,
+ rescale_factor=rescale_factor,
+ do_normalize=do_normalize,
+ image_mean=image_mean,
+ image_std=image_std,
+ do_center_crop=do_center_crop,
+ crop_size=crop_size,
+ do_convert_rgb=do_convert_rgb,
+ data_format=data_format,
+ input_data_format=input_data_format,
+ )
+ for image in images
+ ]
+ data = {"pixel_values_images": pixel_values_images}
+ encoded_outputs = BatchFeature(data, tensor_type=return_tensors)
+
+ return encoded_outputs
+
+ def _preprocess_image(
+ self,
+ image: ImageInput | None = None,
+ do_resize: bool | None = None,
+ size: dict[str, int] | None = None,
+ resample: PILImageResampling | None = None,
+ do_rescale: bool | None = None,
+ rescale_factor: float | None = None,
+ do_normalize: bool | None = None,
+ image_mean: float | list[float] | None = None,
+ image_std: float | list[float] | None = None,
+ do_center_crop: bool | None = None,
+ crop_size: int | None = None,
+ do_convert_rgb: bool | None = None,
+ data_format: ChannelDimension = ChannelDimension.FIRST,
+ input_data_format: str | ChannelDimension | None = None,
+ ) -> np.ndarray:
+ validate_preprocess_arguments(
+ do_rescale=do_rescale,
+ rescale_factor=rescale_factor,
+ do_normalize=do_normalize,
+ image_mean=image_mean,
+ image_std=image_std,
+ do_center_crop=do_center_crop,
+ crop_size=crop_size,
+ do_resize=do_resize,
+ size=size,
+ resample=resample,
+ )
+
+ # PIL RGBA images are converted to RGB
+ if do_convert_rgb:
+ image = convert_to_rgb(image)
+
+ # All transformations expect numpy arrays.
+ image = to_numpy_array(image)
+
+ if do_rescale and is_scaled_image(image):
+ logger.warning_once(
+ "It looks like you are trying to rescale already rescaled images/video frames. If the input"
+ " images have pixel values between 0 and 1, set `do_rescale=False` to avoid rescaling them again."
+ )
+
+ if input_data_format is None:
+ # We assume that all images have the same channel dimension format.
+ input_data_format = infer_channel_dimension_format(image)
+
+ if do_resize:
+ image = self.resize(image=image, size=size, resample=resample, input_data_format=input_data_format)
+
+ if do_center_crop:
+ image = self.center_crop(image=image, size=crop_size, input_data_format=input_data_format)
+
+ if do_rescale:
+ image = self.rescale(image=image, scale=rescale_factor, input_data_format=input_data_format)
+
+ if do_normalize:
+ image = self.normalize(image=image, mean=image_mean, std=image_std, input_data_format=input_data_format)
+
+ image = to_channel_dimension_format(image, data_format, input_channel_dim=input_data_format)
+
+ return image
+
+
+__all__ = ["VideoLlavaImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/modeling_video_llava.py b/lib/python3.11/site-packages/transformers/models/video_llava/modeling_video_llava.py
new file mode 100644
index 0000000000000000000000000000000000000000..a14ee23172bc59302ff5fb8bb3b566bbc0a9cd05
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llava/modeling_video_llava.py
@@ -0,0 +1,579 @@
+# Copyright 2024 the HuggingFace Inc. 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.
+"""PyTorch VideoLlava model."""
+
+from dataclasses import dataclass
+
+import torch
+from torch import nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache
+from ...generation import GenerationMixin
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_outputs import BaseModelOutputWithPooling, ModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, logging, torch_compilable_check
+from ...utils.generic import can_return_tuple, merge_with_config_defaults
+from ..auto import AutoModel
+from .configuration_video_llava import VideoLlavaConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for VideoLlava base model outputs.
+ """
+)
+@dataclass
+class VideoLlavaModelOutputWithPast(ModelOutput):
+ r"""
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
+ `past_key_values` input) to speed up sequential decoding.
+ image_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size (batch_size, num_images, sequence_length, hidden_size)`.
+ image_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ video_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(batch_size * num_frames, num_videos, sequence_length, hidden_size)`.
+ video_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ """
+
+ last_hidden_state: torch.FloatTensor | None = None
+ past_key_values: Cache | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+ image_hidden_states: torch.FloatTensor | None = None
+ video_hidden_states: torch.FloatTensor | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Base class for VideoLlava causal language model (or autoregressive) outputs.
+ """
+)
+@dataclass
+class VideoLlavaCausalLMOutputWithPast(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+ Language modeling loss (for next-token prediction).
+ logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
+ Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+ past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+ It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
+ `past_key_values` input) to speed up sequential decoding.
+ image_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size (batch_size, num_images, sequence_length, hidden_size)`.
+ image_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ video_hidden_states (`torch.FloatTensor`, *optional*):
+ A `torch.FloatTensor` of size `(batch_size * num_frames, num_videos, sequence_length, hidden_size)`.
+ video_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ past_key_values: Cache | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+ image_hidden_states: torch.FloatTensor | None = None
+ video_hidden_states: torch.FloatTensor | None = None
+
+
+# Copied from transformers.models.llava.modeling_llava.LlavaMultiModalProjector with Llava->VideoLlava
+class VideoLlavaMultiModalProjector(nn.Module):
+ def __init__(self, config: VideoLlavaConfig):
+ super().__init__()
+ # We have hidden_size * the number of vision feature layers
+ num_feature_layers = 1 if isinstance(config.vision_feature_layer, int) else len(config.vision_feature_layer)
+ self.linear_1 = nn.Linear(
+ config.vision_config.hidden_size * num_feature_layers,
+ config.text_config.hidden_size,
+ bias=config.multimodal_projector_bias,
+ )
+ self.act = ACT2FN[config.projector_hidden_act]
+ self.linear_2 = nn.Linear(
+ config.text_config.hidden_size, config.text_config.hidden_size, bias=config.multimodal_projector_bias
+ )
+
+ def forward(self, image_features):
+ hidden_states = self.linear_1(image_features)
+ hidden_states = self.act(hidden_states)
+ hidden_states = self.linear_2(hidden_states)
+ return hidden_states
+
+
+@auto_docstring
+class VideoLlavaPreTrainedModel(PreTrainedModel):
+ config: VideoLlavaConfig
+ base_model_prefix = "model"
+ input_modalities = ("image", "video", "text")
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["VideoLlavaVisionAttention"]
+ _skip_keys_device_placement = ["past_key_values"]
+ _supports_flash_attn = True
+ _supports_sdpa = True
+ _can_compile_fullgraph = True
+ _supports_attention_backend = True
+
+ @torch.no_grad()
+ def _init_weights(self, module):
+ super()._init_weights(module)
+ std = (
+ self.config.initializer_range
+ if hasattr(self.config, "initializer_range")
+ else self.config.text_config.initializer_range
+ )
+ if hasattr(module, "class_embedding"):
+ init.normal_(module.class_embedding, mean=0.0, std=std)
+
+
+@auto_docstring(
+ custom_intro="""
+ The VideoLlava model which consists of a vision backbone and a language model without language modeling head.
+ """,
+)
+class VideoLlavaModel(VideoLlavaPreTrainedModel):
+ def __init__(self, config: VideoLlavaConfig):
+ super().__init__(config)
+ self.video_tower = AutoModel.from_config(config.vision_config)
+ self.image_tower = AutoModel.from_config(config.vision_config)
+
+ self.multi_modal_projector = VideoLlavaMultiModalProjector(config)
+ self.vocab_size = config.text_config.vocab_size
+ self.language_model = AutoModel.from_config(config.text_config)
+ self.post_init()
+
+ @merge_with_config_defaults
+ @can_return_tuple
+ @auto_docstring(
+ custom_intro="Obtains image last hidden states from the vision tower and apply multimodal projection."
+ )
+ def get_image_features(
+ self,
+ pixel_values_images: torch.FloatTensor,
+ vision_feature_layer: int | list[int] | list[int] | None = None,
+ vision_feature_select_strategy: str | None = None,
+ output_hidden_states: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values_images (`torch.FloatTensor]` of shape `(batch_size, channels, height, width)`)
+ The tensors corresponding to the input images.
+ vision_feature_layer (`Union[int, list[int]]`, *optional*):
+ The index of the layer to select the vision feature. If multiple indices are provided,
+ the vision feature of the corresponding indices will be concatenated to form the
+ vision features.
+ vision_feature_select_strategy (`str`, *optional*):
+ The feature selection strategy used to select the vision feature from the vision backbone.
+ Can be one of `"default"` or `"full"`
+ """
+ image_outputs = self.image_tower(
+ pixel_values_images,
+ output_hidden_states=True, # Ignore arg on purpose
+ return_dict=True,
+ **kwargs,
+ )
+
+ # If we have one vision feature layer, return the corresponding hidden states,
+ # otherwise, select the hidden states of each feature layer and concatenate them
+ if isinstance(vision_feature_layer, int):
+ selected_hidden_state = image_outputs.hidden_states[vision_feature_layer]
+ if vision_feature_select_strategy == "default":
+ selected_hidden_state = selected_hidden_state[:, 1:]
+ else:
+ hs_pool = [image_outputs.hidden_states[layer_idx] for layer_idx in vision_feature_layer]
+ # For default; crop CLS from each hidden state in the hidden state pool
+ if vision_feature_select_strategy == "default":
+ hs_pool = [hs[:, 1:] for hs in hs_pool]
+ selected_hidden_state = torch.cat(hs_pool, dim=-1)
+
+ image_features = self.multi_modal_projector(selected_hidden_state)
+ image_outputs.pooler_output = image_features
+
+ return image_outputs
+
+ @merge_with_config_defaults
+ @can_return_tuple
+ @auto_docstring(
+ custom_intro="Obtains video last hidden states from the vision tower and apply multimodal projection."
+ )
+ def get_video_features(
+ self,
+ pixel_values_videos: torch.FloatTensor,
+ vision_feature_layer: int | list[int] | list[int] | None = None,
+ output_hidden_states: bool | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values_videos (`torch.FloatTensor]` of shape `(batch_size, num_frames, channels, height, width)`)
+ The tensors corresponding to the input videos.
+ vision_feature_layer (`Union[int, list[int]]`, *optional*):
+ The index of the layer to select the vision feature. If multiple indices are provided,
+ the vision feature of the corresponding indices will be concatenated to form the
+ vision features.
+ """
+ batch_size_vid, num_frames, channels, height, width = pixel_values_videos.shape
+
+ pixel_values = pixel_values_videos.reshape(batch_size_vid * num_frames, channels, height, width)
+ video_outputs = self.video_tower(
+ pixel_values,
+ output_hidden_states=True, # Ignore arg on purpose
+ return_dict=True,
+ **kwargs,
+ )
+
+ # If we have one vision feature layer, return the corresponding hidden states,
+ # otherwise, select the hidden states of each feature layer and concatenate them
+ if isinstance(vision_feature_layer, int):
+ video_features = video_outputs.hidden_states[vision_feature_layer]
+ else:
+ hs_pool = [video_outputs.hidden_states[layer_idx] for layer_idx in vision_feature_layer]
+ video_features = torch.cat(hs_pool, dim=-1)
+
+ video_features = self.multi_modal_projector(video_features)
+ video_outputs.pooler_output = video_features
+
+ return video_outputs
+
+ def get_placeholder_mask(
+ self,
+ input_ids: torch.LongTensor,
+ inputs_embeds: torch.FloatTensor,
+ image_features: torch.FloatTensor | None = None,
+ video_features: torch.FloatTensor | None = None,
+ ):
+ """
+ Obtains multimodal placeholder mask from `input_ids` or `inputs_embeds`, and checks that the placeholder token count is
+ equal to the length of multimodal features. If the lengths are different, an error is raised.
+ """
+ if input_ids is None:
+ special_image_mask = inputs_embeds == self.get_input_embeddings()(
+ torch.tensor(self.config.image_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ special_image_mask = special_image_mask.all(-1)
+ special_video_mask = inputs_embeds == self.get_input_embeddings()(
+ torch.tensor(self.config.video_token_id, dtype=torch.long, device=inputs_embeds.device)
+ )
+ special_video_mask = special_video_mask.all(-1)
+ else:
+ special_image_mask = input_ids == self.config.image_token_id
+ special_video_mask = input_ids == self.config.video_token_id
+
+ n_image_tokens = special_image_mask.sum()
+ special_image_mask = special_image_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+ if image_features is not None:
+ torch_compilable_check(
+ inputs_embeds[special_image_mask].numel() == image_features.numel(),
+ f"Image features and image tokens do not match, tokens: {n_image_tokens}, features: {image_features.shape[0] * image_features.shape[1]}",
+ )
+
+ n_video_tokens = special_video_mask.sum()
+ special_video_mask = special_video_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+ if video_features is not None:
+ torch_compilable_check(
+ inputs_embeds[special_video_mask].numel() == video_features.numel(),
+ f"Video features and video tokens do not match, tokens: {n_video_tokens}, features: {video_features.shape[0] * video_features.shape[1]}",
+ )
+ return special_image_mask, special_video_mask
+
+ @merge_with_config_defaults
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values_images: torch.FloatTensor | None = None,
+ pixel_values_videos: torch.FloatTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ vision_feature_layer: int | list[int] | list[int] | None = None,
+ vision_feature_select_strategy: str | None = None,
+ use_cache: bool | None = None,
+ **kwargs: Unpack[FlashAttentionKwargs],
+ ) -> tuple | VideoLlavaModelOutputWithPast:
+ r"""
+ pixel_values_images (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)):
+ The tensors corresponding to the input images. Pixel values can be obtained using
+ [`AutoImageProcessor`]. See [`VideoLlavaImageProcessor.__call__`] for details ([]`LlavaProcessor`] uses
+ [`VideoLlavaImageProcessor`] for processing images).
+ """
+ if (input_ids is None) ^ (inputs_embeds is not None):
+ raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+ if inputs_embeds is None:
+ inputs_embeds = self.get_input_embeddings()(input_ids)
+
+ if pixel_values_images is not None:
+ image_features = self.get_image_features(
+ pixel_values_images,
+ vision_feature_layer=vision_feature_layer,
+ vision_feature_select_strategy=vision_feature_select_strategy,
+ return_dict=True,
+ ).pooler_output
+ image_features = image_features.to(inputs_embeds.device, inputs_embeds.dtype)
+ special_image_mask, _ = self.get_placeholder_mask(
+ input_ids, inputs_embeds=inputs_embeds, image_features=image_features
+ )
+ inputs_embeds = inputs_embeds.masked_scatter(special_image_mask, image_features)
+
+ if pixel_values_videos is not None:
+ video_features = self.get_video_features(
+ pixel_values_videos=pixel_values_videos, vision_feature_layer=vision_feature_layer, return_dict=True
+ ).pooler_output
+ video_features = video_features.to(inputs_embeds.device, inputs_embeds.dtype)
+ _, special_video_mask = self.get_placeholder_mask(
+ input_ids, inputs_embeds=inputs_embeds, video_features=video_features
+ )
+ inputs_embeds = inputs_embeds.masked_scatter(special_video_mask, video_features)
+
+ outputs = self.language_model(
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ **kwargs,
+ )
+
+ return VideoLlavaModelOutputWithPast(
+ last_hidden_state=outputs.last_hidden_state,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ image_hidden_states=image_features if pixel_values_images is not None else None,
+ video_hidden_states=video_features if pixel_values_videos is not None else None,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ The VideoLlava model which consists of a vision backbone and a language model.
+ """
+)
+class VideoLlavaForConditionalGeneration(VideoLlavaPreTrainedModel, GenerationMixin):
+ _tied_weights_keys = {"lm_head.weight": "model.language_model.embed_tokens.weight"}
+
+ def __init__(self, config: VideoLlavaConfig):
+ super().__init__(config)
+ self.model = VideoLlavaModel(config)
+ self.lm_head = nn.Linear(config.text_config.hidden_size, config.text_config.vocab_size, bias=False)
+ self.post_init()
+
+ def get_output_embeddings(self) -> nn.Module:
+ return self.lm_head
+
+ @merge_with_config_defaults
+ @can_return_tuple
+ @auto_docstring
+ def get_image_features(
+ self,
+ pixel_values_images: torch.FloatTensor,
+ vision_feature_layer: int | list[int] | list[int] | None = None,
+ vision_feature_select_strategy: str | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | BaseModelOutputWithPooling:
+ r"""
+ pixel_values_images (`torch.FloatTensor]` of shape `(batch_size, channels, height, width)`)
+ The tensors corresponding to the input images.
+ vision_feature_layer (`Union[int, list[int]]`, *optional*):
+ The index of the layer to select the vision feature. If multiple indices are provided,
+ the vision feature of the corresponding indices will be concatenated to form the
+ vision features.
+ vision_feature_select_strategy (`str`, *optional*):
+ The feature selection strategy used to select the vision feature from the vision backbone.
+ Can be one of `"default"` or `"full"`
+ """
+ return self.model.get_image_features(
+ pixel_values_images=pixel_values_images,
+ vision_feature_layer=vision_feature_layer,
+ vision_feature_select_strategy=vision_feature_select_strategy,
+ **kwargs,
+ )
+
+ @merge_with_config_defaults
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ input_ids: torch.LongTensor | None = None,
+ pixel_values_images: torch.FloatTensor | None = None,
+ pixel_values_videos: torch.FloatTensor | None = None,
+ attention_mask: torch.Tensor | None = None,
+ position_ids: torch.LongTensor | None = None,
+ past_key_values: Cache | None = None,
+ inputs_embeds: torch.FloatTensor | None = None,
+ vision_feature_layer: int | list[int] | list[int] | None = None,
+ vision_feature_select_strategy: str | None = None,
+ labels: torch.LongTensor | None = None,
+ use_cache: bool | None = None,
+ logits_to_keep: int | torch.Tensor = 0,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> tuple | VideoLlavaCausalLMOutputWithPast:
+ r"""
+ pixel_values_images (`torch.FloatTensor` of shape `(batch_size, num_channels, image_size, image_size)):
+ The tensors corresponding to the input images. Pixel values can be obtained using
+ [`AutoImageProcessor`]. See [`VideoLlavaImageProcessor.__call__`] for details ([]`LlavaProcessor`] uses
+ [`VideoLlavaImageProcessor`] for processing images).
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+ Example:
+
+ ```python
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+ >>> import numpy as np
+ >>> import av
+ >>> from huggingface_hub import hf_hub_download
+ >>> from transformers import VideoLlavaProcessor, VideoLlavaForConditionalGeneration
+
+ >>> def read_video_pyav(container, indices):
+ ... '''
+ ... Decode the video with PyAV decoder.
+ ... Args:
+ ... container (`av.container.input.InputContainer`): PyAV container.
+ ... indices (`list[int]`): List of frame indices to decode.
+ ... Returns:
+ ... result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
+ ... '''
+ ... frames = []
+ ... container.seek(0)
+ ... start_index = indices[0]
+ ... end_index = indices[-1]
+ ... for i, frame in enumerate(container.decode(video=0)):
+ ... if i > end_index:
+ ... break
+ ... if i >= start_index and i in indices:
+ ... frames.append(frame)
+ ... return np.stack([x.to_ndarray(format="rgb24") for x in frames])
+
+ >>> model = VideoLlavaForConditionalGeneration.from_pretrained("LanguageBind/Video-LLaVA-7B-hf")
+ >>> processor = VideoLlavaProcessor.from_pretrained("LanguageBind/Video-LLaVA-7B-hf")
+
+ >>> prompt = "USER: <video>\nWhy is this video funny? ASSISTANT:"
+ >>> video_path = hf_hub_download(repo_id="raushan-testing-hf/videos-test", filename="sample_demo_1.mp4", repo_type="dataset")
+ >>> container = av.open(video_path)
+
+ >>> # sample uniformly 8 frames from the video
+ >>> total_frames = container.streams.video[0].frames
+ >>> indices = np.arange(0, total_frames, total_frames / 8).astype(int)
+ >>> clip = read_video_pyav(container, indices)
+
+ >>> inputs = processor(text=prompt, videos=clip, return_tensors="pt")
+
+ >>> # Generate
+ >>> generate_ids = model.generate(**inputs, max_length=80)
+ >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+ "USER: Why is this video funny? ASSISTANT: The video is funny because the baby is playing with a Wii remote while sitting on the floor, and the baby is wearing glasses.Ъ. The baby's actions are amusing because it is a young child trying to interact with a video game, which is not a typical activity for a"
+
+ >>> # to generate from image and video mix
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read()))
+ >>> prompt = [
+ ... "USER: <image>\nHow many cats do you see? ASSISTANT:",
+ ... "USER: <video>\nWhy is this video funny? ASSISTANT:"
+ ... ]
+ >>> inputs = processor(text=prompt, images=image, videos=clip, padding=True, return_tensors="pt")
+
+ >>> # Generate
+ >>> generate_ids = model.generate(**inputs, max_length=50)
+ >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+ ['USER: How many cats do you see? ASSISTANT: There are two cats visible in the image. (or three, if you count the one in the background).', 'USER: Why is this video funny? ASSISTANT: The video is funny because it shows a baby sitting on a bed and playing with a Wii remote.Ъ. The baby is holding the remote']
+ ```
+ """
+ outputs = self.model(
+ input_ids=input_ids,
+ pixel_values_images=pixel_values_images,
+ pixel_values_videos=pixel_values_videos,
+ attention_mask=attention_mask,
+ position_ids=position_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ use_cache=use_cache,
+ vision_feature_layer=vision_feature_layer,
+ vision_feature_select_strategy=vision_feature_select_strategy,
+ **kwargs,
+ )
+
+ hidden_states = outputs[0]
+ # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+ slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+ logits = self.lm_head(hidden_states[:, slice_indices, :])
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(
+ logits=logits, labels=labels, vocab_size=self.config.text_config.vocab_size, **kwargs
+ )
+
+ return VideoLlavaCausalLMOutputWithPast(
+ loss=loss,
+ logits=logits,
+ past_key_values=outputs.past_key_values,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ image_hidden_states=outputs.image_hidden_states,
+ video_hidden_states=outputs.video_hidden_states,
+ )
+
+ def prepare_inputs_for_generation(
+ self,
+ input_ids,
+ past_key_values=None,
+ inputs_embeds=None,
+ pixel_values_images=None,
+ pixel_values_videos=None,
+ attention_mask=None,
+ logits_to_keep=None,
+ is_first_iteration=False,
+ **kwargs,
+ ):
+ # Overwritten -- in specific circumstances we don't want to forward image inputs to the model
+
+ model_inputs = super().prepare_inputs_for_generation(
+ input_ids,
+ past_key_values=past_key_values,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ logits_to_keep=logits_to_keep,
+ is_first_iteration=is_first_iteration,
+ **kwargs,
+ )
+
+ if is_first_iteration or not kwargs.get("use_cache", True):
+ # Pixel values are used only in the first iteration if available
+ # In subsequent iterations, they are already merged with text and cached
+ # NOTE: first iteration doesn't have to be prefill, it can be the first
+ # iteration with a question and cached system prompt (continue generate from cache)
+ model_inputs["pixel_values_images"] = pixel_values_images
+ model_inputs["pixel_values_videos"] = pixel_values_videos
+
+ return model_inputs
+
+
+__all__ = ["VideoLlavaPreTrainedModel", "VideoLlavaModel", "VideoLlavaForConditionalGeneration"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/processing_video_llava.py b/lib/python3.11/site-packages/transformers/models/video_llava/processing_video_llava.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a5e3336b0e906a158492ce68c15abeec743ddfc
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llava/processing_video_llava.py
@@ -0,0 +1,153 @@
+# Copyright 2023 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.
+"""
+Processor class for VideoLlava.
+"""
+
+import numpy as np
+
+from ...feature_extraction_utils import BatchFeature
+from ...image_utils import ImageInput, get_image_size, to_numpy_array
+from ...processing_utils import ProcessorMixin
+from ...tokenization_utils_base import PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
+from ...utils import TensorType, auto_docstring, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring
+class VideoLlavaProcessor(ProcessorMixin):
+ def __init__(
+ self,
+ image_processor=None,
+ video_processor=None,
+ tokenizer=None,
+ patch_size=14,
+ vision_feature_select_strategy="default",
+ image_token="<image>", # set the default and let users change if they have peculiar special tokens in rare cases
+ video_token="<video>",
+ chat_template=None,
+ num_additional_image_tokens=1,
+ **kwargs,
+ ):
+ r"""
+ patch_size (`int`, *optional*, defaults to 14):
+ Patch size from the vision tower.
+ vision_feature_select_strategy (`str`, *optional*, defaults to `"default"`):
+ The feature selection strategy used to select the vision feature from the vision backbone.
+ Should be same as in model's config
+ image_token (`str`, *optional*, defaults to `"<image>"`):
+ Special token used to denote image location.
+ video_token (`str`, *optional*, defaults to `"<video>"`):
+ Special token used to denote video location.
+ num_additional_image_tokens (`int`, *optional*, defaults to 1):
+ Number of additional tokens added to the image embeddings, such as CLS (+1). If the backbone has no CLS or other
+ extra tokens appended, no need to set this arg.
+ """
+ self.patch_size = patch_size
+ self.num_additional_image_tokens = num_additional_image_tokens
+ self.vision_feature_select_strategy = vision_feature_select_strategy
+ self.image_token = tokenizer.image_token if hasattr(tokenizer, "image_token") else image_token
+ self.video_token = tokenizer.video_token if hasattr(tokenizer, "video_token") else video_token
+ self.image_token_id = tokenizer.convert_tokens_to_ids(self.image_token)
+ self.video_token_id = tokenizer.convert_tokens_to_ids(self.video_token)
+ super().__init__(image_processor, video_processor, tokenizer, chat_template=chat_template)
+
+ @auto_docstring
+ def __call__(
+ self,
+ text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] = None,
+ images: ImageInput | None = None,
+ videos: ImageInput | None = None,
+ padding: bool | str | PaddingStrategy = False,
+ truncation: bool | str | TruncationStrategy | None = None,
+ max_length: int | None = None,
+ return_tensors: str | TensorType | None = TensorType.PYTORCH,
+ ) -> BatchFeature:
+ r"""
+ padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):
+ Select a strategy to pad the returned sequences (according to the model's padding side and padding
+ index) among:
+ - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+ sequence if provided).
+ - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
+ acceptable input length for the model if that argument is not provided.
+ - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
+ lengths).
+ truncation (`bool`, *optional*):
+ Activates truncation to cut input sequences longer than `max_length` to `max_length`.
+ max_length (`int`, *optional*):
+ Maximum length of the returned list and optionally padding length (see above).
+
+ Returns:
+ [`BatchFeature`]: A [`BatchFeature`] with the following fields:
+
+ - **input_ids** -- List of token ids to be fed to a model. Returned when `text` is not `None`.
+ - **attention_mask** -- List of indices specifying which tokens should be attended to by the model (when
+ `return_attention_mask=True` or if *"attention_mask"* is in `self.model_input_names` and if `text` is not
+ `None`).
+ - **pixel_values** -- Pixel values to be fed to a model. Returned when `images` is not `None`.
+ - **pixel_values_videos** -- Pixel values to be fed to a model. Returned when `videos` is not `None`.
+ """
+
+ if isinstance(text, str):
+ text = [text]
+ elif not isinstance(text, list) and not isinstance(text[0], str):
+ raise TypeError("Invalid input text. Please provide a string, or a list of strings")
+
+ data = {}
+ if images is not None:
+ encoded_images = self.image_processor(images=images, return_tensors=return_tensors)
+ data.update(encoded_images)
+
+ height, width = get_image_size(to_numpy_array(encoded_images.get("pixel_values_images")[0]))
+ num_image_tokens = (height // self.patch_size) * (width // self.patch_size)
+ num_image_tokens += self.num_additional_image_tokens
+ if self.vision_feature_select_strategy == "default":
+ num_image_tokens -= 1
+ text = [sample.replace(self.image_token, self.image_token * num_image_tokens) for sample in text]
+
+ if videos is not None:
+ encoded_videos = self.video_processor(videos=videos, return_tensors=return_tensors)
+ data.update(encoded_videos)
+
+ one_video = encoded_videos.get("pixel_values_videos")[0]
+ if isinstance(encoded_videos.get("pixel_values_videos")[0], (list, tuple)):
+ one_video = np.array(one_video)
+ else:
+ one_video = to_numpy_array(one_video)
+ height, width = get_image_size(one_video[0])
+ num_frames = one_video.shape[0] # frame dim is always after batch dim
+
+ num_image_tokens = (height // self.patch_size) * (width // self.patch_size)
+ num_image_tokens += self.num_additional_image_tokens
+ num_video_tokens = num_image_tokens * num_frames
+ text = [sample.replace(self.video_token, self.video_token * num_video_tokens) for sample in text]
+
+ text_inputs = self.tokenizer(
+ text,
+ return_tensors=None,
+ padding=padding,
+ truncation=truncation,
+ max_length=max_length,
+ )
+ self._check_special_mm_tokens(text, text_inputs, modalities=["image", "video"])
+
+ data.update(text_inputs)
+
+ return BatchFeature(data=data, tensor_type=return_tensors)
+
+
+__all__ = ["VideoLlavaProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/video_llava/video_processing_video_llava.py b/lib/python3.11/site-packages/transformers/models/video_llava/video_processing_video_llava.py
new file mode 100644
index 0000000000000000000000000000000000000000..8dcc975a2c0278769a527faa29af955f14895399
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/video_llava/video_processing_video_llava.py
@@ -0,0 +1,35 @@
+# Copyright 2025 The HuggingFace Inc. 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.
+"""Video processor class for Video-LLaVA."""
+
+from ...image_utils import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD, PILImageResampling
+from ...video_processing_utils import BaseVideoProcessor
+
+
+class VideoLlavaVideoProcessor(BaseVideoProcessor):
+ resample = PILImageResampling.BICUBIC
+ image_mean = OPENAI_CLIP_MEAN
+ image_std = OPENAI_CLIP_STD
+ size = {"shortest_edge": 224}
+ default_to_square = False
+ crop_size = {"height": 224, "width": 224}
+ do_resize = True
+ do_center_crop = True
+ do_rescale = True
+ do_normalize = True
+ do_convert_rgb = True
+ do_sample_frames = False # Set to False for BC, recommended to set `True` in new models
+
+
+__all__ = ["VideoLlavaVideoProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/__init__.py b/lib/python3.11/site-packages/transformers/models/videomae/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbc50858a3432ea36baf6027b9f54b0672ffa027
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomae/__init__.py
@@ -0,0 +1,31 @@
+# Copyright 2024 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_videomae import *
+ from .feature_extraction_videomae import *
+ from .image_processing_pil_videomae import *
+ from .image_processing_videomae import *
+ from .modeling_videomae import *
+ from .video_processing_videomae import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c180cb657c5c6f6481ecaecee721a8a6ef2eb1c7
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/configuration_videomae.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/configuration_videomae.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f724b1178275b6d995004b5c97eaea255944414e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/configuration_videomae.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/image_processing_pil_videomae.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/image_processing_pil_videomae.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5cc7541b98e414aa2985fd59fa2119a9ad06cd63
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/image_processing_pil_videomae.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/image_processing_videomae.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/image_processing_videomae.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..abdfadc17fae0200cffe56862bed2647b824a039
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/image_processing_videomae.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/modeling_videomae.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/modeling_videomae.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..389644ac9a69915fa1fc8ca0aeba08db7b53ecef
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/modeling_videomae.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/video_processing_videomae.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/video_processing_videomae.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ab9231ad227a12101b4b34c15c67d37993fbfaf
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomae/__pycache__/video_processing_videomae.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/configuration_videomae.py b/lib/python3.11/site-packages/transformers/models/videomae/configuration_videomae.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7d355d7375b65af92697f3093b3e8ee042af6e1
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomae/configuration_videomae.py
@@ -0,0 +1,83 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""VideoMAE model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="MCG-NJU/videomae-base")
+@strict
+class VideoMAEConfig(PreTrainedConfig):
+ r"""
+ num_frames (`int`, *optional*, defaults to 16):
+ The number of frames in each video.
+ tubelet_size (`int`, *optional*, defaults to 2):
+ The number of tubelets.
+ use_mean_pooling (`bool`, *optional*, defaults to `True`):
+ Whether to mean pool the final hidden states instead of using the final hidden state of the [CLS] token.
+ decoder_num_attention_heads (`int`, *optional*, defaults to 6):
+ Number of attention heads for each attention layer in the decoder.
+ decoder_hidden_size (`int`, *optional*, defaults to 384):
+ Dimensionality of the decoder.
+ decoder_num_hidden_layers (`int`, *optional*, defaults to 4):
+ Number of hidden layers in the decoder.
+ decoder_intermediate_size (`int`, *optional*, defaults to 1536):
+ Dimensionality of the "intermediate" (i.e., feed-forward) layer in the decoder.
+ norm_pix_loss (`bool`, *optional*, defaults to `True`):
+ Whether to normalize the target patch pixels.
+
+ Example:
+
+ ```python
+ >>> from transformers import VideoMAEConfig, VideoMAEModel
+
+ >>> # Initializing a VideoMAE videomae-base style configuration
+ >>> configuration = VideoMAEConfig()
+
+ >>> # Randomly initializing a model from the configuration
+ >>> model = VideoMAEModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "videomae"
+
+ image_size: int | list[int] | tuple[int, int] = 224
+ patch_size: int | list[int] | tuple[int, int] = 16
+ num_channels: int = 3
+ num_frames: int = 16
+ tubelet_size: int = 2
+ hidden_size: int = 768
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ intermediate_size: int = 3072
+ hidden_act: str = "gelu"
+ hidden_dropout_prob: float | int = 0.0
+ attention_probs_dropout_prob: float | int = 0.0
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-12
+ qkv_bias: bool = True
+ use_mean_pooling: bool = True
+ decoder_num_attention_heads: int = 6
+ decoder_hidden_size: int = 384
+ decoder_num_hidden_layers: int = 4
+ decoder_intermediate_size: int = 1536
+ norm_pix_loss: bool = True
+
+
+__all__ = ["VideoMAEConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/image_processing_pil_videomae.py b/lib/python3.11/site-packages/transformers/models/videomae/image_processing_pil_videomae.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fffe2e143bf490e0e67a5de3410b6fea6e0a23b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomae/image_processing_pil_videomae.py
@@ -0,0 +1,94 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""PIL image processor class for VideoMAE."""
+
+import numpy as np
+
+from ...image_processing_backends import PilBackend
+from ...image_processing_utils import BatchFeature
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+ make_nested_list_of_images,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+@auto_docstring
+class VideoMAEImageProcessorPil(PilBackend):
+ resample = PILImageResampling.BILINEAR
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"shortest_edge": 224}
+ default_to_square = False
+ crop_size = {"height": 224, "width": 224}
+ do_resize = True
+ do_center_crop = True
+ do_rescale = True
+ do_normalize = True
+
+ def __init__(self, **kwargs: Unpack[ImagesKwargs]):
+ super().__init__(**kwargs)
+
+ def _prepare_images_structure(self, images: ImageInput, expected_ndims: int = 3) -> ImageInput:
+ return make_nested_list_of_images(images, expected_ndims=expected_ndims)
+
+ @auto_docstring
+ def preprocess(self, videos: ImageInput, **kwargs: Unpack[ImagesKwargs]) -> BatchFeature:
+ r"""
+ videos (`ImageInput`):
+ Video or batch of videos to preprocess. Expects a single video (list of frames) or a batch of videos
+ (list of list of frames). Each frame can be a PIL image, numpy array, or torch tensor with pixel values
+ ranging from 0 to 255. If passing in frames with pixel values between 0 and 1, set `do_rescale=False`.
+ """
+ return super().preprocess(videos, **kwargs)
+
+ def _preprocess(
+ self,
+ images: list[list[np.ndarray]],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | None",
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ pixel_values = []
+ for video_frames in images:
+ processed_frames = []
+ for image in video_frames:
+ if do_resize:
+ image = self.resize(image, size, resample)
+ if do_center_crop:
+ image = self.center_crop(image, crop_size)
+ if do_rescale:
+ image = self.rescale(image, rescale_factor)
+ if do_normalize:
+ image = self.normalize(image, image_mean, image_std)
+ processed_frames.append(image)
+ pixel_values.append(processed_frames)
+ return BatchFeature(data={"pixel_values": pixel_values}, tensor_type=return_tensors)
+
+
+__all__ = ["VideoMAEImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/image_processing_videomae.py b/lib/python3.11/site-packages/transformers/models/videomae/image_processing_videomae.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa0ca726f4cd825c20b76f454b00500d66892b50
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomae/image_processing_videomae.py
@@ -0,0 +1,108 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""Image processor class for VideoMAE."""
+
+import torch
+from torchvision.transforms.v2 import functional as tvF
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ImageInput,
+ PILImageResampling,
+ SizeDict,
+ make_nested_list_of_images,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring
+
+
+@auto_docstring
+class VideoMAEImageProcessor(TorchvisionBackend):
+ resample = PILImageResampling.BILINEAR
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"shortest_edge": 224}
+ default_to_square = False
+ crop_size = {"height": 224, "width": 224}
+ do_resize = True
+ do_center_crop = True
+ do_rescale = True
+ do_normalize = True
+
+ def __init__(self, **kwargs: Unpack[ImagesKwargs]):
+ super().__init__(**kwargs)
+
+ def _prepare_images_structure(self, images: ImageInput, expected_ndims: int = 3) -> ImageInput:
+ return make_nested_list_of_images(images, expected_ndims=expected_ndims)
+
+ @auto_docstring
+ def preprocess(self, videos: ImageInput, **kwargs: Unpack[ImagesKwargs]) -> BatchFeature:
+ r"""
+ videos (`ImageInput`):
+ Video or batch of videos to preprocess. Expects a single video (list of frames) or a batch of videos
+ (list of list of frames). Each frame can be a PIL image, numpy array, or torch tensor with pixel values
+ ranging from 0 to 255. If passing in frames with pixel values between 0 and 1, set `do_rescale=False`.
+ """
+ return super().preprocess(videos, **kwargs)
+
+ def _preprocess(
+ self,
+ images: list[list["torch.Tensor"]],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+ do_center_crop: bool,
+ crop_size: SizeDict,
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ disable_grouping: bool | None,
+ return_tensors: str | TensorType | None,
+ **kwargs,
+ ) -> BatchFeature:
+ grouped_images, grouped_images_index = group_images_by_shape(
+ images, is_nested=True, disable_grouping=disable_grouping
+ )
+ resized_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_resize:
+ stacked_images = self.resize(stacked_images, size, resample)
+ resized_images_grouped[shape] = stacked_images
+ resized_images = reorder_images(resized_images_grouped, grouped_images_index, is_nested=True)
+
+ grouped_images, grouped_images_index = group_images_by_shape(
+ resized_images, is_nested=True, disable_grouping=disable_grouping
+ )
+ processed_images_grouped = {}
+ for shape, stacked_images in grouped_images.items():
+ if do_center_crop:
+ stacked_images = self.center_crop(stacked_images, crop_size)
+ stacked_images = self.rescale_and_normalize(
+ stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+ )
+ processed_images_grouped[shape] = stacked_images
+ processed_images = reorder_images(processed_images_grouped, grouped_images_index, is_nested=True)
+
+ # Stack frames per video: list[list[Tensor(C,H,W)]] → list[Tensor(num_frames,C,H,W)]
+ pixel_values = [torch.stack(video_frames) for video_frames in processed_images]
+ return BatchFeature(data={"pixel_values": pixel_values}, tensor_type=return_tensors)
+
+
+__all__ = ["VideoMAEImageProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/modeling_videomae.py b/lib/python3.11/site-packages/transformers/models/videomae/modeling_videomae.py
new file mode 100644
index 0000000000000000000000000000000000000000..35bcce23c973cedf2962cdee9ad81523365d7213
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomae/modeling_videomae.py
@@ -0,0 +1,758 @@
+# Copyright 2022 Multimedia Computing Group, Nanjing University and The HuggingFace Inc. 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.
+"""PyTorch VideoMAE (masked autoencoder) model."""
+
+import collections.abc
+from collections.abc import Callable
+from copy import deepcopy
+from dataclasses import dataclass
+
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import MSELoss
+
+from ...activations import ACT2FN
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import BaseModelOutput, ImageClassifierOutput
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import ModelOutput, TransformersKwargs, auto_docstring, logging
+from ...utils.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
+from ...utils.generic import can_return_tuple, merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_videomae import VideoMAEConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(
+ custom_intro="""
+ Class for VideoMAEDecoder's outputs, with potential hidden states and attentions.
+ """
+)
+@dataclass
+class VideoMAEDecoderOutput(ModelOutput):
+ r"""
+ logits (`torch.FloatTensor` of shape `(batch_size, patch_size ** 2 * num_channels)`):
+ Pixel reconstruction logits.
+ """
+
+ logits: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+@auto_docstring(
+ custom_intro="""
+ Class for VideoMAEForPreTraining's outputs, with potential hidden states and attentions.
+ """
+)
+@dataclass
+class VideoMAEForPreTrainingOutput(ModelOutput):
+ r"""
+ loss (`torch.FloatTensor` of shape `(1,)`):
+ Pixel reconstruction loss.
+ logits (`torch.FloatTensor` of shape `(batch_size, patch_size ** 2 * num_channels)`):
+ Pixel reconstruction logits.
+ """
+
+ loss: torch.FloatTensor | None = None
+ logits: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+# sin-cos position encoding
+# https://github.com/jadore801120/attention-is-all-you-need-pytorch/blob/master/transformer/Models.py#L31
+def get_sinusoid_encoding_table(n_position, d_hid):
+ """Sinusoid position encoding table"""
+
+ # TODO: make it with torch instead of numpy
+ def get_position_angle_vec(position):
+ return [position / np.power(10000, 2 * (hid_j // 2) / d_hid) for hid_j in range(d_hid)]
+
+ sinusoid_table = np.array([get_position_angle_vec(pos_i) for pos_i in range(n_position)])
+ sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2]) # dim 2i
+ sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2]) # dim 2i+1
+
+ return torch.FloatTensor(sinusoid_table).unsqueeze(0)
+
+
+class VideoMAEEmbeddings(nn.Module):
+ """
+ Construct the patch and position embeddings.
+
+ """
+
+ def __init__(self, config):
+ super().__init__()
+
+ self.patch_embeddings = VideoMAEPatchEmbeddings(config)
+ self.num_patches = self.patch_embeddings.num_patches
+ # fixed sin-cos embedding
+ self.position_embeddings = get_sinusoid_encoding_table(self.num_patches, config.hidden_size)
+ self.config = config
+
+ def forward(self, pixel_values, bool_masked_pos):
+ # create patch embeddings
+ embeddings = self.patch_embeddings(pixel_values)
+
+ # add position embeddings
+ embeddings = embeddings + self.position_embeddings.detach().type_as(embeddings).to(
+ device=embeddings.device, copy=True
+ )
+ # only keep visible patches
+ # ~bool_masked_pos means visible
+ if bool_masked_pos is not None:
+ batch_size, _, num_channels = embeddings.shape
+ embeddings = embeddings[~bool_masked_pos]
+ embeddings = embeddings.reshape(batch_size, -1, num_channels)
+
+ return embeddings
+
+
+class VideoMAEPatchEmbeddings(nn.Module):
+ """
+ Video to Patch Embedding. This module turns a batch of videos of shape (batch_size, num_frames, num_channels,
+ height, width) into a tensor of shape (batch_size, seq_len, hidden_size) to be consumed by a Transformer encoder.
+
+ The seq_len (the number of patches) equals (number of frames // tubelet_size) * (height // patch_size) * (width //
+ patch_size).
+
+ """
+
+ def __init__(self, config):
+ super().__init__()
+
+ image_size = config.image_size
+ patch_size = config.patch_size
+ num_channels = config.num_channels
+ hidden_size = config.hidden_size
+ num_frames = config.num_frames
+ tubelet_size = config.tubelet_size
+
+ image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+ self.image_size = image_size
+ self.patch_size = patch_size
+ self.tubelet_size = int(tubelet_size)
+ num_patches = (
+ (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) * (num_frames // self.tubelet_size)
+ )
+ self.num_channels = num_channels
+ self.num_patches = num_patches
+ self.projection = nn.Conv3d(
+ in_channels=num_channels,
+ out_channels=hidden_size,
+ kernel_size=(self.tubelet_size, patch_size[0], patch_size[1]),
+ stride=(self.tubelet_size, patch_size[0], patch_size[1]),
+ )
+
+ def forward(self, pixel_values):
+ batch_size, num_frames, num_channels, height, width = pixel_values.shape
+ 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."
+ )
+ if height != self.image_size[0] or width != self.image_size[1]:
+ raise ValueError(
+ f"Input image size ({height}*{width}) doesn't match model ({self.image_size[0]}*{self.image_size[1]})."
+ )
+ # permute to (batch_size, num_channels, num_frames, height, width)
+ pixel_values = pixel_values.permute(0, 2, 1, 3, 4)
+ embeddings = self.projection(pixel_values).flatten(2).transpose(1, 2)
+ return embeddings
+
+
+# Copied from transformers.models.bert.modeling_bert.eager_attention_forward
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float | None = None,
+ dropout: float = 0.0,
+ **kwargs: Unpack[TransformersKwargs],
+):
+ if scaling is None:
+ scaling = query.size(-1) ** -0.5
+
+ # Take the dot product between "query" and "key" to get the raw attention scores.
+ attn_weights = torch.matmul(query, key.transpose(2, 3)) * scaling
+
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+class VideoMAESelfAttention(nn.Module):
+ def __init__(self, config: VideoMAEConfig) -> None:
+ super().__init__()
+ if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+ raise ValueError(
+ f"The hidden size {config.hidden_size} is not a multiple of the number of attention "
+ f"heads {config.num_attention_heads}."
+ )
+ self.config = config
+ self.num_attention_heads = config.num_attention_heads
+ self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+ self.all_head_size = self.num_attention_heads * self.attention_head_size
+ self.dropout_prob = config.attention_probs_dropout_prob
+ self.scaling = self.attention_head_size**-0.5
+ self.is_causal = False
+
+ self.query = nn.Linear(config.hidden_size, self.all_head_size, bias=config.qkv_bias)
+ self.key = nn.Linear(config.hidden_size, self.all_head_size, bias=config.qkv_bias)
+ self.value = nn.Linear(config.hidden_size, self.all_head_size, bias=config.qkv_bias)
+
+ def forward(
+ self, hidden_states: torch.Tensor | None = None
+ ) -> tuple[torch.Tensor, torch.Tensor]: # TODO: siglip attention 1-1
+ input_shape = hidden_states.shape[:-1]
+
+ hidden_shape = (*input_shape, -1, self.attention_head_size)
+ keys = self.key(hidden_states).view(hidden_shape).transpose(1, 2)
+ values = self.value(hidden_states).view(hidden_shape).transpose(1, 2)
+ queries = self.query(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ context_layer, attention_probs = attention_interface(
+ self,
+ queries,
+ keys,
+ values,
+ None,
+ is_causal=self.is_causal,
+ scaling=self.scaling,
+ dropout=0.0 if not self.training else self.dropout_prob,
+ )
+
+ new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+ context_layer = context_layer.reshape(new_context_layer_shape)
+
+ return context_layer, attention_probs
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.vit.modeling_vit.ViTAttention with ViT->VideoMAE
+class VideoMAESelfOutput(nn.Module):
+ """
+ The residual connection is defined in VideoMAELayer instead of here (as is the case with other models), due to the
+ layernorm applied before each block.
+ """
+
+ def __init__(self, config: VideoMAEConfig):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ return hidden_states
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.vit.modeling_vit.ViTAttention with ViT->VideoMAE
+class VideoMAEAttention(nn.Module):
+ def __init__(self, config: VideoMAEConfig):
+ super().__init__()
+ self.attention = VideoMAESelfAttention(config)
+ self.output = VideoMAESelfOutput(config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ self_attn_output, _ = self.attention(hidden_states, **kwargs)
+ output = self.output(self_attn_output, hidden_states)
+ return output
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.vit.modeling_vit.ViTMLP ViT->VideoMAE
+class VideoMAEIntermediate(nn.Module):
+ def __init__(self, config: VideoMAEConfig):
+ super().__init__()
+ self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+ if isinstance(config.hidden_act, str):
+ self.intermediate_act_fn = ACT2FN[config.hidden_act]
+ else:
+ self.intermediate_act_fn = config.hidden_act
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.intermediate_act_fn(hidden_states)
+ return hidden_states
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.vit.modeling_vit.ViTMLP ViT->VideoMAE
+class VideoMAEOutput(nn.Module):
+ def __init__(self, config: VideoMAEConfig):
+ super().__init__()
+ self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+ def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.dense(hidden_states)
+ hidden_states = self.dropout(hidden_states)
+ hidden_states = hidden_states + input_tensor
+ return hidden_states
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.vit.modeling_vit.ViTLayer with ViT->VideoMAE,VIT->VIDEOMAE
+class VideoMAELayer(GradientCheckpointingLayer):
+ """This corresponds to the Block class in the timm implementation."""
+
+ def __init__(self, config: VideoMAEConfig):
+ super().__init__()
+ self.chunk_size_feed_forward = config.chunk_size_feed_forward
+ self.seq_len_dim = 1
+ self.attention = VideoMAEAttention(config)
+ self.intermediate = VideoMAEIntermediate(config)
+ self.output = VideoMAEOutput(config)
+ self.layernorm_before = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.layernorm_after = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> torch.Tensor:
+ hidden_states_norm = self.layernorm_before(hidden_states)
+ attention_output = self.attention(hidden_states_norm, **kwargs)
+
+ # first residual connection
+ hidden_states = attention_output + hidden_states
+
+ # in VideoMAE, layernorm is also applied after self-attention
+ layer_output = self.layernorm_after(hidden_states)
+ layer_output = self.intermediate(layer_output)
+
+ # second residual connection is done here
+ layer_output = self.output(layer_output, hidden_states)
+
+ return layer_output
+
+
+# Todo - Refactor as part of vision refactor. Copied from transformers.models.vit.modeling_vit.ViTEncoder with ViT->VideoMAE
+class VideoMAEEncoder(nn.Module):
+ def __init__(self, config: VideoMAEConfig):
+ super().__init__()
+ self.config = config
+ self.layer = nn.ModuleList([VideoMAELayer(config) for _ in range(config.num_hidden_layers)])
+ self.gradient_checkpointing = False
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ for layer_module in self.layer:
+ hidden_states = layer_module(hidden_states, **kwargs)
+
+ return BaseModelOutput(last_hidden_state=hidden_states)
+
+
+@auto_docstring
+class VideoMAEPreTrainedModel(PreTrainedModel):
+ config: VideoMAEConfig
+ base_model_prefix = "videomae"
+ main_input_name = "pixel_values"
+ input_modalities = "video"
+ supports_gradient_checkpointing = True
+ _no_split_modules = ["VideoMAEEmbeddings", "VideoMAELayer"]
+ _supports_sdpa = True
+ _supports_flash_attn = True
+ _supports_flex_attn = True
+ _supports_attention_backend = True
+ _can_record_outputs = {
+ "hidden_states": VideoMAELayer,
+ "attentions": VideoMAESelfAttention,
+ }
+
+
+@auto_docstring
+class VideoMAEModel(VideoMAEPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.config = config
+
+ self.embeddings = VideoMAEEmbeddings(config)
+ self.encoder = VideoMAEEncoder(config)
+
+ if config.use_mean_pooling:
+ self.layernorm = None
+ else:
+ self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def get_input_embeddings(self):
+ return self.embeddings.patch_embeddings
+
+ @merge_with_config_defaults
+ @capture_outputs(tie_last_hidden_states=False)
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ bool_masked_pos: torch.BoolTensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> BaseModelOutput:
+ r"""
+ bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
+ Boolean masked positions. Indicates which patches are masked (1) and which aren't (0). Each video in the
+ batch must have the same number of masked patches. If `None`, then all patches are considered. Sequence
+ length is `(num_frames // tubelet_size) * (image_size // patch_size) ** 2`.
+
+ Examples:
+
+ ```python
+ >>> import torch
+ >>> from transformers import VideoMAEVideoProcessor, VideoMAEModel
+ >>> from huggingface_hub import hf_hub_download
+
+ >>> # replace this with your own video file
+ >>> video_path = hf_hub_download(
+ ... repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
+ ... )
+
+ >>> video_processor = VideoMAEVideoProcessor.from_pretrained("MCG-NJU/videomae-base")
+ >>> model = VideoMAEModel.from_pretrained("MCG-NJU/videomae-base")
+
+ >>> # prepare video for the model
+ >>> inputs = video_processor(video_path, return_tensors="pt")
+
+ >>> # forward pass
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> last_hidden_states = outputs.last_hidden_state
+ >>> list(last_hidden_states.shape)
+ [1, 1568, 768]
+ ```"""
+
+ embedding_output = self.embeddings(pixel_values, bool_masked_pos)
+
+ encoder_outputs: BaseModelOutput = self.encoder(embedding_output)
+ sequence_output = encoder_outputs.last_hidden_state
+ if self.layernorm is not None:
+ sequence_output = self.layernorm(sequence_output)
+
+ return BaseModelOutput(last_hidden_state=sequence_output)
+
+
+class VideoMAEDecoder(nn.Module):
+ def __init__(self, config: VideoMAEConfig):
+ super().__init__()
+
+ decoder_num_labels = config.num_channels * config.tubelet_size * config.patch_size**2
+
+ decoder_config = deepcopy(config)
+ decoder_config.hidden_size = config.decoder_hidden_size
+ decoder_config.num_hidden_layers = config.decoder_num_hidden_layers
+ decoder_config.num_attention_heads = config.decoder_num_attention_heads
+ decoder_config.intermediate_size = config.decoder_intermediate_size
+ self.decoder_layers = nn.ModuleList(
+ [VideoMAELayer(decoder_config) for _ in range(config.decoder_num_hidden_layers)]
+ )
+
+ self.norm = nn.LayerNorm(config.decoder_hidden_size)
+ self.head = (
+ nn.Linear(config.decoder_hidden_size, decoder_num_labels) if decoder_num_labels > 0 else nn.Identity()
+ )
+
+ self.gradient_checkpointing = False
+ self.config = decoder_config
+
+ def forward(self, hidden_states: torch.Tensor, return_token_num: int):
+ # Apply transformer layers
+ for layer_module in self.decoder_layers:
+ hidden_states = layer_module(hidden_states)
+
+ hidden_states = hidden_states[:, -return_token_num:]
+
+ # predictor projection
+ hidden_states = self.norm(hidden_states)
+ logits = self.head(hidden_states)
+
+ return VideoMAEDecoderOutput(logits=logits)
+
+
+@auto_docstring(
+ custom_intro="""
+ The VideoMAE Model transformer with the decoder on top for self-supervised pre-training.
+ """
+)
+class VideoMAEForPreTraining(VideoMAEPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+ self.config = config
+
+ self.videomae = VideoMAEModel(config)
+
+ self.encoder_to_decoder = nn.Linear(config.hidden_size, config.decoder_hidden_size, bias=False)
+ self.mask_token = nn.Parameter(torch.zeros(1, 1, config.decoder_hidden_size))
+ self.position_embeddings = get_sinusoid_encoding_table(
+ self.videomae.embeddings.num_patches, config.decoder_hidden_size
+ )
+
+ self.decoder = VideoMAEDecoder(config)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.FloatTensor,
+ bool_masked_pos: torch.BoolTensor,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> VideoMAEForPreTrainingOutput:
+ r"""
+ bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, sequence_length)`):
+ Boolean masked positions. Indicates which patches are masked (1) and which aren't (0). Each video in the
+ batch must have the same number of masked patches. Sequence length is `(num_frames // tubelet_size) *
+ (image_size // patch_size) ** 2`.
+
+ Examples:
+ ```python
+ >>> from transformers import AutoImageProcessor, VideoMAEForPreTraining
+ >>> import numpy as np
+ >>> import torch
+
+ >>> num_frames = 16
+ >>> video = list(np.random.randint(0, 256, (num_frames, 3, 224, 224)))
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base")
+ >>> model = VideoMAEForPreTraining.from_pretrained("MCG-NJU/videomae-base")
+
+ >>> pixel_values = image_processor(video, return_tensors="pt").pixel_values
+
+ >>> num_patches_per_frame = (model.config.image_size // model.config.patch_size) ** 2
+ >>> seq_length = (num_frames // model.config.tubelet_size) * num_patches_per_frame
+ >>> bool_masked_pos = torch.randint(0, 2, (1, seq_length)).bool()
+
+ >>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
+ >>> loss = outputs.loss
+ ```"""
+ outputs: BaseModelOutput = self.videomae(pixel_values, bool_masked_pos=bool_masked_pos, **kwargs)
+
+ sequence_output = outputs.last_hidden_state
+ sequence_output = self.encoder_to_decoder(sequence_output)
+
+ # [batch_size, num_visible_patches, decoder_hidden_size]
+ batch_size, _, num_channels = sequence_output.shape
+
+ # we don't unshuffle the correct visible token order, but shuffle the position embeddings accordingly.
+ if bool_masked_pos is None:
+ raise ValueError("One must provided a boolean mask ")
+
+ expanded_position_embeddings = self.position_embeddings.expand(batch_size, -1, -1).type_as(pixel_values)
+ expanded_position_embeddings = expanded_position_embeddings.detach().to(device=pixel_values.device, copy=True)
+ pos_emb_visible = expanded_position_embeddings[~bool_masked_pos].reshape(batch_size, -1, num_channels)
+ pos_emb_mask = expanded_position_embeddings[bool_masked_pos].reshape(batch_size, -1, num_channels)
+
+ # [batch_size, num_patches, decoder_hidden_size]
+ x_full = torch.cat([sequence_output + pos_emb_visible, self.mask_token + pos_emb_mask], dim=1)
+
+ # [batch_size, num_masked_patches, num_channels * patch_size * patch_size]
+ decoder_outputs: VideoMAEDecoderOutput = self.decoder(x_full, pos_emb_mask.shape[1])
+ logits = decoder_outputs.logits
+
+ loss = None
+ with torch.no_grad():
+ # calculate the labels to be predicted
+ if self.config.num_channels != 3:
+ # Can't unnormalize with default means/stds
+ frames = pixel_values
+ else:
+ # first, unnormalize the frames
+ device = pixel_values.device
+ dtype = pixel_values.dtype
+ mean = torch.as_tensor(IMAGENET_DEFAULT_MEAN).to(device=device, dtype=dtype)[None, None, :, None, None]
+ std = torch.as_tensor(IMAGENET_DEFAULT_STD).to(device=device, dtype=dtype)[None, None, :, None, None]
+ frames = pixel_values * std + mean # in [0, 1]
+
+ batch_size, time, num_channels, height, width = frames.shape
+ tubelet_size, patch_size = self.config.tubelet_size, self.config.patch_size
+ if self.config.norm_pix_loss:
+ # step 1: split up dimensions (time by tubelet_size, height by patch_size, width by patch_size)
+ frames = frames.view(
+ batch_size,
+ time // tubelet_size,
+ tubelet_size,
+ num_channels,
+ height // patch_size,
+ patch_size,
+ width // patch_size,
+ patch_size,
+ )
+ # step 2: move dimensions to concatenate:
+ frames = frames.permute(0, 1, 4, 6, 2, 5, 7, 3).contiguous()
+ # step 3: concatenate:
+ frames = frames.view(
+ batch_size,
+ time // tubelet_size * height // patch_size * width // patch_size,
+ tubelet_size * patch_size * patch_size,
+ num_channels,
+ )
+ # step 4: normalize. The authors find that the mean is about 0.48 and standard deviation is about 0.08.
+ frames_norm = (frames - frames.mean(dim=-2, keepdim=True)) / (
+ frames.var(dim=-2, unbiased=True, keepdim=True).sqrt() + 1e-6
+ )
+ # step 5: reshape to (batch_size, T//ts * H//ps * W//ps, ts * ps * ps * C)
+ videos_patch = frames_norm.view(
+ batch_size,
+ time // tubelet_size * height // patch_size * width // patch_size,
+ tubelet_size * patch_size * patch_size * num_channels,
+ )
+ else:
+ if self.config.num_channels != 3:
+ raise ValueError(
+ "Can't unnormalize non-RGB images. Consider setting config.norm_pix_loss to False."
+ )
+ # step 1: split up dimensions (time by tubelet_size, height by patch_size, width by patch_size)
+ frames = frames.view(
+ batch_size,
+ time // tubelet_size,
+ tubelet_size,
+ num_channels,
+ height // patch_size,
+ patch_size,
+ width // patch_size,
+ patch_size,
+ )
+ # step 2: move dimensions to concatenate: (batch_size, T//ts, H//ps, W//ps, ts, ps, ps, C)
+ frames = frames.permute(0, 1, 4, 6, 2, 5, 7, 3).contiguous()
+ # step 3: concatenate
+ videos_patch = frames.view(
+ batch_size,
+ time // tubelet_size * height // patch_size * width // patch_size,
+ tubelet_size * patch_size * patch_size * num_channels,
+ )
+
+ batch_size, _, num_channels = videos_patch.shape
+ labels = videos_patch[bool_masked_pos].reshape(batch_size, -1, num_channels)
+
+ loss_fct = MSELoss()
+ loss = loss_fct(logits, labels)
+
+ return VideoMAEForPreTrainingOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+@auto_docstring(
+ custom_intro="""
+ VideoMAE Model transformer with a video classification head on top (a linear layer on top of the average pooled hidden
+ states of all tokens) e.g. for ImageNet.
+ """
+)
+class VideoMAEForVideoClassification(VideoMAEPreTrainedModel):
+ def __init__(self, config):
+ super().__init__(config)
+
+ self.num_labels = config.num_labels
+ self.videomae = VideoMAEModel(config)
+
+ # Classifier head
+ self.fc_norm = nn.LayerNorm(config.hidden_size) if config.use_mean_pooling else None
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels) if config.num_labels > 0 else nn.Identity()
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ @can_return_tuple
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values: torch.Tensor | None = None,
+ labels: torch.Tensor | None = None,
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> ImageClassifierOutput:
+ r"""
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+ Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+
+ Examples:
+
+ ```python
+ >>> import torch
+ >>> from transformers import VideoMAEVideoProcessor, VideoMAEForVideoClassification
+ >>> from huggingface_hub import hf_hub_download
+
+ >>> # replace this with your own video file
+ >>> video_path = hf_hub_download(
+ ... repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
+ ... )
+
+ >>> video_processor = VideoMAEVideoProcessor.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics")
+ >>> model = VideoMAEForVideoClassification.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics")
+
+ >>> inputs = video_processor(video_path, return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+ ... logits = outputs.logits
+
+ >>> # model predicts one of the 400 Kinetics-400 classes
+ >>> predicted_label = logits.argmax(-1).item()
+ >>> print(model.config.id2label[predicted_label])
+ eating spaghetti
+ ```"""
+
+ outputs: BaseModelOutput = self.videomae(pixel_values, **kwargs)
+ sequence_output = outputs.last_hidden_state
+
+ if self.fc_norm is not None:
+ output = sequence_output.mean(1)
+ output = self.fc_norm(output)
+ else:
+ output = sequence_output[:, 0]
+
+ logits = self.classifier(output)
+
+ loss = None
+ if labels is not None:
+ loss = self.loss_function(labels, logits, self.config, **kwargs)
+
+ return ImageClassifierOutput(
+ loss=loss,
+ logits=logits,
+ hidden_states=outputs.hidden_states,
+ attentions=outputs.attentions,
+ )
+
+
+__all__ = ["VideoMAEForPreTraining", "VideoMAEModel", "VideoMAEPreTrainedModel", "VideoMAEForVideoClassification"]
diff --git a/lib/python3.11/site-packages/transformers/models/videomae/video_processing_videomae.py b/lib/python3.11/site-packages/transformers/models/videomae/video_processing_videomae.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc1050d0eb15230837634efcc2a4f8b8dc640aa4
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomae/video_processing_videomae.py
@@ -0,0 +1,42 @@
+# Copyright 2025 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.
+"""Video processor class for VideoMAE."""
+
+from ...image_utils import IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, PILImageResampling
+from ...video_processing_utils import BaseVideoProcessor
+
+
+class VideoMAEVideoProcessor(BaseVideoProcessor):
+ resample = PILImageResampling.BILINEAR
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"shortest_edge": 224}
+ default_to_square = False
+ crop_size = {"height": 224, "width": 224}
+ do_resize = True
+ do_center_crop = True
+ do_rescale = True
+ rescale_factor = 1 / 255
+ do_normalize = True
+ do_convert_rgb = True
+ do_sample_frames = False # Set to False for backward compatibility with image processor workflows.
+ model_input_names = ["pixel_values"]
+
+ def preprocess(self, videos, **kwargs):
+ batch = super().preprocess(videos, **kwargs)
+ batch["pixel_values"] = batch.pop("pixel_values_videos")
+ return batch
+
+
+__all__ = ["VideoMAEVideoProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/__init__.py b/lib/python3.11/site-packages/transformers/models/videomt/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..edfedae488df11a9ffd0e12c0c6b729190866b91
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomt/__init__.py
@@ -0,0 +1,29 @@
+# Copyright 2026 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_videomt import *
+ from .modeling_videomt import *
+ from .video_processing_videomt import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f339c257d0abe4408bfc68aaf14dd960754966c1
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/configuration_videomt.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/configuration_videomt.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..808ce7646883ed74a7928972e2b7d548bb517440
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/configuration_videomt.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/modeling_videomt.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/modeling_videomt.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..284d6b4d399f82a0368076ab4f0eb491998a3744
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/modeling_videomt.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/modular_videomt.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/modular_videomt.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fe52cbf44a3e73de9a3232f727ad9bab4a2f0317
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/modular_videomt.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/video_processing_videomt.cpython-311.pyc b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/video_processing_videomt.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..264a0b879a47cd566e79f5f66a36872dd3302f80
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/models/videomt/__pycache__/video_processing_videomt.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/configuration_videomt.py b/lib/python3.11/site-packages/transformers/models/videomt/configuration_videomt.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9acb2abe17359e6f382b5a34342735f77e85dd0
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomt/configuration_videomt.py
@@ -0,0 +1,101 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/videomt/modular_videomt.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_videomt.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="tue-mps/videomt-dinov2-small-ytvis2019")
+@strict
+class VideomtConfig(PreTrainedConfig):
+ r"""
+ layerscale_value (`float`, *optional*, defaults to 1.0):
+ Initial value for the LayerScale parameter.
+ num_upscale_blocks (`int`, *optional*, defaults to 2):
+ Number of upsampling blocks used in the decoder or segmentation head.
+ use_swiglu_ffn (`bool`, *optional*, defaults to `False`):
+ Whether to use the SwiGLU feedforward neural network.
+ num_blocks (`int`, *optional*, defaults to 4):
+ Number of feature blocks or stages in the architecture.
+ no_object_weight (`float`, *optional*, defaults to 0.1):
+ Loss weight for the 'no object' class in panoptic/instance segmentation.
+ class_weight (`float`, *optional*, defaults to 2.0):
+ Loss weight for classification targets.
+ mask_weight (`float`, *optional*, defaults to 5.0):
+ Loss weight for mask prediction.
+ train_num_points (`int`, *optional*, defaults to 12544):
+ Number of points to sample for mask loss computation during training.
+ oversample_ratio (`float`, *optional*, defaults to 3.0):
+ Oversampling ratio used in point sampling for mask training.
+ importance_sample_ratio (`float`, *optional*, defaults to 0.75):
+ Ratio of points to sample based on importance during training.
+ num_queries (`int`, *optional*, defaults to 200):
+ Number of object queries in the Transformer.
+ num_register_tokens (`int`, *optional*, defaults to 4):
+ Number of learnable register tokens added to the transformer input.
+
+ Example:
+
+ ```python
+ >>> from transformers import VideomtConfig, VideomtForUniversalSegmentation
+
+ >>> # Initialize configuration
+ >>> config = VideomtConfig()
+
+ >>> # Initialize model
+ >>> model = VideomtForUniversalSegmentation(config)
+
+ >>> # Access config
+ >>> config = model.config
+ ```"""
+
+ model_type = "videomt"
+
+ hidden_size: int = 1024
+ num_hidden_layers: int = 24
+ num_attention_heads: int = 16
+ hidden_act: str = "gelu"
+ hidden_dropout_prob: float | int = 0.0
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-6
+ image_size: int | list[int] | tuple[int, int] = 640
+ patch_size: int | list[int] | tuple[int, int] = 16
+ num_channels: int = 3
+ mlp_ratio: int = 4
+ layerscale_value: float = 1.0
+ drop_path_rate: float | int = 0.0
+ num_upscale_blocks: int = 2
+ attention_dropout: float | int = 0.0
+ use_swiglu_ffn: bool = False
+ num_blocks: int = 4
+ no_object_weight: float = 0.1
+ class_weight: float = 2.0
+ mask_weight: float = 5.0
+ dice_weight: float = 5.0
+ train_num_points: int = 12544
+ oversample_ratio: float = 3.0
+ importance_sample_ratio: float = 0.75
+ num_queries: int = 200
+ num_register_tokens: int = 4
+
+
+__all__ = ["VideomtConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/modeling_videomt.py b/lib/python3.11/site-packages/transformers/models/videomt/modeling_videomt.py
new file mode 100644
index 0000000000000000000000000000000000000000..e42ff129993119aa27d5a6379ed2f6fa7fc8eb91
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomt/modeling_videomt.py
@@ -0,0 +1,1219 @@
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# This file was automatically generated from src/transformers/models/videomt/modular_videomt.py.
+# Do NOT edit this file manually as any edits will be overwritten by the generation of
+# the file from the modular. If any change should be done, please apply the change to the
+# modular_videomt.py file directly. One of our CI enforces this.
+# 🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 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 collections.abc
+import math
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import Tensor, nn
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...file_utils import ModelOutput, is_scipy_available, requires_backends
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, is_accelerate_available
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from .configuration_videomt import VideomtConfig
+
+
+if is_scipy_available():
+ from scipy.optimize import linear_sum_assignment
+
+if is_accelerate_available():
+ from accelerate import PartialState
+ from accelerate.utils import reduce
+
+
+class VideomtPatchEmbeddings(nn.Module):
+ """
+ This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
+ `hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
+ Transformer.
+ """
+
+ def __init__(self, config):
+ super().__init__()
+ image_size, patch_size = config.image_size, config.patch_size
+ num_channels, hidden_size = config.num_channels, config.hidden_size
+
+ image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+ patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+ num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
+ self.image_size = image_size
+ self.patch_size = patch_size
+ self.num_channels = num_channels
+ self.num_patches = num_patches
+
+ self.projection = nn.Conv2d(num_channels, hidden_size, kernel_size=patch_size, stride=patch_size)
+
+ def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
+ num_channels = 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."
+ f" Expected {self.num_channels} but got {num_channels}."
+ )
+
+ pixel_values = pixel_values.to(dtype=self.projection.weight.dtype)
+ embeddings = self.projection(pixel_values).flatten(2).transpose(1, 2)
+ return embeddings
+
+
+class VideomtEmbeddings(nn.Module):
+ """
+ Construct the CLS token, mask token, position and patch embeddings.
+ """
+
+ def __init__(self, config: VideomtConfig) -> None:
+ super().__init__()
+
+ self.config = config
+ self.patch_size = config.patch_size
+
+ self.cls_token = nn.Parameter(torch.randn(1, 1, config.hidden_size))
+ self.register_tokens = nn.Parameter(torch.zeros(1, config.num_register_tokens, config.hidden_size))
+ self.patch_embeddings = VideomtPatchEmbeddings(config)
+ num_patches = self.patch_embeddings.num_patches
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
+ self.num_prefix_tokens = 1 + config.num_register_tokens # 1 for [CLS]
+ self.position_embeddings = nn.Embedding(num_patches, config.hidden_size)
+ self.register_buffer("position_ids", torch.arange(num_patches).expand((1, -1)), persistent=False)
+ self.mask_token = nn.Parameter(torch.zeros(1, 1, config.hidden_size))
+
+ def forward(self, pixel_values: torch.Tensor, bool_masked_pos: torch.Tensor | None = None) -> torch.Tensor:
+ if pixel_values.ndim == 5:
+ batch_size, num_frames, num_channels, height, width = pixel_values.shape
+ pixel_values = pixel_values.reshape(batch_size * num_frames, num_channels, height, width)
+
+ if bool_masked_pos is not None:
+ bool_masked_pos = bool_masked_pos.reshape(batch_size * num_frames, -1)
+ elif bool_masked_pos is not None and bool_masked_pos.ndim > 2:
+ bool_masked_pos = bool_masked_pos.reshape(bool_masked_pos.shape[0], -1)
+
+ batch_size = pixel_values.shape[0]
+ embeddings = self.patch_embeddings(pixel_values)
+
+ if bool_masked_pos is not None:
+ mask = bool_masked_pos.to(device=embeddings.device, dtype=torch.bool).unsqueeze(-1)
+ embeddings = torch.where(mask, self.mask_token, embeddings)
+
+ cls_tokens = self.cls_token.expand(batch_size, -1, -1)
+ register_tokens = self.register_tokens.expand(batch_size, -1, -1)
+
+ embeddings = embeddings + self.position_embeddings(self.position_ids)
+ embeddings = torch.cat([cls_tokens, register_tokens, embeddings], dim=1)
+ embeddings = self.dropout(embeddings)
+ return embeddings
+
+
+class VideomtMLP(nn.Module):
+ def __init__(self, config) -> None:
+ super().__init__()
+ in_features = out_features = config.hidden_size
+ hidden_features = int(config.hidden_size * config.mlp_ratio)
+ self.fc1 = nn.Linear(in_features, hidden_features, bias=True)
+ if isinstance(config.hidden_act, str):
+ self.activation = ACT2FN[config.hidden_act]
+ else:
+ self.activation = config.hidden_act
+ self.fc2 = nn.Linear(hidden_features, out_features, bias=True)
+
+ def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+ hidden_state = self.fc1(hidden_state)
+ hidden_state = self.activation(hidden_state)
+ hidden_state = self.fc2(hidden_state)
+ return hidden_state
+
+
+class VideomtGatedMLP(nn.Module):
+ def __init__(self, config) -> None:
+ super().__init__()
+ in_features = out_features = config.hidden_size
+ hidden_features = int(config.hidden_size * config.mlp_ratio)
+ hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8
+
+ self.weights_in = nn.Linear(in_features, 2 * hidden_features, bias=True)
+ self.weights_out = nn.Linear(hidden_features, out_features, bias=True)
+
+ def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+ hidden_state = self.weights_in(hidden_state)
+ x1, x2 = hidden_state.chunk(2, dim=-1)
+ hidden = nn.functional.silu(x1) * x2
+ return self.weights_out(hidden)
+
+
+def eager_attention_forward(
+ module: nn.Module,
+ query: torch.Tensor,
+ key: torch.Tensor,
+ value: torch.Tensor,
+ attention_mask: torch.Tensor | None,
+ scaling: float,
+ dropout: float = 0.0,
+ **kwargs,
+):
+ attn_weights = torch.matmul(query, key.transpose(-1, -2)) * scaling
+ if attention_mask is not None:
+ attn_weights = attn_weights + attention_mask
+
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
+ attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+ attn_output = torch.matmul(attn_weights, value)
+ attn_output = attn_output.transpose(1, 2).contiguous()
+
+ return attn_output, attn_weights
+
+
+class VideomtAttention(nn.Module):
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+ def __init__(self, config):
+ super().__init__()
+ self.config = config
+ self.embed_dim = config.hidden_size
+ self.num_heads = config.num_attention_heads
+ self.head_dim = self.embed_dim // self.num_heads
+ if self.head_dim * self.num_heads != self.embed_dim:
+ raise ValueError(
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+ f" {self.num_heads})."
+ )
+ self.scale = self.head_dim**-0.5
+ self.dropout = config.attention_dropout
+ self.is_causal = False
+
+ self.k_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.v_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.q_proj = nn.Linear(self.embed_dim, self.embed_dim)
+ self.out_proj = nn.Linear(self.embed_dim, self.embed_dim)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ **kwargs,
+ ) -> tuple[torch.Tensor, torch.Tensor | None]:
+ """Input shape: Batch x Time x Channel"""
+
+ input_shape = hidden_states.shape[:-1]
+
+ hidden_shape = (*input_shape, -1, self.head_dim)
+ queries = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ keys = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+ values = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+ attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+ self.config._attn_implementation, eager_attention_forward
+ )
+
+ attn_output, attn_weights = attention_interface(
+ self,
+ queries,
+ keys,
+ values,
+ attention_mask,
+ is_causal=self.is_causal,
+ scaling=self.scale,
+ dropout=0.0 if not self.training else self.dropout,
+ )
+
+ attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+ attn_output = self.out_proj(attn_output)
+
+ return attn_output, attn_weights
+
+
+class VideomtSwiGLUFFN(nn.Module):
+ def __init__(self, config) -> None:
+ super().__init__()
+ in_features = out_features = config.hidden_size
+ hidden_features = int(config.hidden_size * config.mlp_ratio)
+ hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8
+
+ self.weights_in = nn.Linear(in_features, 2 * hidden_features, bias=True)
+ self.weights_out = nn.Linear(hidden_features, out_features, bias=True)
+
+ def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+ hidden_state = self.weights_in(hidden_state)
+ x1, x2 = hidden_state.chunk(2, dim=-1)
+ hidden = nn.functional.silu(x1) * x2
+ return self.weights_out(hidden)
+
+
+class VideomtDropPath(nn.Module):
+ """Stochastic depth (DropPath) per sample, for residual blocks.
+
+ Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
+ <https://arxiv.org/abs/1603.09382>`_.
+ """
+
+ def __init__(self, drop_prob: float = 0.0) -> None:
+ super().__init__()
+ self.drop_prob = drop_prob
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ if self.drop_prob == 0.0 or not self.training:
+ return hidden_states
+ keep_prob = 1 - self.drop_prob
+ shape = (hidden_states.shape[0],) + (1,) * (hidden_states.ndim - 1)
+ random_tensor = torch.rand(shape, dtype=hidden_states.dtype, device=hidden_states.device)
+ random_tensor = torch.floor(random_tensor + keep_prob)
+ return hidden_states.div(keep_prob) * random_tensor
+
+ def extra_repr(self) -> str:
+ return f"p={self.drop_prob}"
+
+
+class VideomtLayer(GradientCheckpointingLayer):
+ """This corresponds to the Block class in the original implementation."""
+
+ def __init__(self, config: VideomtConfig) -> None:
+ super().__init__()
+
+ self.norm1 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+ self.attention = VideomtAttention(config)
+ self.layer_scale1 = VideomtLayerScale(config)
+ self.drop_path = VideomtDropPath(config.drop_path_rate) if config.drop_path_rate > 0.0 else nn.Identity()
+
+ self.norm2 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ if config.use_swiglu_ffn:
+ self.mlp = VideomtSwiGLUFFN(config)
+ else:
+ self.mlp = VideomtMLP(config)
+ self.layer_scale2 = VideomtLayerScale(config)
+
+ def forward(
+ self,
+ hidden_states: torch.Tensor,
+ attention_mask: torch.Tensor | None = None,
+ ) -> torch.Tensor:
+ hidden_states_norm = self.norm1(hidden_states)
+ self_attention_output, _ = self.attention(hidden_states_norm, attention_mask)
+ self_attention_output = self.layer_scale1(self_attention_output)
+
+ # first residual connection
+ hidden_states = self.drop_path(self_attention_output) + hidden_states
+
+ # in Videomt, layernorm is also applied after self-attention
+ layer_output = self.norm2(hidden_states)
+ layer_output = self.mlp(layer_output)
+ layer_output = self.layer_scale2(layer_output)
+
+ # second residual connection
+ layer_output = self.drop_path(layer_output) + hidden_states
+
+ return layer_output
+
+
+class VideomtLayerScale(nn.Module):
+ def __init__(self, config) -> None:
+ super().__init__()
+ self.lambda1 = nn.Parameter(config.layerscale_value * torch.ones(config.hidden_size))
+
+ def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+ return hidden_state * self.lambda1
+
+
+@auto_docstring(
+ custom_intro="""
+ Class for outputs of [`VideomtForUniversalSegmentationOutput`].
+
+ This output can be directly passed to [`~VideomtVideoProcessor.post_process_semantic_segmentation`] or
+ [`~VideomtVideoProcessor.post_process_instance_segmentation`] or
+ [`~VideomtVideoProcessor.post_process_panoptic_segmentation`] to compute final segmentation maps. Please, see
+ [`~VideomtVideoProcessor`] for details regarding usage.
+ """
+)
+@dataclass
+class VideomtForUniversalSegmentationOutput(ModelOutput):
+ r"""
+ loss (`torch.Tensor`, *optional*):
+ The computed loss, returned when labels are present.
+ class_queries_logits (`torch.FloatTensor`):
+ A tensor of shape `(batch_size, num_queries, num_labels + 1)` representing the proposed classes for each
+ query. Note the `+ 1` is needed because we incorporate the null class.
+ masks_queries_logits (`torch.FloatTensor`):
+ A tensor of shape `(batch_size, num_queries, height, width)` representing the proposed masks for each
+ query.
+ last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+ Last hidden states (final feature map) of the last layer.
+ hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, sequence_length, hidden_size)`. Hidden-states all layers of the model.
+ attentions (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `tuple(torch.FloatTensor)` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`. Self and Cross Attentions weights from transformer decoder.
+ """
+
+ loss: torch.FloatTensor | None = None
+ class_queries_logits: torch.FloatTensor | None = None
+ masks_queries_logits: torch.FloatTensor | None = None
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+# Adapted from https://github.com/facebookresearch/detectron2/blob/main/projects/PointRend/point_rend/point_features.py
+def sample_point(
+ input_features: torch.Tensor, point_coordinates: torch.Tensor, add_dim=False, **kwargs
+) -> torch.Tensor:
+ """
+ A wrapper around `torch.nn.functional.grid_sample` to support 3D point_coordinates tensors.
+
+ Args:
+ input_features (`torch.Tensor` of shape (batch_size, channels, height, width)):
+ A tensor that contains features map on a height * width grid
+ point_coordinates (`torch.Tensor` of shape (batch_size, num_points, 2) or (batch_size, grid_height, grid_width,:
+ 2)):
+ A tensor that contains [0, 1] * [0, 1] normalized point coordinates
+ add_dim (`bool`):
+ boolean value to keep track of added dimension
+
+ Returns:
+ point_features (`torch.Tensor` of shape (batch_size, channels, num_points) or (batch_size, channels,
+ height_grid, width_grid):
+ A tensor that contains features for points in `point_coordinates`.
+ """
+ if point_coordinates.dim() == 3:
+ add_dim = True
+ point_coordinates = point_coordinates.unsqueeze(2)
+
+ # use nn.function.grid_sample to get features for points in `point_coordinates` via bilinear interpolation
+ point_features = torch.nn.functional.grid_sample(input_features, 2.0 * point_coordinates - 1.0, **kwargs)
+ if add_dim:
+ point_features = point_features.squeeze(3)
+
+ return point_features
+
+
+def pair_wise_dice_loss(inputs: Tensor, labels: Tensor) -> Tensor:
+ """
+ A pair wise version of the dice loss, see `dice_loss` for usage.
+
+ Args:
+ inputs (`torch.Tensor`):
+ A tensor representing a mask
+ labels (`torch.Tensor`):
+ A tensor with the same shape as inputs. Stores the binary classification labels for each element in inputs
+ (0 for the negative class and 1 for the positive class).
+
+ Returns:
+ `torch.Tensor`: The computed loss between each pairs.
+ """
+ inputs = inputs.sigmoid().flatten(1)
+ numerator = 2 * torch.matmul(inputs, labels.T)
+ # using broadcasting to get a [num_queries, NUM_CLASSES] matrix
+ denominator = inputs.sum(-1)[:, None] + labels.sum(-1)[None, :]
+ loss = 1 - (numerator + 1) / (denominator + 1)
+ return loss
+
+
+def pair_wise_sigmoid_cross_entropy_loss(inputs: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
+ r"""
+ A pair wise version of the cross entropy loss, see `sigmoid_cross_entropy_loss` for usage.
+
+ Args:
+ inputs (`torch.Tensor`):
+ A tensor representing a mask.
+ labels (`torch.Tensor`):
+ A tensor with the same shape as inputs. Stores the binary classification labels for each element in inputs
+ (0 for the negative class and 1 for the positive class).
+
+ Returns:
+ loss (`torch.Tensor`): The computed loss between each pairs.
+ """
+
+ height_and_width = inputs.shape[1]
+
+ criterion = nn.BCEWithLogitsLoss(reduction="none")
+ cross_entropy_loss_pos = criterion(inputs, torch.ones_like(inputs))
+ cross_entropy_loss_neg = criterion(inputs, torch.zeros_like(inputs))
+
+ loss_pos = torch.matmul(cross_entropy_loss_pos / height_and_width, labels.T)
+ loss_neg = torch.matmul(cross_entropy_loss_neg / height_and_width, (1 - labels).T)
+ loss = loss_pos + loss_neg
+ return loss
+
+
+# Adapted from https://github.com/facebookresearch/Videomt/blob/main/videomt/modeling/matcher.py
+class VideomtHungarianMatcher(nn.Module):
+ """This class computes an assignment between the labels and the predictions of the network.
+
+ For efficiency reasons, the labels don't include the no_object. Because of this, in general, there are more
+ predictions than labels. In this case, we do a 1-to-1 matching of the best predictions, while the others are
+ un-matched (and thus treated as non-objects).
+ """
+
+ def __init__(
+ self, cost_class: float = 1.0, cost_mask: float = 1.0, cost_dice: float = 1.0, num_points: int = 12544
+ ):
+ """Creates the matcher
+
+ Params:
+ cost_class (`float`, *optional*, defaults to 1.0):
+ Relative weight of the classification error in the matching cost.
+ cost_mask (`float`, *optional*, defaults to 1.0):
+ This is the relative weight of the focal loss of the binary mask in the matching cost.
+ cost_dice (`float`, *optional*, defaults to 1.0):
+ This is the relative weight of the dice loss of the binary mask in the matching cost.
+ num_points (`int`, *optional*, defaults to 12544):
+ No. of points to sample on which the mask loss will be calculated. The same set of K points are
+ uniformly sampled for all prediction and ground truth masks to construct the cost matrix for bipartite
+ matching.
+ """
+ super().__init__()
+ if cost_class == 0 and cost_mask == 0 and cost_dice == 0:
+ raise ValueError("All costs can't be 0")
+
+ self.num_points = num_points
+ self.cost_class = cost_class
+ self.cost_mask = cost_mask
+ self.cost_dice = cost_dice
+
+ @torch.no_grad()
+ def forward(
+ self,
+ masks_queries_logits: torch.Tensor,
+ class_queries_logits: torch.Tensor,
+ mask_labels: torch.Tensor,
+ class_labels: torch.Tensor,
+ ) -> list[tuple[Tensor]]:
+ """
+ Params:
+ masks_queries_logits (`torch.Tensor`):
+ A tensor of dim `batch_size, num_queries, num_labels` with the classification logits.
+ class_queries_logits (`torch.Tensor`):
+ A tensor of dim `batch_size, num_queries, height, width` with the predicted masks.
+ class_labels (`torch.Tensor`):
+ A tensor of dim `num_target_boxes` (where num_target_boxes is the number of ground-truth objects in the
+ target) containing the class labels.
+ mask_labels (`torch.Tensor`):
+ A tensor of dim `num_target_boxes, height, width` containing the target masks.
+
+ Returns:
+ matched_indices (`list[tuple[Tensor]]`): A list of size batch_size, containing tuples of (index_i, index_j)
+ where:
+ - index_i is the indices of the selected predictions (in order)
+ - index_j is the indices of the corresponding selected labels (in order)
+ For each batch element, it holds:
+ len(index_i) = len(index_j) = min(num_queries, num_target_boxes).
+ """
+ indices: list[tuple[np.array]] = []
+
+ # iterate through batch size
+ batch_size = masks_queries_logits.shape[0]
+ for i in range(batch_size):
+ pred_probs = class_queries_logits[i].softmax(-1)
+ pred_mask = masks_queries_logits[i]
+
+ # Compute the classification cost. Contrary to the loss, we don't use the NLL, but approximate it in 1 - proba[target class]. The 1 is a constant that doesn't change the matching, it can be omitted.
+ cost_class = -pred_probs[:, class_labels[i]]
+ target_mask = mask_labels[i].to(pred_mask)
+ target_mask = target_mask[:, None]
+ pred_mask = pred_mask[:, None]
+
+ # Sample ground truth and predicted masks
+ point_coordinates = torch.rand(1, self.num_points, 2, device=pred_mask.device)
+
+ target_coordinates = point_coordinates.repeat(target_mask.shape[0], 1, 1)
+ target_mask = sample_point(target_mask, target_coordinates, align_corners=False).squeeze(1)
+
+ pred_coordinates = point_coordinates.repeat(pred_mask.shape[0], 1, 1)
+ pred_mask = sample_point(pred_mask, pred_coordinates, align_corners=False).squeeze(1)
+
+ # compute the cross entropy loss between each mask pairs -> shape (num_queries, num_labels)
+ cost_mask = pair_wise_sigmoid_cross_entropy_loss(pred_mask, target_mask)
+ # Compute the dice loss between each mask pairs -> shape (num_queries, num_labels)
+ cost_dice = pair_wise_dice_loss(pred_mask, target_mask)
+ # final cost matrix
+ cost_matrix = self.cost_mask * cost_mask + self.cost_class * cost_class + self.cost_dice * cost_dice
+ # eliminate infinite values in cost_matrix to avoid the error ``ValueError: cost matrix is infeasible``
+ cost_matrix = torch.minimum(cost_matrix, torch.tensor(1e10))
+ cost_matrix = torch.maximum(cost_matrix, torch.tensor(-1e10))
+ cost_matrix = torch.nan_to_num(cost_matrix, 0)
+ # do the assignment using the hungarian algorithm in scipy
+ assigned_indices: tuple[np.array] = linear_sum_assignment(cost_matrix.cpu())
+ indices.append(assigned_indices)
+
+ # It could be stacked in one tensor
+ matched_indices = [
+ (torch.as_tensor(i, dtype=torch.int64), torch.as_tensor(j, dtype=torch.int64)) for i, j in indices
+ ]
+ return matched_indices
+
+
+def dice_loss(inputs: Tensor, labels: Tensor, num_masks: int) -> Tensor:
+ r"""
+ Compute the DICE loss, similar to generalized IOU for masks as follows:
+
+ $$ \mathcal{L}_{\text{dice}(x, y) = 1 - \frac{2 * x \cap y }{x \cup y + 1}} $$
+
+ In practice, since `labels` is a binary mask, (only 0s and 1s), dice can be computed as follow
+
+ $$ \mathcal{L}_{\text{dice}(x, y) = 1 - \frac{2 * x * y }{x + y + 1}} $$
+
+ Args:
+ inputs (`torch.Tensor`):
+ A tensor representing a mask.
+ labels (`torch.Tensor`):
+ A tensor with the same shape as inputs. Stores the binary classification labels for each element in inputs
+ (0 for the negative class and 1 for the positive class).
+ num_masks (`int`):
+ The number of masks present in the current batch, used for normalization.
+
+ Returns:
+ `torch.Tensor`: The computed loss.
+ """
+ probs = inputs.sigmoid().flatten(1)
+ numerator = 2 * (probs * labels).sum(-1)
+ denominator = probs.sum(-1) + labels.sum(-1)
+ loss = 1 - (numerator + 1) / (denominator + 1)
+ loss = loss.sum() / num_masks
+ return loss
+
+
+def sigmoid_cross_entropy_loss(inputs: torch.Tensor, labels: torch.Tensor, num_masks: int) -> torch.Tensor:
+ r"""
+ Args:
+ inputs (`torch.Tensor`):
+ A float tensor of arbitrary shape.
+ labels (`torch.Tensor`):
+ A tensor with the same shape as inputs. Stores the binary classification labels for each element in inputs
+ (0 for the negative class and 1 for the positive class).
+
+ Returns:
+ loss (`torch.Tensor`): The computed loss.
+ """
+ criterion = nn.BCEWithLogitsLoss(reduction="none")
+ cross_entropy_loss = criterion(inputs, labels)
+
+ loss = cross_entropy_loss.mean(1).sum() / num_masks
+ return loss
+
+
+# Adapted from https://github.com/facebookresearch/Videomt/blob/main/videomt/modeling/criterion.py
+class VideomtLoss(nn.Module):
+ def __init__(self, config: VideomtConfig, weight_dict: dict[str, float]):
+ """
+ The Videomt Loss. The loss is computed very similar to DETR. The process happens in two steps: 1) we
+ compute hungarian assignment between ground truth masks and the outputs of the model 2) we supervise each pair
+ of matched ground-truth / prediction (supervise class and mask)
+
+ Args:
+ config (`VideomtConfig`):
+ The configuration for Videomt model also containing loss calculation specific parameters.
+ weight_dict (`dict[str, float]`):
+ A dictionary of weights to be applied to the different losses.
+ """
+ super().__init__()
+ requires_backends(self, ["scipy"])
+ self.num_labels = config.num_labels
+ self.weight_dict = weight_dict
+
+ # Weight to apply to the null class
+ self.eos_coef = config.no_object_weight
+ empty_weight = torch.ones(self.num_labels + 1)
+ empty_weight[-1] = self.eos_coef
+ self.register_buffer("empty_weight", empty_weight)
+
+ # pointwise mask loss parameters
+ self.num_points = config.train_num_points
+ self.oversample_ratio = config.oversample_ratio
+ self.importance_sample_ratio = config.importance_sample_ratio
+
+ self.matcher = VideomtHungarianMatcher(
+ cost_class=config.class_weight,
+ cost_dice=config.dice_weight,
+ cost_mask=config.mask_weight,
+ num_points=self.num_points,
+ )
+
+ def _max_by_axis(self, sizes: list[list[int]]) -> list[int]:
+ maxes = sizes[0]
+ for sublist in sizes[1:]:
+ for index, item in enumerate(sublist):
+ maxes[index] = max(maxes[index], item)
+ return maxes
+
+ # Adapted from nested_tensor_from_tensor_list() in original implementation
+ def _pad_images_to_max_in_batch(self, tensors: list[Tensor]) -> tuple[Tensor, Tensor]:
+ # get the maximum size in the batch
+ max_size = self._max_by_axis([list(tensor.shape) for tensor in tensors])
+ # compute final size
+ batch_shape = [len(tensors)] + max_size
+ batch_size, _, height, width = batch_shape
+ dtype = tensors[0].dtype
+ device = tensors[0].device
+ padded_tensors = torch.zeros(batch_shape, dtype=dtype, device=device)
+ padding_masks = torch.ones((batch_size, height, width), dtype=torch.bool, device=device)
+ # pad the tensors to the size of the biggest one
+ for tensor, padded_tensor, padding_mask in zip(tensors, padded_tensors, padding_masks):
+ padded_tensor[: tensor.shape[0], : tensor.shape[1], : tensor.shape[2]].copy_(tensor)
+ padding_mask[: tensor.shape[1], : tensor.shape[2]] = False
+
+ return padded_tensors, padding_masks
+
+ def loss_labels(
+ self, class_queries_logits: Tensor, class_labels: list[Tensor], indices: tuple[np.array]
+ ) -> dict[str, Tensor]:
+ """Compute the losses related to the labels using cross entropy.
+
+ Args:
+ class_queries_logits (`torch.Tensor`):
+ A tensor of shape `batch_size, num_queries, num_labels`
+ class_labels (`list[torch.Tensor]`):
+ List of class labels of shape `(labels)`.
+ indices (`tuple[np.array])`:
+ The indices computed by the Hungarian matcher.
+
+ Returns:
+ `dict[str, Tensor]`: A dict of `torch.Tensor` containing the following key:
+ - **loss_cross_entropy** -- The loss computed using cross entropy on the predicted and ground truth labels.
+ """
+ pred_logits = class_queries_logits
+ batch_size, num_queries, _ = pred_logits.shape
+ criterion = nn.CrossEntropyLoss(weight=self.empty_weight)
+ idx = self._get_predictions_permutation_indices(indices) # shape of (batch_size, num_queries)
+ target_classes_o = torch.cat(
+ [target[j] for target, (_, j) in zip(class_labels, indices)]
+ ) # shape of (batch_size, num_queries)
+ target_classes = torch.full(
+ (batch_size, num_queries), fill_value=self.num_labels, dtype=torch.int64, device=pred_logits.device
+ )
+ target_classes[idx] = target_classes_o
+ # Permute target_classes (batch_size, num_queries, num_labels) -> (batch_size, num_labels, num_queries)
+ pred_logits_transposed = pred_logits.transpose(1, 2)
+ loss_ce = criterion(pred_logits_transposed, target_classes)
+ losses = {"loss_cross_entropy": loss_ce}
+ return losses
+
+ def loss_masks(
+ self,
+ masks_queries_logits: torch.Tensor,
+ mask_labels: list[torch.Tensor],
+ indices: tuple[np.array],
+ num_masks: int,
+ ) -> dict[str, torch.Tensor]:
+ """Compute the losses related to the masks using sigmoid_cross_entropy_loss and dice loss.
+
+ Args:
+ masks_queries_logits (`torch.Tensor`):
+ A tensor of shape `(batch_size, num_queries, height, width)`.
+ mask_labels (`torch.Tensor`):
+ List of mask labels of shape `(labels, height, width)`.
+ indices (`tuple[np.array])`:
+ The indices computed by the Hungarian matcher.
+ num_masks (`int)`:
+ The number of masks, used for normalization.
+
+ Returns:
+ losses (`dict[str, Tensor]`): A dict of `torch.Tensor` containing two keys:
+ - **loss_mask** -- The loss computed using sigmoid cross entropy loss on the predicted and ground truth.
+ masks.
+ - **loss_dice** -- The loss computed using dice loss on the predicted on the predicted and ground truth,
+ masks.
+ """
+ src_idx = self._get_predictions_permutation_indices(indices)
+ tgt_idx = self._get_targets_permutation_indices(indices)
+ # shape (batch_size * num_queries, height, width)
+ pred_masks = masks_queries_logits[src_idx]
+ # shape (batch_size, num_queries, height, width)
+ # pad all and stack the targets to the num_labels dimension
+ target_masks, _ = self._pad_images_to_max_in_batch(mask_labels)
+ target_masks = target_masks[tgt_idx]
+
+ # No need to upsample predictions as we are using normalized coordinates
+ pred_masks = pred_masks[:, None]
+ target_masks = target_masks[:, None]
+
+ # Sample point coordinates
+ with torch.no_grad():
+ point_coordinates = self.sample_points_using_uncertainty(
+ pred_masks,
+ lambda logits: self.calculate_uncertainty(logits),
+ self.num_points,
+ self.oversample_ratio,
+ self.importance_sample_ratio,
+ )
+
+ point_labels = sample_point(target_masks, point_coordinates, align_corners=False).squeeze(1)
+
+ point_logits = sample_point(pred_masks, point_coordinates, align_corners=False).squeeze(1)
+
+ losses = {
+ "loss_mask": sigmoid_cross_entropy_loss(point_logits, point_labels, num_masks),
+ "loss_dice": dice_loss(point_logits, point_labels, num_masks),
+ }
+
+ del pred_masks
+ del target_masks
+ return losses
+
+ def _get_predictions_permutation_indices(self, indices):
+ # Permute predictions following indices
+ batch_indices = torch.cat([torch.full_like(src, i) for i, (src, _) in enumerate(indices)])
+ predictions_indices = torch.cat([src for (src, _) in indices])
+ return batch_indices, predictions_indices
+
+ def _get_targets_permutation_indices(self, indices):
+ # Permute labels following indices
+ batch_indices = torch.cat([torch.full_like(tgt, i) for i, (_, tgt) in enumerate(indices)])
+ target_indices = torch.cat([tgt for (_, tgt) in indices])
+ return batch_indices, target_indices
+
+ def calculate_uncertainty(self, logits: torch.Tensor) -> torch.Tensor:
+ """
+ In Videomt paper, uncertainty is estimated as L1 distance between 0.0 and the logit prediction in 'logits'
+ for the foreground class in `classes`.
+
+ Args:
+ logits (`torch.Tensor`):
+ A tensor of shape (R, 1, ...) for class-specific or class-agnostic, where R is the total number of predicted masks in all images and C is:
+ the number of foreground classes. The values are logits.
+
+ Returns:
+ scores (`torch.Tensor`): A tensor of shape (R, 1, ...) that contains uncertainty scores with the most
+ uncertain locations having the highest uncertainty score.
+ """
+ uncertainty_scores = -(torch.abs(logits))
+ return uncertainty_scores
+
+ def sample_points_using_uncertainty(
+ self,
+ logits: torch.Tensor,
+ uncertainty_function,
+ num_points: int,
+ oversample_ratio: int,
+ importance_sample_ratio: float,
+ ) -> torch.Tensor:
+ """
+ This function is meant for sampling points in [0, 1] * [0, 1] coordinate space based on their uncertainty. The
+ uncertainty is calculated for each point using the passed `uncertainty function` that takes points logit
+ prediction as input.
+
+ Args:
+ logits (`float`):
+ Logit predictions for P points.
+ uncertainty_function:
+ A function that takes logit predictions for P points and returns their uncertainties.
+ num_points (`int`):
+ The number of points P to sample.
+ oversample_ratio (`int`):
+ Oversampling parameter.
+ importance_sample_ratio (`float`):
+ Ratio of points that are sampled via importance sampling.
+
+ Returns:
+ point_coordinates (`torch.Tensor`):
+ Coordinates for P sampled points.
+ """
+
+ num_boxes = logits.shape[0]
+ num_points_sampled = int(num_points * oversample_ratio)
+
+ # Get random point coordinates
+ point_coordinates = torch.rand(num_boxes, num_points_sampled, 2, device=logits.device)
+ # Get sampled prediction value for the point coordinates
+ point_logits = sample_point(logits, point_coordinates, align_corners=False)
+ # Calculate the uncertainties based on the sampled prediction values of the points
+ point_uncertainties = uncertainty_function(point_logits)
+
+ num_uncertain_points = int(importance_sample_ratio * num_points)
+ num_random_points = num_points - num_uncertain_points
+
+ idx = torch.topk(point_uncertainties[:, 0, :], k=num_uncertain_points, dim=1)[1]
+ shift = num_points_sampled * torch.arange(num_boxes, dtype=torch.long, device=logits.device)
+ idx += shift[:, None]
+ point_coordinates = point_coordinates.view(-1, 2)[idx.view(-1), :].view(num_boxes, num_uncertain_points, 2)
+
+ if num_random_points > 0:
+ point_coordinates = torch.cat(
+ [point_coordinates, torch.rand(num_boxes, num_random_points, 2, device=logits.device)],
+ dim=1,
+ )
+ return point_coordinates
+
+ def forward(
+ self,
+ masks_queries_logits: torch.Tensor,
+ class_queries_logits: torch.Tensor,
+ mask_labels: list[torch.Tensor],
+ class_labels: list[torch.Tensor],
+ auxiliary_predictions: dict[str, torch.Tensor] | None = None,
+ ) -> dict[str, torch.Tensor]:
+ """
+ This performs the loss computation.
+
+ Args:
+ masks_queries_logits (`torch.Tensor`):
+ A tensor of shape `(batch_size, num_queries, height, width)`.
+ class_queries_logits (`torch.Tensor`):
+ A tensor of shape `(batch_size, num_queries, num_labels)`.
+ mask_labels (`torch.Tensor`):
+ List of mask labels of shape `(labels, height, width)`.
+ class_labels (`list[torch.Tensor]`):
+ List of class labels of shape `(labels)`.
+ auxiliary_predictions (`dict[str, torch.Tensor]`, *optional*):
+ if `use_auxiliary_loss` was set to `true` in [`VideomtConfig`], then it contains the logits from
+ the inner layers of the VideomtMaskedAttentionDecoder.
+
+ Returns:
+ losses (`dict[str, Tensor]`): A dict of `torch.Tensor` containing three keys:
+ - **loss_cross_entropy** -- The loss computed using cross entropy on the predicted and ground truth labels.
+ - **loss_mask** -- The loss computed using sigmoid cross_entropy loss on the predicted and ground truth
+ masks.
+ - **loss_dice** -- The loss computed using dice loss on the predicted on the predicted and ground truth
+ masks.
+ if `use_auxiliary_loss` was set to `true` in [`VideomtConfig`], the dictionary contains additional
+ losses for each auxiliary predictions.
+ """
+
+ # retrieve the matching between the outputs of the last layer and the labels
+ indices = self.matcher(masks_queries_logits, class_queries_logits, mask_labels, class_labels)
+ # compute the average number of target masks for normalization purposes
+ num_masks = self.get_num_masks(class_labels, device=class_labels[0].device)
+ # get all the losses
+ losses: dict[str, Tensor] = {
+ **self.loss_masks(masks_queries_logits, mask_labels, indices, num_masks),
+ **self.loss_labels(class_queries_logits, class_labels, indices),
+ }
+ # in case of auxiliary losses, we repeat this process with the output of each intermediate layer.
+ if auxiliary_predictions is not None:
+ for idx, aux_outputs in enumerate(auxiliary_predictions):
+ masks_queries_logits = aux_outputs["masks_queries_logits"]
+ class_queries_logits = aux_outputs["class_queries_logits"]
+ loss_dict = self.forward(masks_queries_logits, class_queries_logits, mask_labels, class_labels)
+ loss_dict = {f"{key}_{idx}": value for key, value in loss_dict.items()}
+ losses.update(loss_dict)
+
+ return losses
+
+ def get_num_masks(self, class_labels: torch.Tensor, device: torch.device) -> torch.Tensor:
+ """
+ Computes the average number of target masks across the batch, for normalization purposes.
+ """
+ num_masks = sum(len(classes) for classes in class_labels)
+ num_masks = torch.as_tensor(num_masks, dtype=torch.float, device=device)
+ world_size = 1
+ if is_accelerate_available():
+ if PartialState._shared_state != {}:
+ num_masks = reduce(num_masks)
+ world_size = PartialState().num_processes
+
+ num_masks = torch.clamp(num_masks / world_size, min=1)
+ return num_masks
+
+
+@auto_docstring
+class VideomtPreTrainedModel(PreTrainedModel):
+ """
+ An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+ models.
+ """
+
+ config: VideomtConfig
+ base_model_prefix = "videomt"
+ main_input_name = "pixel_values_videos"
+ input_modalities = ("video",)
+ supports_gradient_checkpointing = False
+ _no_split_modules = ["VideomtLayer"]
+ _supports_sdpa = True
+ _can_record_outputs = {
+ "hidden_states": VideomtLayer,
+ "attentions": VideomtAttention,
+ }
+
+ @torch.no_grad()
+ def _init_weights(self, module: nn.Module) -> None:
+ std = self.config.initializer_range
+ if isinstance(module, (nn.Linear, nn.Conv2d, nn.ConvTranspose2d)):
+ init.kaiming_uniform_(module.weight, a=math.sqrt(5))
+ if module.bias is not None:
+ fan_in, _ = torch.nn.init._calculate_fan_in_and_fan_out(module.weight)
+ bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0
+ init.uniform_(module.bias, -bound, bound)
+ elif isinstance(module, nn.LayerNorm):
+ init.ones_(module.weight)
+ init.zeros_(module.bias)
+ elif isinstance(module, nn.Embedding):
+ init.normal_(module.weight, mean=0.0, std=1)
+ # Here we need the check explicitly, as we slice the weight in the `zeros_` call, so it looses the flag
+ if module.padding_idx is not None and not getattr(module.weight, "_is_hf_initialized", False):
+ init.zeros_(module.weight[module.padding_idx])
+ elif isinstance(module, VideomtLayerScale):
+ if hasattr(module, "lambda1"):
+ init.constant_(module.lambda1, self.config.layerscale_value)
+ elif isinstance(module, VideomtEmbeddings):
+ init.trunc_normal_(module.cls_token, mean=0.0, std=std)
+ init.zeros_(module.register_tokens)
+ init.copy_(module.position_ids, torch.arange(module.position_ids.shape[-1]).expand((1, -1)))
+ elif isinstance(module, VideomtLoss):
+ empty_weight = torch.ones(module.num_labels + 1)
+ empty_weight[-1] = module.eos_coef
+ init.copy_(module.empty_weight, empty_weight)
+ elif isinstance(module, VideomtForUniversalSegmentation):
+ init.ones_(module.attn_mask_probs)
+ if isinstance(module, VideomtEmbeddings):
+ nn.init.zeros_(module.mask_token)
+
+
+class VideomtLayerNorm2d(nn.LayerNorm):
+ def __init__(self, num_channels, eps=1e-6, affine=True):
+ super().__init__(num_channels, eps=eps, elementwise_affine=affine)
+
+ def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+ hidden_state = hidden_state.permute(0, 2, 3, 1)
+ hidden_state = F.layer_norm(hidden_state, self.normalized_shape, self.weight, self.bias, self.eps)
+ hidden_state = hidden_state.permute(0, 3, 1, 2)
+ return hidden_state
+
+
+class VideomtScaleLayer(nn.Module):
+ def __init__(self, config: VideomtConfig):
+ super().__init__()
+ hidden_size = config.hidden_size
+ self.conv1 = nn.ConvTranspose2d(hidden_size, hidden_size, kernel_size=2, stride=2)
+ self.activation = ACT2FN[config.hidden_act]
+ self.conv2 = nn.Conv2d(
+ hidden_size,
+ hidden_size,
+ kernel_size=3,
+ padding=1,
+ groups=hidden_size,
+ bias=False,
+ )
+
+ self.layernorm2d = VideomtLayerNorm2d(hidden_size)
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.conv1(hidden_states)
+ hidden_states = self.activation(hidden_states)
+ hidden_states = self.conv2(hidden_states)
+ hidden_states = self.layernorm2d(hidden_states)
+ return hidden_states
+
+
+class VideomtScaleBlock(nn.Module):
+ def __init__(self, config: VideomtConfig):
+ super().__init__()
+ self.num_blocks = config.num_upscale_blocks
+ self.block = nn.ModuleList([VideomtScaleLayer(config) for _ in range(self.num_blocks)])
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ for block in self.block:
+ hidden_states = block(hidden_states)
+ return hidden_states
+
+
+class VideomtMaskHead(nn.Module):
+ def __init__(self, config: VideomtConfig):
+ super().__init__()
+
+ hidden_size = config.hidden_size
+ self.fc1 = nn.Linear(hidden_size, hidden_size)
+ self.fc2 = nn.Linear(hidden_size, hidden_size)
+ self.fc3 = nn.Linear(hidden_size, hidden_size)
+ self.activation = ACT2FN[config.hidden_act]
+
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+ hidden_states = self.activation(self.fc1(hidden_states))
+ hidden_states = self.activation(self.fc2(hidden_states))
+ hidden_states = self.fc3(hidden_states)
+ return hidden_states
+
+
+@auto_docstring(
+ custom_intro="""
+ The Videomt Model with head on top for instance/semantic/panoptic segmentation.
+ """
+)
+class VideomtForUniversalSegmentation(VideomtPreTrainedModel):
+ main_input_name = "pixel_values_videos"
+
+ def __init__(self, config: VideomtConfig):
+ super().__init__(config)
+ self.config = config
+ self.num_hidden_layers = config.num_hidden_layers
+ self.embeddings = VideomtEmbeddings(config)
+ self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+ self.query = nn.Embedding(config.num_queries, config.hidden_size)
+ self.layers = nn.ModuleList([VideomtLayer(config) for _ in range(config.num_hidden_layers)])
+
+ self.upscale_block = VideomtScaleBlock(config)
+ self.mask_head = VideomtMaskHead(config)
+
+ self.class_predictor = nn.Linear(config.hidden_size, config.num_labels + 1)
+
+ self.grid_size = (config.image_size // config.patch_size, config.image_size // config.patch_size)
+ self.weight_dict: dict[str, float] = {
+ "loss_cross_entropy": config.class_weight,
+ "loss_mask": config.mask_weight,
+ "loss_dice": config.dice_weight,
+ }
+
+ self.criterion = VideomtLoss(config=config, weight_dict=self.weight_dict)
+
+ self.register_buffer("attn_mask_probs", torch.ones(config.num_blocks))
+ self.query_updater = nn.Linear(config.hidden_size, config.hidden_size)
+
+ self.post_init()
+
+ def get_loss_dict(
+ self,
+ masks_queries_logits: Tensor,
+ class_queries_logits: Tensor,
+ mask_labels: Tensor,
+ class_labels: Tensor,
+ auxiliary_predictions: dict[str, Tensor],
+ ) -> dict[str, Tensor]:
+ loss_dict: dict[str, Tensor] = self.criterion(
+ masks_queries_logits=masks_queries_logits,
+ class_queries_logits=class_queries_logits,
+ mask_labels=mask_labels,
+ class_labels=class_labels,
+ auxiliary_predictions=auxiliary_predictions,
+ )
+
+ # weight each loss by `self.weight_dict[<LOSS_NAME>]` including auxiliary losses
+ for key, weight in self.weight_dict.items():
+ for loss_key, loss in loss_dict.items():
+ if key in loss_key:
+ loss *= weight
+
+ return loss_dict
+
+ def get_loss(self, loss_dict: dict[str, Tensor]) -> Tensor:
+ return sum(loss_dict.values())
+
+ @merge_with_config_defaults
+ @capture_outputs
+ @auto_docstring
+ def forward(
+ self,
+ pixel_values_videos: torch.Tensor | None = None,
+ mask_labels: list[torch.Tensor] | None = None,
+ class_labels: list[torch.Tensor] | None = None,
+ patch_offsets: list[torch.Tensor] | None = None, # Unused, kept for modular compatibility.
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> VideomtForUniversalSegmentationOutput:
+ r"""
+ pixel_values_videos (`torch.Tensor`, *optional*):
+ Video inputs of shape `(batch_size, num_frames, num_channels, height, width)`.
+ mask_labels (`list[torch.Tensor]`, *optional*):
+ Not supported for 5D video inputs.
+ class_labels (`list[torch.LongTensor]`, *optional*):
+ Not supported for 5D video inputs.
+ patch_offsets (`list[torch.Tensor]`, *optional*):
+ Unused for video inputs and only kept for modular compatibility.
+ """
+ if "pixel_values" in kwargs:
+ raise ValueError("Use `pixel_values_videos` with `VideomtForUniversalSegmentation`.")
+
+ if pixel_values_videos is None:
+ raise ValueError("You have to specify pixel_values_videos")
+
+ if pixel_values_videos.ndim != 5:
+ raise ValueError(
+ "VideomtForUniversalSegmentation only supports 5D video inputs of shape "
+ "(batch_size, num_frames, channels, height, width)."
+ )
+
+ if mask_labels is not None or class_labels is not None:
+ raise ValueError(
+ "Training with 5D video inputs is not supported in `VideomtForUniversalSegmentation`. "
+ "Flatten frames and use `EomtForUniversalSegmentation` instead."
+ )
+
+ batch_size, num_frames, num_channels, height, width = pixel_values_videos.shape
+ flat_pixel_values = pixel_values_videos.reshape(batch_size * num_frames, num_channels, height, width)
+
+ hidden_states = self.embeddings(flat_pixel_values)
+ query_start_idx = self.num_hidden_layers - self.config.num_blocks
+
+ for layer_module in self.layers[:query_start_idx]:
+ hidden_states = layer_module(hidden_states)
+
+ hidden_states = hidden_states.view(batch_size, num_frames, hidden_states.shape[1], hidden_states.shape[2])
+
+ all_masks_queries_logits = []
+ all_class_queries_logits = []
+ all_last_hidden_states = []
+ propagated_query = None
+
+ for frame_idx in range(num_frames):
+ frame_hidden_states = hidden_states[:, frame_idx]
+
+ if propagated_query is None:
+ query_tokens = self.query.weight[None, :, :].expand(batch_size, -1, -1).to(frame_hidden_states.device)
+ else:
+ query_tokens = self.query_updater(propagated_query).to(frame_hidden_states.device) + self.query.weight[
+ None, :, :
+ ].to(frame_hidden_states.device)
+ frame_hidden_states = torch.cat((query_tokens, frame_hidden_states), dim=1)
+
+ for layer_module in self.layers[query_start_idx:]:
+ frame_hidden_states = layer_module(frame_hidden_states)
+
+ sequence_output = self.layernorm(frame_hidden_states)
+ masks_queries_logits, class_queries_logits = self.predict(sequence_output)
+
+ all_masks_queries_logits.append(masks_queries_logits)
+ all_class_queries_logits.append(class_queries_logits)
+ all_last_hidden_states.append(sequence_output)
+ propagated_query = frame_hidden_states[:, : self.config.num_queries, :]
+
+ return VideomtForUniversalSegmentationOutput(
+ loss=None, # Training not supported yet
+ masks_queries_logits=torch.cat(all_masks_queries_logits, dim=0),
+ class_queries_logits=torch.cat(all_class_queries_logits, dim=0),
+ last_hidden_state=torch.cat(all_last_hidden_states, dim=0),
+ )
+
+ def get_input_embeddings(self):
+ return self.embeddings.patch_embeddings
+
+ def predict(self, logits: torch.Tensor):
+ query_tokens = logits[:, : self.config.num_queries, :]
+ class_logits = self.class_predictor(query_tokens)
+
+ prefix_tokens = logits[:, self.config.num_queries + self.embeddings.num_prefix_tokens :, :]
+ prefix_tokens = prefix_tokens.transpose(1, 2)
+
+ prefix_tokens = prefix_tokens.reshape(prefix_tokens.shape[0], -1, *self.grid_size)
+
+ query_tokens = self.mask_head(query_tokens)
+ prefix_tokens = self.upscale_block(prefix_tokens)
+
+ mask_logits = torch.einsum("bqc, bchw -> bqhw", query_tokens, prefix_tokens)
+
+ return mask_logits, class_logits
+
+
+__all__ = ["VideomtPreTrainedModel", "VideomtForUniversalSegmentation"]
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/modular_videomt.py b/lib/python3.11/site-packages/transformers/models/videomt/modular_videomt.py
new file mode 100644
index 0000000000000000000000000000000000000000..172c7fd117a6a53010e453eb05bb5fc6241aa0db
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomt/modular_videomt.py
@@ -0,0 +1,266 @@
+# Copyright 2026 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 dataclasses import dataclass
+
+import torch
+from huggingface_hub.dataclasses import strict
+from torch import nn
+
+from ...file_utils import ModelOutput
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring
+from ..eomt.configuration_eomt import EomtConfig
+from ..eomt.modeling_eomt import (
+ EomtEmbeddings,
+ EomtForUniversalSegmentation,
+ EomtLayer,
+ EomtLayerNorm2d,
+ EomtLayerScale,
+ EomtMLP,
+ EomtPatchEmbeddings,
+ EomtPreTrainedModel,
+ EomtScaleBlock,
+ EomtScaleLayer,
+ EomtSwiGLUFFN,
+)
+
+
+@auto_docstring(checkpoint="tue-mps/videomt-dinov2-small-ytvis2019")
+@strict
+class VideomtConfig(EomtConfig):
+ model_type = "videomt"
+
+
+class VideomtPatchEmbeddings(EomtPatchEmbeddings):
+ def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
+ num_channels = 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."
+ f" Expected {self.num_channels} but got {num_channels}."
+ )
+
+ pixel_values = pixel_values.to(dtype=self.projection.weight.dtype)
+ embeddings = self.projection(pixel_values).flatten(2).transpose(1, 2)
+ return embeddings
+
+
+class VideomtEmbeddings(EomtEmbeddings):
+ def __init__(self, config: VideomtConfig):
+ super().__init__(config)
+ self.patch_embeddings = VideomtPatchEmbeddings(config)
+ self.mask_token = nn.Parameter(torch.zeros(1, 1, config.hidden_size))
+
+ def forward(self, pixel_values: torch.Tensor, bool_masked_pos: torch.Tensor | None = None) -> torch.Tensor:
+ if pixel_values.ndim == 5:
+ batch_size, num_frames, num_channels, height, width = pixel_values.shape
+ pixel_values = pixel_values.reshape(batch_size * num_frames, num_channels, height, width)
+
+ if bool_masked_pos is not None:
+ bool_masked_pos = bool_masked_pos.reshape(batch_size * num_frames, -1)
+ elif bool_masked_pos is not None and bool_masked_pos.ndim > 2:
+ bool_masked_pos = bool_masked_pos.reshape(bool_masked_pos.shape[0], -1)
+
+ batch_size = pixel_values.shape[0]
+ embeddings = self.patch_embeddings(pixel_values)
+
+ if bool_masked_pos is not None:
+ mask = bool_masked_pos.to(device=embeddings.device, dtype=torch.bool).unsqueeze(-1)
+ embeddings = torch.where(mask, self.mask_token, embeddings)
+
+ cls_tokens = self.cls_token.expand(batch_size, -1, -1)
+ register_tokens = self.register_tokens.expand(batch_size, -1, -1)
+
+ embeddings = embeddings + self.position_embeddings(self.position_ids)
+ embeddings = torch.cat([cls_tokens, register_tokens, embeddings], dim=1)
+ embeddings = self.dropout(embeddings)
+ return embeddings
+
+
+class VideomtMLP(EomtMLP):
+ pass
+
+
+class VideomtGatedMLP(EomtSwiGLUFFN):
+ pass
+
+
+class VideomtLayer(EomtLayer):
+ pass
+
+
+class VideomtLayerScale(EomtLayerScale):
+ pass
+
+
+@auto_docstring(
+ custom_intro="""
+ Class for outputs of [`VideomtForUniversalSegmentationOutput`].
+
+ This output can be directly passed to [`~VideomtVideoProcessor.post_process_semantic_segmentation`] or
+ [`~VideomtVideoProcessor.post_process_instance_segmentation`] or
+ [`~VideomtVideoProcessor.post_process_panoptic_segmentation`] to compute final segmentation maps. Please, see
+ [`~VideomtVideoProcessor`] for details regarding usage.
+ """
+)
+@dataclass
+class VideomtForUniversalSegmentationOutput(ModelOutput):
+ r"""
+ loss (`torch.Tensor`, *optional*):
+ The computed loss, returned when labels are present.
+ class_queries_logits (`torch.FloatTensor`):
+ A tensor of shape `(batch_size, num_queries, num_labels + 1)` representing the proposed classes for each
+ query. Note the `+ 1` is needed because we incorporate the null class.
+ masks_queries_logits (`torch.FloatTensor`):
+ A tensor of shape `(batch_size, num_queries, height, width)` representing the proposed masks for each
+ query.
+ last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+ Last hidden states (final feature map) of the last layer.
+ hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
+ shape `(batch_size, sequence_length, hidden_size)`. Hidden-states all layers of the model.
+ attentions (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+ Tuple of `tuple(torch.FloatTensor)` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`. Self and Cross Attentions weights from transformer decoder.
+ """
+
+ loss: torch.FloatTensor | None = None
+ class_queries_logits: torch.FloatTensor | None = None
+ masks_queries_logits: torch.FloatTensor | None = None
+ last_hidden_state: torch.FloatTensor | None = None
+ hidden_states: tuple[torch.FloatTensor] | None = None
+ attentions: tuple[torch.FloatTensor] | None = None
+
+
+class VideomtPreTrainedModel(EomtPreTrainedModel):
+ main_input_name = "pixel_values_videos"
+ input_modalities = ("video",)
+
+ @torch.no_grad()
+ def _init_weights(self, module: nn.Module) -> None:
+ super()._init_weights(module)
+ if isinstance(module, VideomtEmbeddings):
+ nn.init.zeros_(module.mask_token)
+
+
+class VideomtLayerNorm2d(EomtLayerNorm2d):
+ pass
+
+
+class VideomtScaleLayer(EomtScaleLayer):
+ pass
+
+
+class VideomtScaleBlock(EomtScaleBlock):
+ pass
+
+
+class VideomtForUniversalSegmentation(EomtForUniversalSegmentation):
+ main_input_name = "pixel_values_videos"
+
+ def __init__(self, config: VideomtConfig):
+ super().__init__(config)
+ self.query_updater = nn.Linear(config.hidden_size, config.hidden_size)
+
+ def _disable_attention_mask(attn_mask, prob, num_query_tokens, encoder_start_tokens, device):
+ raise AttributeError("Not needed for Videomt")
+
+ def forward(
+ self,
+ pixel_values_videos: torch.Tensor | None = None,
+ mask_labels: list[torch.Tensor] | None = None,
+ class_labels: list[torch.Tensor] | None = None,
+ patch_offsets: list[torch.Tensor] | None = None, # Unused, kept for modular compatibility.
+ **kwargs: Unpack[TransformersKwargs],
+ ) -> VideomtForUniversalSegmentationOutput:
+ r"""
+ pixel_values_videos (`torch.Tensor`, *optional*):
+ Video inputs of shape `(batch_size, num_frames, num_channels, height, width)`.
+ mask_labels (`list[torch.Tensor]`, *optional*):
+ Not supported for 5D video inputs.
+ class_labels (`list[torch.LongTensor]`, *optional*):
+ Not supported for 5D video inputs.
+ patch_offsets (`list[torch.Tensor]`, *optional*):
+ Unused for video inputs and only kept for modular compatibility.
+ """
+ if "pixel_values" in kwargs:
+ raise ValueError("Use `pixel_values_videos` with `VideomtForUniversalSegmentation`.")
+
+ if pixel_values_videos is None:
+ raise ValueError("You have to specify pixel_values_videos")
+
+ if pixel_values_videos.ndim != 5:
+ raise ValueError(
+ "VideomtForUniversalSegmentation only supports 5D video inputs of shape "
+ "(batch_size, num_frames, channels, height, width)."
+ )
+
+ if mask_labels is not None or class_labels is not None:
+ raise ValueError(
+ "Training with 5D video inputs is not supported in `VideomtForUniversalSegmentation`. "
+ "Flatten frames and use `EomtForUniversalSegmentation` instead."
+ )
+
+ batch_size, num_frames, num_channels, height, width = pixel_values_videos.shape
+ flat_pixel_values = pixel_values_videos.reshape(batch_size * num_frames, num_channels, height, width)
+
+ hidden_states = self.embeddings(flat_pixel_values)
+ query_start_idx = self.num_hidden_layers - self.config.num_blocks
+
+ for layer_module in self.layers[:query_start_idx]:
+ hidden_states = layer_module(hidden_states)
+
+ hidden_states = hidden_states.view(batch_size, num_frames, hidden_states.shape[1], hidden_states.shape[2])
+
+ all_masks_queries_logits = []
+ all_class_queries_logits = []
+ all_last_hidden_states = []
+ propagated_query = None
+
+ for frame_idx in range(num_frames):
+ frame_hidden_states = hidden_states[:, frame_idx]
+
+ if propagated_query is None:
+ query_tokens = self.query.weight[None, :, :].expand(batch_size, -1, -1).to(frame_hidden_states.device)
+ else:
+ query_tokens = self.query_updater(propagated_query).to(frame_hidden_states.device) + self.query.weight[
+ None, :, :
+ ].to(frame_hidden_states.device)
+ frame_hidden_states = torch.cat((query_tokens, frame_hidden_states), dim=1)
+
+ for layer_module in self.layers[query_start_idx:]:
+ frame_hidden_states = layer_module(frame_hidden_states)
+
+ sequence_output = self.layernorm(frame_hidden_states)
+ masks_queries_logits, class_queries_logits = self.predict(sequence_output)
+
+ all_masks_queries_logits.append(masks_queries_logits)
+ all_class_queries_logits.append(class_queries_logits)
+ all_last_hidden_states.append(sequence_output)
+ propagated_query = frame_hidden_states[:, : self.config.num_queries, :]
+
+ return VideomtForUniversalSegmentationOutput(
+ loss=None, # Training not supported yet
+ masks_queries_logits=torch.cat(all_masks_queries_logits, dim=0),
+ class_queries_logits=torch.cat(all_class_queries_logits, dim=0),
+ last_hidden_state=torch.cat(all_last_hidden_states, dim=0),
+ )
+
+
+__all__ = [
+ "VideomtConfig",
+ "VideomtPreTrainedModel",
+ "VideomtForUniversalSegmentation",
+]
diff --git a/lib/python3.11/site-packages/transformers/models/videomt/video_processing_videomt.py b/lib/python3.11/site-packages/transformers/models/videomt/video_processing_videomt.py
new file mode 100644
index 0000000000000000000000000000000000000000..de1dd6816fceba347ab5c2a05b6721246e0ad564
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/videomt/video_processing_videomt.py
@@ -0,0 +1,364 @@
+# Copyright 2026 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.
+"""Video processor class for Videomt."""
+
+from ...image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling
+from ...utils import is_torch_available, requires_backends
+from ...video_processing_utils import BaseVideoProcessor
+
+
+if is_torch_available():
+ import torch
+ import torch.nn.functional as F
+
+
+def check_segment_validity(
+ mask_labels: "torch.Tensor",
+ mask_probs: "torch.Tensor",
+ query_idx: int,
+ mask_threshold: float = 0.5,
+ overlap_mask_area_threshold: float = 0.8,
+) -> tuple[bool, "torch.Tensor"]:
+ """
+ Checks whether a predicted query produces a valid panoptic segment.
+
+ Args:
+ mask_labels (`torch.Tensor`):
+ Tensor of shape `(height, width)` containing the winning query index for each pixel.
+ mask_probs (`torch.Tensor`):
+ Tensor of shape `(num_queries, height, width)` containing per-query mask probabilities.
+ query_idx (`int`):
+ Index of the query to validate.
+ mask_threshold (`float`, *optional*, defaults to 0.5):
+ Threshold used to binarize the query mask probabilities.
+ overlap_mask_area_threshold (`float`, *optional*, defaults to 0.8):
+ Minimum overlap ratio required between the assigned query area and the original query mask area.
+
+ Returns:
+ `tuple[bool, torch.Tensor]`: A tuple containing whether the segment is valid and the final boolean mask for
+ that segment.
+ """
+ query_mask = mask_labels == query_idx
+ query_mask_area = query_mask.sum()
+
+ original_mask = mask_probs[query_idx] >= mask_threshold
+ original_area = original_mask.sum()
+
+ final_mask = query_mask & original_mask
+ final_mask_area = final_mask.sum()
+
+ mask_exists = query_mask_area > 0 and original_area > 0 and final_mask_area > 0
+
+ if mask_exists:
+ area_ratio = query_mask_area / original_area
+ if not area_ratio.item() > overlap_mask_area_threshold:
+ mask_exists = False
+
+ return mask_exists, final_mask
+
+
+def compute_segments(
+ mask_probs: "torch.Tensor",
+ pred_scores: "torch.Tensor",
+ pred_labels: "torch.Tensor",
+ label_ids_to_fuse: set[int] | None,
+ mask_threshold: float = 0.5,
+ overlap_mask_area_threshold: float = 0.8,
+ target_size: tuple[int, int] | None = None,
+) -> tuple["torch.Tensor", list[dict[str, int | float]]]:
+ """
+ Converts per-query mask predictions into a panoptic segmentation map.
+
+ Args:
+ mask_probs (`torch.Tensor`):
+ Tensor of shape `(num_queries, height, width)` containing per-query mask logits.
+ pred_scores (`torch.Tensor`):
+ Tensor of shape `(num_queries,)` containing the confidence score of each predicted query.
+ pred_labels (`torch.Tensor`):
+ Tensor of shape `(num_queries,)` containing the predicted class ID of each query.
+ label_ids_to_fuse (`set[int]`, *optional*):
+ Label IDs that should be fused across disconnected regions.
+ mask_threshold (`float`, *optional*, defaults to 0.5):
+ Threshold used to binarize the query mask probabilities.
+ overlap_mask_area_threshold (`float`, *optional*, defaults to 0.8):
+ Minimum overlap ratio required to keep a predicted segment.
+ target_size (`tuple[int, int]`, *optional*):
+ Final `(height, width)` of the segmentation map. If unset, uses the spatial size of `mask_probs`.
+
+ Returns:
+ `tuple[torch.Tensor, list[dict[str, int | float]]]`: The panoptic segmentation map and the metadata for each
+ predicted segment.
+ """
+ height = mask_probs.shape[1] if target_size is None else target_size[0]
+ width = mask_probs.shape[2] if target_size is None else target_size[1]
+
+ segmentation = torch.zeros((height, width), dtype=torch.long, device=mask_probs.device) - 1
+ segments: list[dict] = []
+
+ mask_probs = mask_probs.sigmoid()
+ mask_labels = (pred_scores[:, None, None] * mask_probs).argmax(0)
+
+ current_segment_id = 0
+ stuff_memory_list: dict[int, int] = {}
+
+ for query_idx in range(pred_labels.shape[0]):
+ pred_class = pred_labels[query_idx].item()
+
+ mask_exists, final_mask = check_segment_validity(
+ mask_labels, mask_probs, query_idx, mask_threshold, overlap_mask_area_threshold
+ )
+
+ if not mask_exists:
+ continue
+
+ if label_ids_to_fuse and pred_class in label_ids_to_fuse:
+ if pred_class in stuff_memory_list:
+ segmentation[final_mask] = stuff_memory_list[pred_class]
+ continue
+ else:
+ stuff_memory_list[pred_class] = current_segment_id
+
+ segmentation[final_mask] = current_segment_id
+ segment_score = round(pred_scores[query_idx].item(), 6)
+ segments.append(
+ {
+ "id": current_segment_id,
+ "label_id": pred_class,
+ "score": segment_score,
+ }
+ )
+ current_segment_id += 1
+ return segmentation, segments
+
+
+class VideomtVideoProcessor(BaseVideoProcessor):
+ resample = PILImageResampling.BILINEAR
+ image_mean = IMAGENET_DEFAULT_MEAN
+ image_std = IMAGENET_DEFAULT_STD
+ size = {"height": 640, "width": 640}
+ do_resize = True
+ do_center_crop = False
+ do_rescale = True
+ rescale_factor = 1 / 255
+ do_normalize = True
+ do_convert_rgb = True
+ do_sample_frames = False
+ model_input_names = ["pixel_values_videos"]
+
+ def _resize_mask_logits(
+ self,
+ masks_queries_logits: "torch.Tensor",
+ target_sizes: list[tuple[int, int]],
+ ) -> list["torch.Tensor"]:
+ """Interpolates mask logits to each frame's original resolution."""
+ resized = []
+ for idx, original_size in enumerate(target_sizes):
+ upsampled = F.interpolate(
+ masks_queries_logits[idx][None, ...],
+ size=original_size,
+ mode="bilinear",
+ align_corners=False,
+ )[0]
+ resized.append(upsampled)
+ return resized
+
+ def post_process_semantic_segmentation(
+ self,
+ outputs,
+ target_sizes: list[tuple[int, int]],
+ ) -> list["torch.Tensor"]:
+ """
+ Converts the output of [`VideomtForUniversalSegmentation`] into semantic segmentation predictions.
+
+ Args:
+ outputs ([`VideomtForUniversalSegmentationOutput`]):
+ Raw outputs of the model.
+ target_sizes (`list[tuple[int, int]]`):
+ List of `(height, width)` tuples corresponding to the requested final size of each prediction.
+ Length should match the number of frames in the output.
+
+ Returns:
+ `list[torch.Tensor]`: A list of tensors, each of shape `(height, width)`, where each value is the
+ predicted class index for the corresponding pixel.
+ """
+ requires_backends(self, ["torch"])
+
+ masks_queries_logits = outputs.masks_queries_logits # [num_frames, num_queries, height, width]
+ class_queries_logits = outputs.class_queries_logits # [num_frames, num_queries, num_classes+1]
+
+ # Remove the null class `[..., :-1]`
+ masks_classes = class_queries_logits.float().softmax(dim=-1)[..., :-1]
+ masks_probs = masks_queries_logits.float().sigmoid()
+
+ segmentation_logits = torch.matmul(masks_classes.transpose(1, 2), masks_probs.flatten(2))
+ segmentation_logits = segmentation_logits.reshape(
+ masks_probs.shape[0], masks_classes.shape[-1], masks_probs.shape[-2], masks_probs.shape[-1]
+ )
+
+ output_logits = self._resize_mask_logits(segmentation_logits, target_sizes)
+
+ return [logit.argmax(dim=0) for logit in output_logits]
+
+ def post_process_instance_segmentation(
+ self,
+ outputs,
+ target_sizes: list[tuple[int, int]],
+ threshold: float = 0.5,
+ ) -> list[dict]:
+ """
+ Converts the output of [`VideomtForUniversalSegmentation`] into instance segmentation predictions.
+
+ Args:
+ outputs ([`VideomtForUniversalSegmentationOutput`]):
+ Raw outputs of the model.
+ target_sizes (`list[tuple[int, int]]`):
+ List of `(height, width)` tuples corresponding to the requested final size of each prediction.
+ Length should match the number of frames in the output.
+ threshold (`float`, *optional*, defaults to 0.5):
+ Minimum combined score to keep an instance.
+
+ Returns:
+ `list[dict]`: A list of dicts (one per frame), each containing:
+ - `"segmentation"` -- A `torch.Tensor` of shape `(height, width)` with instance IDs (or -1 for background).
+ - `"segments_info"` -- A list of dicts with `"id"`, `"label_id"`, and `"score"` for each instance.
+ """
+ requires_backends(self, ["torch"])
+
+ class_queries_logits = outputs.class_queries_logits
+ masks_queries_logits = outputs.masks_queries_logits
+
+ mask_probs_batch = self._resize_mask_logits(masks_queries_logits, target_sizes)
+
+ device = masks_queries_logits.device
+ num_frames = class_queries_logits.shape[0]
+ num_queries = class_queries_logits.shape[-2]
+
+ results = []
+
+ for frame_idx in range(num_frames):
+ mask_pred = mask_probs_batch[frame_idx]
+ mask_class = class_queries_logits[frame_idx]
+
+ class_probs = mask_class.float().softmax(dim=-1)[..., :-1]
+ scores, pred_classes = class_probs.max(-1)
+ pred_masks = mask_pred > 0
+
+ mask_probs = mask_pred.float().sigmoid()
+ mask_scores = (mask_probs.flatten(1) * pred_masks.flatten(1)).sum(1) / (
+ pred_masks.flatten(1).sum(1) + 1e-6
+ )
+ pred_scores = scores * mask_scores
+
+ segmentation = torch.full(target_sizes[frame_idx], fill_value=-1, dtype=torch.long, device=device)
+
+ segments = []
+ current_segment_id = 0
+ for query_idx in range(num_queries):
+ score = pred_scores[query_idx].item()
+
+ if torch.any(pred_masks[query_idx]) and score >= threshold:
+ segmentation[pred_masks[query_idx]] = current_segment_id
+ segments.append(
+ {
+ "id": current_segment_id,
+ "label_id": pred_classes[query_idx].item(),
+ "score": round(score, 6),
+ }
+ )
+ current_segment_id += 1
+
+ results.append({"segmentation": segmentation, "segments_info": segments})
+ return results
+
+ def post_process_panoptic_segmentation(
+ self,
+ outputs,
+ target_sizes: list[tuple[int, int]],
+ threshold: float = 0.8,
+ mask_threshold: float = 0.5,
+ overlap_mask_area_threshold: float = 0.8,
+ label_ids_to_fuse: set[int] | None = None,
+ ) -> list[dict]:
+ """
+ Converts the output of [`VideomtForUniversalSegmentation`] into panoptic segmentation predictions.
+
+ Args:
+ outputs ([`VideomtForUniversalSegmentationOutput`]):
+ Raw outputs of the model.
+ target_sizes (`list[tuple[int, int]]`):
+ List of `(height, width)` tuples corresponding to the requested final size of each prediction.
+ Length should match the number of frames in the output.
+ threshold (`float`, *optional*, defaults to 0.8):
+ Minimum score to keep a predicted segment.
+ mask_threshold (`float`, *optional*, defaults to 0.5):
+ Threshold for binarizing mask probabilities.
+ overlap_mask_area_threshold (`float`, *optional*, defaults to 0.8):
+ Overlap threshold to merge masks into a single segment.
+ label_ids_to_fuse (`set[int]`, *optional*):
+ Label IDs that should be fused across disconnected regions.
+
+ Returns:
+ `list[dict]`: A list of dicts (one per frame), each containing:
+ - `"segmentation"` -- A `torch.Tensor` of shape `(height, width)` with segment IDs (or -1 for background).
+ - `"segments_info"` -- A list of dicts with `"id"`, `"label_id"`, and `"score"` for each segment.
+ """
+ requires_backends(self, ["torch"])
+
+ masks_queries_logits = outputs.masks_queries_logits
+ class_queries_logits = outputs.class_queries_logits
+
+ num_frames = class_queries_logits.shape[0]
+ num_labels = class_queries_logits.shape[-1] - 1
+
+ mask_probs_batch = self._resize_mask_logits(masks_queries_logits, target_sizes)
+ pred_scores_batch, pred_labels_batch = class_queries_logits.float().softmax(dim=-1).max(-1)
+
+ results: list = []
+
+ for frame_idx in range(num_frames):
+ mask_probs = mask_probs_batch[frame_idx]
+ pred_scores = pred_scores_batch[frame_idx]
+ pred_labels = pred_labels_batch[frame_idx]
+
+ if not (mask_probs.shape[0] == pred_scores.shape[0] == pred_labels.shape[0]):
+ raise ValueError("mask, scores and labels must have the same shape!")
+
+ to_keep = pred_labels.ne(num_labels) & (pred_scores > threshold)
+ mask_probs = mask_probs[to_keep]
+ pred_scores = pred_scores[to_keep]
+ pred_labels = pred_labels[to_keep]
+
+ if mask_probs.shape[0] <= 0:
+ height, width = target_sizes[frame_idx] if target_sizes is not None else mask_probs.shape[1:]
+ segmentation = torch.full(
+ (height, width), fill_value=-1, dtype=torch.long, device=masks_queries_logits.device
+ )
+ results.append({"segmentation": segmentation, "segments_info": []})
+ continue
+
+ segmentation, segments = compute_segments(
+ mask_probs=mask_probs,
+ pred_scores=pred_scores,
+ pred_labels=pred_labels,
+ label_ids_to_fuse=label_ids_to_fuse,
+ mask_threshold=mask_threshold,
+ overlap_mask_area_threshold=overlap_mask_area_threshold,
+ target_size=target_sizes[frame_idx] if target_sizes is not None else None,
+ )
+
+ results.append({"segmentation": segmentation, "segments_info": segments})
+ return results
+
+
+__all__ = ["VideomtVideoProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/models/vilt/__init__.py b/lib/python3.11/site-packages/transformers/models/vilt/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..962b2785e8cfd5cec4efad46a4994bd794fe956c
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vilt/__init__.py
@@ -0,0 +1,31 @@
+# Copyright 2024 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_vilt import *
+ from .feature_extraction_vilt import *
+ from .image_processing_pil_vilt import *
+ from .image_processing_vilt import *
+ from .modeling_vilt import *
+ from .processing_vilt import *
+else:
+ import sys
+
+ _file = globals()["__file__"]
+ sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)
diff --git a/lib/python3.11/site-packages/transformers/models/vilt/configuration_vilt.py b/lib/python3.11/site-packages/transformers/models/vilt/configuration_vilt.py
new file mode 100644
index 0000000000000000000000000000000000000000..4227dfd02f3464c8d2472295e61aa2a97a9c18dd
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vilt/configuration_vilt.py
@@ -0,0 +1,82 @@
+# Copyright 2022 The HuggingFace Inc. 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.
+"""VilT model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="dandelin/vilt-b32-mlm")
+@strict
+class ViltConfig(PreTrainedConfig):
+ r"""
+ modality_type_vocab_size (`int`, *optional*, defaults to 2):
+ The vocabulary size of the modalities passed when calling [`ViltModel`]. This is used after concatenating the
+ embeddings of the text and image modalities.
+ max_image_length (`int`, *optional*, defaults to -1):
+ The maximum number of patches to take as input for the Transformer encoder. If set to a positive integer,
+ the encoder will sample `max_image_length` patches at maximum. If set to -1, will not be taken into
+ account.
+ num_images (`int`, *optional*, defaults to -1):
+ The number of images to use for natural language visual reasoning. If set to a positive integer, will be
+ used by [`ViltForImagesAndTextClassification`] for defining the classifier head.
+
+ Example:
+
+ ```python
+ >>> from transformers import ViLTModel, ViLTConfig
+
+ >>> # Initializing a ViLT dandelin/vilt-b32-mlm style configuration
+ >>> configuration = ViLTConfig()
+
+ >>> # Initializing a model from the dandelin/vilt-b32-mlm style configuration
+ >>> model = ViLTModel(configuration)
+
+ >>> # Accessing the model configuration
+ >>> configuration = model.config
+ ```"""
+
+ model_type = "vilt"
+
+ vocab_size: int = 30522
+ type_vocab_size: int = 2
+ modality_type_vocab_size: int = 2
+ max_position_embeddings: int = 40
+ hidden_size: int = 768
+ num_hidden_layers: int = 12
+ num_attention_heads: int = 12
+ intermediate_size: int = 3072
+ hidden_act: str = "gelu"
+ hidden_dropout_prob: float | int = 0.0
+ attention_probs_dropout_prob: float | int = 0.0
+ initializer_range: float = 0.02
+ layer_norm_eps: float = 1e-12
+ image_size: int | list[int] | tuple[int, int] = 384
+ patch_size: int | list[int] | tuple[int, int] = 32
+ num_channels: int = 3
+ qkv_bias: bool = True
+ max_image_length: int = -1
+ tie_word_embeddings: bool = True
+ num_images: int = -1
+ pad_token_id: int | None = None
+
+ def __post_init__(self, **kwargs):
+ kwargs.pop("tie_word_embeddings", None)
+ self.tie_word_embeddings = True # force it
+ super().__post_init__(**kwargs)
+
+
+__all__ = ["ViltConfig"]
diff --git a/lib/python3.11/site-packages/transformers/models/vilt/image_processing_pil_vilt.py b/lib/python3.11/site-packages/transformers/models/vilt/image_processing_pil_vilt.py
new file mode 100644
index 0000000000000000000000000000000000000000..88948e0ef538bb5ebbb659ae9bf87bb195d15a09
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vilt/image_processing_pil_vilt.py
@@ -0,0 +1,245 @@
+# Copyright 2025 The HuggingFace Inc. 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.
+"""Image processor class for Vilt."""
+
+from collections.abc import Iterable
+from typing import Any
+
+import numpy as np
+
+from ...image_processing_backends import PilBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import PaddingMode, pad
+from ...image_utils import (
+ IMAGENET_STANDARD_MEAN,
+ IMAGENET_STANDARD_STD,
+ ChannelDimension,
+ PILImageResampling,
+ SizeDict,
+ get_image_size,
+ get_max_height_width,
+)
+from ...processing_utils import ImagesKwargs
+from ...utils import (
+ TensorType,
+ auto_docstring,
+)
+
+
+# Set maximum size based on the typical aspect ratio of the COCO dataset
+MAX_LONGER_EDGE = 1333
+MAX_SHORTER_EDGE = 800
+
+
+def max_across_indices(values: Iterable[Any]) -> list[Any]:
+ """
+ Return the maximum value across all indices of an iterable of values.
+ """
+ return [max(values_i) for values_i in zip(*values)]
+
+
+def make_pixel_mask(
+ image: np.ndarray, output_size: tuple[int, int], input_data_format: str | ChannelDimension | None = None
+) -> np.ndarray:
+ """
+ Make a pixel mask for the image, where 1 indicates a valid pixel and 0 indicates padding.
+
+ Args:
+ image (`np.ndarray`):
+ Image to make the pixel mask for.
+ output_size (`tuple[int, int]`):
+ Output size of the mask.
+ """
+ input_height, input_width = get_image_size(image, channel_dim=input_data_format)
+ mask = np.zeros(output_size, dtype=np.int64)
+ mask[:input_height, :input_width] = 1
+ return mask
+
+
+def get_resize_output_image_size(
+ input_image: np.ndarray,
+ shorter: int = 800,
+ longer: int = 1333,
+ size_divisor: int = 32,
+ input_data_format: str | ChannelDimension | None = None,
+) -> tuple[int, int]:
+ input_height, input_width = get_image_size(input_image, input_data_format)
+ min_size, max_size = shorter, longer
+
+ scale = min_size / min(input_height, input_width)
+
+ if input_height < input_width:
+ new_height = min_size
+ new_width = scale * input_width
+ else:
+ new_height = scale * input_height
+ new_width = min_size
+
+ if max(new_height, new_width) > max_size:
+ scale = max_size / max(new_height, new_width)
+ new_height = scale * new_height
+ new_width = scale * new_width
+
+ new_height, new_width = int(new_height + 0.5), int(new_width + 0.5)
+ new_height = new_height // size_divisor * size_divisor
+ new_width = new_width // size_divisor * size_divisor
+
+ return new_height, new_width
+
+
+# Adapted from transformers.models.vilt.image_processing_vilt.ViltImageProcessorKwargs
+class ViltImageProcessorKwargs(ImagesKwargs, total=False):
+ r"""
+ size_divisor (`int`, *optional*, defaults to `self.size_divisor`):
+ The size by which to make sure both the height and width can be divided. Only has an effect if `do_resize`
+ is set to `True`.
+ """
+
+ size_divisor: int
+
+
+@auto_docstring
+class ViltImageProcessorPil(PilBackend):
+ valid_kwargs = ViltImageProcessorKwargs
+ resample = PILImageResampling.BICUBIC
+ image_mean = IMAGENET_STANDARD_MEAN
+ image_std = IMAGENET_STANDARD_STD
+ size = {"shortest_edge": 384}
+ do_resize = True
+ do_rescale = True
+ do_normalize = True
+ size_divisor = 32
+ do_pad = True
+ default_to_square = False
+ model_input_names = ["pixel_values", "pixel_mask"]
+
+ def resize(
+ self,
+ image: np.ndarray,
+ size: SizeDict,
+ resample: "PILImageResampling | None" = None,
+ size_divisor: int | None = None,
+ ) -> np.ndarray:
+ """
+ Resize an image to specified size.
+
+ Args:
+ image (`np.ndarray`): Image to resize.
+ size (`SizeDict`): Size dictionary with shortest_edge key.
+ resample (`PILImageResampling | int`, *optional*): Interpolation method to use.
+ size_divisor (`int`, *optional*): Value to ensure height/width are divisible by.
+
+ Returns:
+ `np.ndarray`: Resized image.
+ """
+ if not hasattr(size, "shortest_edge") or size.shortest_edge is None:
+ raise ValueError(f"The `size` dictionary must contain the key `shortest_edge`. Got {size}")
+ shorter = size.shortest_edge
+ longer = int(MAX_LONGER_EDGE / MAX_SHORTER_EDGE * shorter)
+ output_size = get_resize_output_image_size(
+ image,
+ shorter=shorter,
+ longer=longer,
+ size_divisor=size_divisor or self.size_divisor,
+ input_data_format=ChannelDimension.FIRST,
+ )
+
+ return super().resize(image, SizeDict(height=output_size[0], width=output_size[1]), resample=resample)
+
+ def _pad_batch(
+ self,
+ images: list[np.ndarray],
+ return_tensors: str | TensorType | None,
+ ) -> tuple:
+ """
+ Pad a batch of images to the same size based on the maximum dimensions.
+
+ Args:
+ images (`list[np.ndarray]`): List of images to pad.
+ return_tensors (`str` or `TensorType`, *optional*): The type of tensors to return.
+
+ Returns:
+ `tuple`: Tuple containing padded images and pixel masks.
+ """
+ # Calculate global maximum dimensions across all images
+ max_size = get_max_height_width(images, input_data_format=ChannelDimension.FIRST)
+
+ padded_images = []
+ pixel_masks = []
+
+ for image in images:
+ input_height, input_width = get_image_size(image, channel_dim=ChannelDimension.FIRST)
+ needs_padding = input_height != max_size[0] or input_width != max_size[1]
+
+ if needs_padding:
+ pad_bottom = max_size[0] - input_height
+ pad_right = max_size[1] - input_width
+ padding = ((0, pad_bottom), (0, pad_right))
+
+ padded_image = pad(
+ image,
+ padding,
+ mode=PaddingMode.CONSTANT,
+ constant_values=0,
+ data_format=ChannelDimension.FIRST,
+ input_data_format=ChannelDimension.FIRST,
+ )
+ pixel_mask = make_pixel_mask(image, max_size, input_data_format=ChannelDimension.FIRST)
+ else:
+ padded_image = image
+ pixel_mask = np.ones(max_size, dtype=np.int64)
+
+ padded_images.append(padded_image)
+ pixel_masks.append(pixel_mask)
+
+ return padded_images, pixel_masks
+
+ def _preprocess(
+ self,
+ images: list[np.ndarray],
+ do_resize: bool,
+ size: SizeDict,
+ resample: "PILImageResampling | None",
+ do_rescale: bool,
+ rescale_factor: float,
+ do_normalize: bool,
+ image_mean: float | list[float] | None,
+ image_std: float | list[float] | None,
+ do_pad: bool | None,
+ return_tensors: str | TensorType | None,
+ size_divisor: int | None = None,
+ **kwargs,
+ ) -> BatchFeature:
+ processed_images = []
+ for image in images:
+ if do_resize:
+ image = self.resize(image, size, resample, size_divisor)
+ if do_rescale:
+ image = self.rescale(image, rescale_factor)
+ if do_normalize:
+ image = self.normalize(image, image_mean, image_std)
+ processed_images.append(image)
+
+ # Handle padding if required
+ data = {}
+ if do_pad:
+ pixel_values, pixel_mask = self._pad_batch(processed_images, return_tensors)
+ data = {"pixel_values": pixel_values, "pixel_mask": pixel_mask}
+ else:
+ data = {"pixel_values": processed_images}
+
+ return BatchFeature(data=data, tensor_type=return_tensors)
+
+
+__all__ = ["ViltImageProcessorPil"]
diff --git a/lib/python3.11/site-packages/transformers/models/vilt/processing_vilt.py b/lib/python3.11/site-packages/transformers/models/vilt/processing_vilt.py
new file mode 100644
index 0000000000000000000000000000000000000000..be47b2e6ee754c9b00660040bb7407f69b32483e
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/models/vilt/processing_vilt.py
@@ -0,0 +1,45 @@
+# Copyright 2022 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.
+"""
+Processor class for ViLT.
+"""
+
+from ...processing_utils import ProcessingKwargs, ProcessorMixin
+from ...utils import auto_docstring
+
+
+class ViltProcessorKwargs(ProcessingKwargs, total=False):
+ _defaults = {
+ "text_kwargs": {
+ "add_special_tokens": True,
+ "padding": False,
+ "stride": 0,
+ "return_overflowing_tokens": False,
+ "return_special_tokens_mask": False,
+ "return_offsets_mapping": False,
+ "return_length": False,
+ "verbose": True,
+ },
+ }
+
+
+@auto_docstring
+class ViltProcessor(ProcessorMixin):
+ valid_processor_kwargs = ViltProcessorKwargs
+
+ def __init__(self, image_processor=None, tokenizer=None, **kwargs):
+ super().__init__(image_processor, tokenizer)
+
+
+__all__ = ["ViltProcessor"]
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fa33930114085e06ed98833267b700712f2e4ec3
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/audio_classification.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/audio_classification.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f02580c1f0e82ded41ab11f642b0573248e320ee
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/audio_classification.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/audio_utils.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/audio_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5dea575a19aa5ecad2526a2085d454775a8d0df6
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/audio_utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/automatic_speech_recognition.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/automatic_speech_recognition.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d47cbf78d746038b902f823620ca28d3831d424c
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/automatic_speech_recognition.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/base.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/base.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99a754414c232951ebd2e1e98a82d75dc1e7d55d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/base.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/depth_estimation.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/depth_estimation.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2fa7c0527284620bb9a3320cdb18b4694e22f181
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/depth_estimation.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/document_question_answering.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/document_question_answering.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7cebca531c72f4f002d1361f08a5c0aa229047c
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/document_question_answering.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/feature_extraction.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/feature_extraction.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9411f30fc530b86f5907f83cc9ef332b0cb321ed
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/feature_extraction.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/fill_mask.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/fill_mask.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..817504924ecabfe9dfbeb0898f5fa9d145552789
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/fill_mask.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_classification.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_classification.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d861d51099fadc064f05c93019f61a52d5866afa
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_classification.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_feature_extraction.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_feature_extraction.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..12ec0bc6e4a38886dd2b7987f2274b9121746079
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_feature_extraction.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_segmentation.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_segmentation.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..07922ad1c08afb386299b683b5dacbf9cefb296b
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_segmentation.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_text_to_text.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_text_to_text.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..674194b043c3d63c2c82db706a04351a56b7dae9
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/image_text_to_text.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/keypoint_matching.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/keypoint_matching.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a924a3e20035af084a0ed472fcff38dc03b75a76
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/keypoint_matching.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/mask_generation.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/mask_generation.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30ab537be11a18cc1e78cde666c4940f8d22ff60
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/mask_generation.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/object_detection.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/object_detection.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8ca3033874426883143094a852ea2ae460c7e54e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/object_detection.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/pt_utils.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/pt_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f9f51709d3ed94438b564314275738723249757
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/pt_utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/table_question_answering.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/table_question_answering.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14c31abb83d285506755fb9898e8a4eb6e4143c8
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/table_question_answering.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/text_classification.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/text_classification.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0876b2800e3f869f4edc36ade2f7b0b994c571fa
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/text_classification.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/text_generation.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/text_generation.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..979ce5bea15b1d79ebc6b2078fd14f5b68016cce
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/text_generation.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/text_to_audio.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/text_to_audio.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..27d3eef459f2469013460427ee0e45c7d6f407ab
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/text_to_audio.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/token_classification.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/token_classification.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74a55b4473fb68a68e70a6570b62b4d1009a3716
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/token_classification.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/video_classification.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/video_classification.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fa0cfc77a8ba8f07ea578288d08e7d617ed3d612
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/video_classification.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_audio_classification.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_audio_classification.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3b502eb614d7bf32f7df7bdef3496a6fd177cf21
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_audio_classification.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_classification.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_classification.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4991a2ec8abee9bfce5cb53b432b76db9abbbd7f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_classification.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_image_classification.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_image_classification.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2cf108f6ed8bae1cdd3253dc94996a9de33c9b1
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_image_classification.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_object_detection.cpython-311.pyc b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_object_detection.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..871b5c4e1338843f047f4c16e736172b89e88621
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/pipelines/__pycache__/zero_shot_object_detection.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__init__.py b/lib/python3.11/site-packages/transformers/quantizers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7117bc2b5d8045380f582ac09338af3f3f3e3f61
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/__init__.py
@@ -0,0 +1,16 @@
+# Copyright 2024 The HuggingFace Inc. 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 .auto import AutoHfQuantizer, AutoQuantizationConfig, register_quantization_config, register_quantizer
+from .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..149f541edbc6a6208d2b8c2c0a153a284abd99f6
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/auto.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/auto.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f877498a75453efdc4193e1516f9377d996c4daf
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/auto.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/base.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/base.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c2244f3717363562082a885a1b323d05069c0d1
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/base.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_aqlm.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_aqlm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1af5cb98c61a5e3d361e5cb66ec04d632e85835d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_aqlm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_auto_round.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_auto_round.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6c991a7911cb9f367af76982aee901e6bcd62e1
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_auto_round.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_awq.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_awq.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..40f9f1ceadd3409ce79a0f64552a5364abaebd19
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_awq.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_bitnet.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_bitnet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7e2fc54ad1f058a4777e149b647b293c5d2755cf
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_bitnet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_bnb_4bit.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_bnb_4bit.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..daa5afc6901283755ba9bf7ffe785e352bcf19b4
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_bnb_4bit.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_bnb_8bit.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_bnb_8bit.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e202e877689822424970b33cae9ed800641d202e
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_bnb_8bit.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_compressed_tensors.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_compressed_tensors.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a494018da9c2fd9ecc3c4f231bddae3ecda9fac
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_compressed_tensors.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_eetq.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_eetq.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b1ec01ecc2e78ab9fb0690a316fd6b38688f141f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_eetq.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_fbgemm_fp8.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_fbgemm_fp8.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..51c411c1e6985f0179ce5926f5e0205edfd4c737
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_fbgemm_fp8.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_finegrained_fp8.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_finegrained_fp8.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2642041d7d5295aff9f04321ed150be04832738
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_finegrained_fp8.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_fouroversix.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_fouroversix.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c0fec9866b3cd927527a5fab28a972d462a94707
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_fouroversix.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_fp_quant.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_fp_quant.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6e2b22cf88954a207d28d195cc192ef20ceb3d5
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_fp_quant.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_gptq.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_gptq.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ff7864535bdef9f6ab11cd14f025d10d8df8189
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_gptq.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_higgs.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_higgs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67c7db808bf43e16049da18785da7b787832d6c3
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_higgs.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_hqq.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_hqq.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..124b13b6e9a6a72a0b963d7ee25573de68232f4d
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_hqq.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_metal.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_metal.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e72e41690781e187e7b50036eff87f6a643083a4
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_metal.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_mxfp4.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_mxfp4.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7bb6ad87e4a619b85ba8b6d7ba1d72c0b83f70d9
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_mxfp4.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_quanto.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_quanto.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af33f62b3f7e6741a85dfac882f3982385d74289
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_quanto.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_quark.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_quark.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..038aeeb7a4c6e9283c239ad949ecb4ef0a1d5020
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_quark.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_sinq.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_sinq.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5f500c331ab4c92c2c8581b3799b9c80d87a9c01
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_sinq.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_spqr.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_spqr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4da7249aabfd252806e28372f3aa3c11d8f1a0ed
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_spqr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_torchao.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_torchao.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23b4d25e56c912a3d9d3fa2d62ae2a31c351b561
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_torchao.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_vptq.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_vptq.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5abd51b847dfcd6172f7cb2caa9167581e5f5b60
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizer_vptq.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizers_utils.cpython-311.pyc b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizers_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d0b7e466c6af52df0b2a217892485d39bb10aa4f
Binary files /dev/null and b/lib/python3.11/site-packages/transformers/quantizers/__pycache__/quantizers_utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/transformers/quantizers/auto.py b/lib/python3.11/site-packages/transformers/quantizers/auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..a972c6f637bb23092426e42a04be3753c97f58b5
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/auto.py
@@ -0,0 +1,354 @@
+# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
+# Modifications Copyright (C) 2025, Advanced Micro Devices, Inc. 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 warnings
+
+from ..models.auto.configuration_auto import AutoConfig
+from ..utils import logging
+from ..utils.quantization_config import (
+ AqlmConfig,
+ AutoRoundConfig,
+ AwqConfig,
+ BitNetQuantConfig,
+ BitsAndBytesConfig,
+ CompressedTensorsConfig,
+ EetqConfig,
+ FbgemmFp8Config,
+ FineGrainedFP8Config,
+ FourOverSixConfig,
+ FPQuantConfig,
+ GPTQConfig,
+ HiggsConfig,
+ HqqConfig,
+ MetalConfig,
+ Mxfp4Config,
+ QuantizationConfigMixin,
+ QuantizationMethod,
+ QuantoConfig,
+ QuarkConfig,
+ SinqConfig,
+ SpQRConfig,
+ TorchAoConfig,
+ VptqConfig,
+)
+from .base import HfQuantizer
+from .quantizer_aqlm import AqlmHfQuantizer
+from .quantizer_auto_round import AutoRoundQuantizer
+from .quantizer_awq import AwqQuantizer
+from .quantizer_bitnet import BitNetHfQuantizer
+from .quantizer_bnb_4bit import Bnb4BitHfQuantizer
+from .quantizer_bnb_8bit import Bnb8BitHfQuantizer
+from .quantizer_compressed_tensors import CompressedTensorsHfQuantizer
+from .quantizer_eetq import EetqHfQuantizer
+from .quantizer_fbgemm_fp8 import FbgemmFp8HfQuantizer
+from .quantizer_finegrained_fp8 import FineGrainedFP8HfQuantizer
+from .quantizer_fouroversix import FourOverSixHfQuantizer
+from .quantizer_fp_quant import FPQuantHfQuantizer
+from .quantizer_gptq import GptqHfQuantizer
+from .quantizer_higgs import HiggsHfQuantizer
+from .quantizer_hqq import HqqHfQuantizer
+from .quantizer_metal import MetalHfQuantizer
+from .quantizer_mxfp4 import Mxfp4HfQuantizer
+from .quantizer_quanto import QuantoHfQuantizer
+from .quantizer_quark import QuarkHfQuantizer
+from .quantizer_sinq import SinqHfQuantizer
+from .quantizer_spqr import SpQRHfQuantizer
+from .quantizer_torchao import TorchAoHfQuantizer
+from .quantizer_vptq import VptqHfQuantizer
+
+
+AUTO_QUANTIZER_MAPPING = {
+ "awq": AwqQuantizer,
+ "bitsandbytes_4bit": Bnb4BitHfQuantizer,
+ "bitsandbytes_8bit": Bnb8BitHfQuantizer,
+ "gptq": GptqHfQuantizer,
+ "aqlm": AqlmHfQuantizer,
+ "quanto": QuantoHfQuantizer,
+ "quark": QuarkHfQuantizer,
+ "fouroversix": FourOverSixHfQuantizer,
+ "fp_quant": FPQuantHfQuantizer,
+ "eetq": EetqHfQuantizer,
+ "higgs": HiggsHfQuantizer,
+ "hqq": HqqHfQuantizer,
+ "compressed-tensors": CompressedTensorsHfQuantizer,
+ "fbgemm_fp8": FbgemmFp8HfQuantizer,
+ "torchao": TorchAoHfQuantizer,
+ "bitnet": BitNetHfQuantizer,
+ "vptq": VptqHfQuantizer,
+ "spqr": SpQRHfQuantizer,
+ "fp8": FineGrainedFP8HfQuantizer,
+ "auto-round": AutoRoundQuantizer,
+ "mxfp4": Mxfp4HfQuantizer,
+ "metal": MetalHfQuantizer,
+ "sinq": SinqHfQuantizer,
+}
+
+AUTO_QUANTIZATION_CONFIG_MAPPING = {
+ "awq": AwqConfig,
+ "bitsandbytes_4bit": BitsAndBytesConfig,
+ "bitsandbytes_8bit": BitsAndBytesConfig,
+ "eetq": EetqConfig,
+ "gptq": GPTQConfig,
+ "aqlm": AqlmConfig,
+ "quanto": QuantoConfig,
+ "quark": QuarkConfig,
+ "fouroversix": FourOverSixConfig,
+ "fp_quant": FPQuantConfig,
+ "hqq": HqqConfig,
+ "compressed-tensors": CompressedTensorsConfig,
+ "fbgemm_fp8": FbgemmFp8Config,
+ "higgs": HiggsConfig,
+ "torchao": TorchAoConfig,
+ "bitnet": BitNetQuantConfig,
+ "vptq": VptqConfig,
+ "spqr": SpQRConfig,
+ "fp8": FineGrainedFP8Config,
+ "auto-round": AutoRoundConfig,
+ "mxfp4": Mxfp4Config,
+ "metal": MetalConfig,
+ "sinq": SinqConfig,
+}
+
+LOADING_ATTRIBUTES_CONFIG_TYPES = (
+ GPTQConfig,
+ AwqConfig,
+ AutoRoundConfig,
+ FbgemmFp8Config,
+ CompressedTensorsConfig,
+ Mxfp4Config,
+ MetalConfig,
+ FineGrainedFP8Config,
+)
+
+logger = logging.get_logger(__name__)
+
+
+class AutoQuantizationConfig:
+ """
+ The Auto-HF quantization config class that takes care of automatically dispatching to the correct
+ quantization config given a quantization config stored in a dictionary.
+ """
+
+ @classmethod
+ def from_dict(cls, quantization_config_dict: dict):
+ quant_method = quantization_config_dict.get("quant_method")
+ # We need a special care for bnb models to make sure everything is BC ..
+ if quantization_config_dict.get("load_in_8bit", False) or quantization_config_dict.get("load_in_4bit", False):
+ suffix = "_4bit" if quantization_config_dict.get("load_in_4bit", False) else "_8bit"
+ quant_method = QuantizationMethod.BITS_AND_BYTES + suffix
+ elif quant_method is None:
+ raise ValueError(
+ "The model's quantization config from the arguments has no `quant_method` attribute. Make sure that the model has been correctly quantized"
+ )
+
+ if quant_method not in AUTO_QUANTIZATION_CONFIG_MAPPING:
+ raise ValueError(
+ f"Unknown quantization type, got {quant_method} - supported types are:"
+ f" {list(AUTO_QUANTIZER_MAPPING.keys())}"
+ )
+
+ target_cls = AUTO_QUANTIZATION_CONFIG_MAPPING[quant_method]
+ return target_cls.from_dict(quantization_config_dict)
+
+ @classmethod
+ def from_pretrained(cls, pretrained_model_name_or_path, **kwargs):
+ model_config = AutoConfig.from_pretrained(pretrained_model_name_or_path, **kwargs)
+ if getattr(model_config, "quantization_config", None) is None:
+ raise ValueError(
+ f"Did not found a `quantization_config` in {pretrained_model_name_or_path}. Make sure that the model is correctly quantized."
+ )
+ quantization_config_dict = model_config.quantization_config
+ quantization_config = cls.from_dict(quantization_config_dict)
+ # Update with potential kwargs that are passed through from_pretrained.
+ quantization_config.update(**kwargs)
+ return quantization_config
+
+
+class AutoHfQuantizer:
+ """
+ The Auto-HF quantizer class that takes care of automatically instantiating to the correct
+ `HfQuantizer` given the `QuantizationConfig`.
+ """
+
+ @classmethod
+ def from_config(cls, quantization_config: QuantizationConfigMixin | dict, **kwargs):
+ # Convert it to a QuantizationConfig if the q_config is a dict
+ if isinstance(quantization_config, dict):
+ quantization_config = AutoQuantizationConfig.from_dict(quantization_config)
+
+ quant_method = quantization_config.quant_method
+
+ # Again, we need a special care for bnb as we have a single quantization config
+ # class for both 4-bit and 8-bit quantization
+ if quant_method == QuantizationMethod.BITS_AND_BYTES:
+ if not isinstance(quantization_config, BitsAndBytesConfig):
+ raise TypeError(
+ "Found `quant_method=bitsandbytes` but `quantization_config` is not a `BitsAndBytesConfig`."
+ )
+ if quantization_config.load_in_8bit:
+ quant_method += "_8bit"
+ else:
+ quant_method += "_4bit"
+
+ if quant_method not in AUTO_QUANTIZER_MAPPING:
+ raise ValueError(
+ f"Unknown quantization type, got {quant_method} - supported types are:"
+ f" {list(AUTO_QUANTIZER_MAPPING.keys())}"
+ )
+
+ target_cls = AUTO_QUANTIZER_MAPPING[quant_method]
+ return target_cls(quantization_config, **kwargs)
+
+ @classmethod
+ def from_pretrained(cls, pretrained_model_name_or_path, **kwargs):
+ quantization_config = AutoQuantizationConfig.from_pretrained(pretrained_model_name_or_path, **kwargs)
+ return cls.from_config(quantization_config)
+
+ @classmethod
+ def merge_quantization_configs(
+ cls,
+ quantization_config: dict | QuantizationConfigMixin,
+ quantization_config_from_args: QuantizationConfigMixin | None,
+ ):
+ """
+ handles situations where both quantization_config from args and quantization_config from model config are present.
+ """
+ if quantization_config_from_args is not None:
+ warning_msg = (
+ "You passed `quantization_config` or equivalent parameters to `from_pretrained` but the model you're loading"
+ " already has a `quantization_config` attribute. The `quantization_config` from the model will be used."
+ )
+ else:
+ warning_msg = ""
+
+ if isinstance(quantization_config, dict):
+ # Convert the config based on the type of quantization_config_from_args (e.g., AutoRoundConfig), which takes priority before automatic configuration dispatch.
+ if isinstance(quantization_config_from_args, AutoRoundConfig):
+ quantization_config = AutoRoundConfig.from_dict(quantization_config)
+ else:
+ quantization_config = AutoQuantizationConfig.from_dict(quantization_config)
+
+ if (
+ quantization_config_from_args is not None
+ and quantization_config.__class__.__name__ != quantization_config_from_args.__class__.__name__
+ ):
+ raise ValueError(
+ f"The model is quantized with {quantization_config.__class__.__name__} but you are passing a {quantization_config_from_args.__class__.__name__} config. "
+ "Please make sure to pass the same quantization config class to `from_pretrained` with different loading attributes."
+ )
+
+ if isinstance(quantization_config, LOADING_ATTRIBUTES_CONFIG_TYPES) and isinstance(
+ quantization_config_from_args, LOADING_ATTRIBUTES_CONFIG_TYPES
+ ):
+ loading_attr_dict = quantization_config_from_args.get_loading_attributes()
+ for attr, val in loading_attr_dict.items():
+ setattr(quantization_config, attr, val)
+
+ if loading_attr_dict:
+ warning_msg += f"However, loading attributes (e.g. {list(loading_attr_dict.keys())}) will be overwritten with the one you passed to `from_pretrained`. The rest will be ignored."
+
+ if warning_msg != "" and not isinstance(quantization_config, (Mxfp4Config, MetalConfig, FineGrainedFP8Config)):
+ warnings.warn(warning_msg)
+ else:
+ # in the case of mxfp4, we don't want to print the warning message, bit confusing for users
+ logger.info(warning_msg)
+ return quantization_config
+
+ @staticmethod
+ def supports_quant_method(quantization_config_dict):
+ quant_method = quantization_config_dict.get("quant_method", None)
+ if quantization_config_dict.get("load_in_8bit", False) or quantization_config_dict.get("load_in_4bit", False):
+ suffix = "_4bit" if quantization_config_dict.get("load_in_4bit", False) else "_8bit"
+ quant_method = QuantizationMethod.BITS_AND_BYTES + suffix
+ elif quant_method is None:
+ raise ValueError(
+ "The model's quantization config from the arguments has no `quant_method` attribute. Make sure that the model has been correctly quantized"
+ )
+
+ if quant_method not in AUTO_QUANTIZATION_CONFIG_MAPPING:
+ logger.warning(
+ f"Unknown quantization type, got {quant_method} - supported types are:"
+ f" {list(AUTO_QUANTIZER_MAPPING.keys())}. Hence, we will skip the quantization. "
+ "To remove the warning, you can delete the quantization_config attribute in config.json"
+ )
+ return False
+ return True
+
+
+def register_quantization_config(method: str):
+ """Register a custom quantization configuration."""
+
+ def register_config_fn(cls):
+ if method in AUTO_QUANTIZATION_CONFIG_MAPPING:
+ raise ValueError(f"Config '{method}' already registered")
+
+ if not issubclass(cls, QuantizationConfigMixin):
+ raise TypeError("Config must extend QuantizationConfigMixin")
+
+ AUTO_QUANTIZATION_CONFIG_MAPPING[method] = cls
+ return cls
+
+ return register_config_fn
+
+
+def register_quantizer(name: str):
+ """Register a custom quantizer."""
+
+ def register_quantizer_fn(cls):
+ if name in AUTO_QUANTIZER_MAPPING:
+ raise ValueError(f"Quantizer '{name}' already registered")
+
+ if not issubclass(cls, HfQuantizer):
+ raise TypeError("Quantizer must extend HfQuantizer")
+
+ AUTO_QUANTIZER_MAPPING[name] = cls
+ return cls
+
+ return register_quantizer_fn
+
+
+def get_hf_quantizer(config, quantization_config, device_map, weights_only, user_agent):
+ pre_quantized = hasattr(config, "quantization_config")
+ if pre_quantized and not AutoHfQuantizer.supports_quant_method(config.quantization_config):
+ pre_quantized = False
+
+ if pre_quantized or quantization_config is not None:
+ if pre_quantized:
+ config.quantization_config = AutoHfQuantizer.merge_quantization_configs(
+ config.quantization_config, quantization_config
+ )
+ else:
+ config.quantization_config = quantization_config
+
+ hf_quantizer = AutoHfQuantizer.from_config(
+ config.quantization_config,
+ pre_quantized=pre_quantized,
+ )
+ else:
+ hf_quantizer = None
+
+ if hf_quantizer is not None:
+ hf_quantizer.validate_environment(
+ device_map=device_map,
+ weights_only=weights_only,
+ )
+ device_map = hf_quantizer.update_device_map(device_map)
+ config = hf_quantizer.update_tp_plan(config)
+ config = hf_quantizer.update_ep_plan(config)
+
+ # In order to ensure popular quantization methods are supported. Can be disable with `disable_telemetry`
+ if not getattr(hf_quantizer.quantization_config, "dequantize", False):
+ quant_method = hf_quantizer.quantization_config.quant_method
+ user_agent["quant"] = getattr(quant_method, "value", quant_method)
+ return hf_quantizer, config, device_map
diff --git a/lib/python3.11/site-packages/transformers/quantizers/base.py b/lib/python3.11/site-packages/transformers/quantizers/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbebea2977bebfbcdea00fa2fd74e4cb0d689f16
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/base.py
@@ -0,0 +1,342 @@
+# Copyright 2024 The HuggingFace Inc. 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 abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+from ..utils import is_torch_available, logging
+from ..utils.quantization_config import QuantizationConfigMixin, QuantizationMethod
+from .quantizers_utils import get_module_from_name
+
+
+if TYPE_CHECKING:
+ from torch.nn import ModuleList
+
+ from ..modeling_utils import PreTrainedModel
+
+if is_torch_available():
+ import torch
+
+ if not TYPE_CHECKING:
+ from torch.nn import ModuleList
+else:
+ ModuleList = str
+
+logger = logging.get_logger(__file__)
+
+
+def get_keys_to_not_convert(model) -> list:
+ r"""
+ Function to automatically detect keys to not convert for usage like quantization. For example for CausalLM modules
+ we may want to keep the lm_head in full precision for numerical stability reasons.
+ """
+ # remove tied weights
+ tied_keys = set()
+ if len(model.all_tied_weights_keys) > 0:
+ tied_keys = set(model.all_tied_weights_keys.values()) | set(model.all_tied_weights_keys.keys())
+
+ # remove last module
+ last_module_key = {list(model.named_parameters())[-1][0]}
+
+ # remove output emb
+ output_emb_module = model.get_output_embeddings()
+ output_emb_keys = {
+ name
+ for name, module in model.named_modules()
+ if output_emb_module is not None and id(module) == id(output_emb_module)
+ }
+ modules_to_not_convert = tied_keys | last_module_key | output_emb_keys
+
+ modules_to_not_convert = list({k.removesuffix(".weight") for k in modules_to_not_convert})
+
+ return list(modules_to_not_convert)
+
+
+def _assign_is_quantized(model):
+ from ..modeling_utils import PreTrainedModel
+
+ for module in model.modules():
+ if isinstance(module, PreTrainedModel):
+ module.config._is_quantized = True
+
+
+class HfQuantizer(ABC):
+ """
+ Abstract class of the HuggingFace quantizer. Supports for now quantizing HF transformers models for inference and/or quantization.
+ This class is used only for transformers.PreTrainedModel.from_pretrained and cannot be easily used outside the scope of that method
+ yet.
+
+ Attributes
+ quantization_config (`transformers.utils.quantization_config.QuantizationConfigMixin`):
+ The quantization config that defines the quantization parameters of your model that you want to quantize.
+ requires_calibration (`bool`):
+ Whether the quantization method requires to calibrate the model before using it.
+ """
+
+ requires_calibration = False
+
+ def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
+ self.quantization_config = quantization_config
+ self.pre_quantized = kwargs.pop("pre_quantized", True)
+
+ if not self.pre_quantized and self.requires_calibration:
+ raise ValueError(
+ f"The quantization method {quantization_config.quant_method} does require the model to be pre-quantized."
+ f" You explicitly passed `pre_quantized=False` meaning your model weights are not quantized. Make sure to "
+ f"pass `pre_quantized=True` while knowing what you are doing."
+ )
+
+ def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
+ """
+ Some quantization methods require to explicitly set the dtype of the model to a
+ target dtype. You need to override this method in case you want to make sure that behavior is
+ preserved
+
+ Args:
+ dtype (`torch.dtype`):
+ The input dtype that is passed in `from_pretrained`
+ """
+ return dtype
+
+ def update_device_map(self, device_map: dict[str, Any] | None) -> dict[str, Any] | None:
+ """
+ Override this method if you want to pass a override the existing device map with a new
+ one. E.g. for bitsandbytes, since `accelerate` is a hard requirement, if no device_map is
+ passed, the device_map is set to `"auto"``
+
+ Args:
+ device_map (`Union[dict, str]`, *optional*):
+ The device_map that is passed through the `from_pretrained` method.
+ """
+ return device_map
+
+ def param_element_size(self, model: "PreTrainedModel", param_name: str, param: "torch.Tensor") -> float:
+ return param.element_size()
+
+ def adjust_max_memory(self, max_memory: dict[str, int | str]) -> dict[str, int | str]:
+ """adjust max_memory argument for infer_auto_device_map() if extra memory is needed for quantization"""
+ return max_memory
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ """
+ Check whether a given param needs to be quantized.
+ """
+ return False
+
+ def validate_environment(self, *args, **kwargs):
+ """
+ This method is used to potentially check for potential conflicts with arguments that are
+ passed in `from_pretrained`. You need to define it for all future quantizers that are integrated with transformers.
+ If no explicit check are needed, simply return nothing.
+ """
+ return
+
+ def update_tp_plan(self, config):
+ "updates the tp plan for the scales"
+ return config
+
+ def update_ep_plan(self, config):
+ "updates the tp plan for the scales"
+ return config
+
+ def _process_model_before_weight_loading(self, model, **kwargs):
+ return model
+
+ def preprocess_model(self, model: "PreTrainedModel", dtype=None, **kwargs):
+ """
+ Setting model attributes and/or converting model before weights loading. At this point
+ the model should be initialized on the meta device so you can freely manipulate the skeleton
+ of the model in order to replace modules in-place. Make sure to override the abstract method `_process_model_before_weight_loading`.
+
+ Args:
+ model (`~transformers.PreTrainedModel`):
+ The model to quantize
+ kwargs (`dict`, *optional*):
+ The keyword arguments that are passed along `_process_model_before_weight_loading`.
+ """
+ setattr(model, "is_quantized", True)
+ setattr(model, "quantization_method", self.quantization_config.quant_method)
+ if self.pre_quantized:
+ self._convert_model_for_quantization(model)
+ self._process_model_before_weight_loading(model, **kwargs)
+
+ def _process_model_after_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ return model
+
+ def postprocess_model(self, model: "PreTrainedModel", **kwargs):
+ """
+ Post-process the model post weights loading.
+ Make sure to override the abstract method `_process_model_after_weight_loading`.
+
+ Args:
+ model (`~transformers.PreTrainedModel`):
+ The model to quantize
+ kwargs (`dict`, *optional*):
+ The keyword arguments that are passed along `_process_model_after_weight_loading`.
+ """
+ model.config.quantization_config = self.quantization_config
+
+ if self.pre_quantized and getattr(self.quantization_config, "dequantize", False):
+ self.remove_quantization_config(model)
+ else:
+ _assign_is_quantized(model)
+
+ return self._process_model_after_weight_loading(model, **kwargs)
+
+ def remove_quantization_config(self, model):
+ """
+ Remove the quantization config from the model.
+ """
+ if hasattr(model, "hf_quantizer"):
+ del model.hf_quantizer
+ if hasattr(model.config, "quantization_config"):
+ del model.config.quantization_config
+ if hasattr(model, "quantization_method"):
+ del model.quantization_method
+ model.is_quantized = False
+
+ def dequantize(self, model, dtype=None):
+ """
+ Potentially dequantize the model to retrieve the original model, with some loss in accuracy / performance.
+ Note not all quantization schemes support this.
+ """
+ if dtype is None:
+ # using the same dtype we used to load the model. If we don't do that, we might have issues with modules we didn't quantize.
+ # or we need to upcast everything to the same dtype
+ dtype = model.config.dtype
+ model = self._dequantize(model, dtype=dtype)
+ self.remove_quantization_config(model)
+
+ return model
+
+ def _dequantize(self, model, dtype=None):
+ raise NotImplementedError(
+ f"{self.quantization_config.quant_method} has no implementation of `dequantize`, please raise an issue on GitHub."
+ )
+
+ def get_param_name(self, param_name: str) -> str:
+ """
+ Override this method if you want to adjust the `param_name`.
+ """
+ return param_name
+
+ @staticmethod
+ def get_modules_to_not_convert(
+ model: "PreTrainedModel",
+ skip_modules: list[str] | None = None,
+ keep_in_fp32_modules: list[str] | None = None,
+ add_default_skips: bool = False,
+ ):
+ if skip_modules is None or add_default_skips:
+ modules_to_not_convert = get_keys_to_not_convert(model)
+ else:
+ modules_to_not_convert = []
+
+ if skip_modules is not None:
+ modules_to_not_convert.extend(skip_modules)
+
+ if keep_in_fp32_modules is not None:
+ modules_to_not_convert.extend(keep_in_fp32_modules)
+
+ modules_to_not_convert = list(set(modules_to_not_convert))
+
+ return modules_to_not_convert
+
+ @property
+ def is_qat_trainable(self) -> bool:
+ """Flag indicating whether the quantized model can carry out quantization aware training"""
+ return False
+
+ @property
+ def is_compileable(self) -> bool:
+ """Flag indicating whether the quantized model can be compiled"""
+ return False
+
+ def get_state_dict_and_metadata(self, model):
+ """Get state dict and metadata. Useful when we need to modify a bit the state dict due to quantization"""
+ return None, {}
+
+ @abstractmethod
+ def is_serializable(self): ...
+
+ @property
+ @abstractmethod
+ def is_trainable(self): ...
+
+ def _convert_model_for_quantization(self, model):
+ for name, module in model.named_modules():
+ module_class_name = module.__class__.__name__
+ if module_class_name in MODULES_TO_PATCH_FOR_QUANTIZATION and (
+ self.quantization_config.quant_method
+ in MODULES_TO_PATCH_FOR_QUANTIZATION[module_class_name]["quantization_methods"]
+ ):
+ with torch.device("meta"):
+ parent_module, name = get_module_from_name(model, name)
+ parent_module._modules[name] = MODULES_TO_PATCH_FOR_QUANTIZATION[module_class_name]["module_name"](
+ model.config.get_text_config()
+ )
+
+ def get_quantize_ops(self):
+ raise NotImplementedError(
+ f"{self.quantization_config.quant_method} is not available yet and will be supported soon."
+ )
+
+ def get_weight_conversions(self):
+ return []
+
+ def update_weight_conversions(self, weight_conversions):
+ """Give the quantizer a chance to rewrite the weight conversion pipeline.
+
+ Loading runs ``renamings → converters → (dequant → merge → concat)``. Dequant
+ has to happen *before* any merge/concat op because those operations aren't
+ aware of per-block scales, so the per-expert (weight, scale) pairs need to be
+ collapsed into full-precision tensors first. Subclasses (e.g. the FP8
+ quantizer in ``dequantize=True`` mode) override this to inject a dequantize
+ op at the start of each model-provided :class:`WeightConverter` and attach the
+ matching scale source patterns. Default: no-op.
+ """
+ return weight_conversions + self.get_weight_conversions()
+
+
+class SequentialLlama4TextExperts(ModuleList):
+ """
+ A module that implements a compressed version of a list of expert modules.
+ This is specifically designed to work with Llama4TextExperts in MoE layers.
+ """
+
+ def __init__(self, config):
+ from transformers.models.llama4.modeling_llama4 import Llama4TextMLP
+
+ super().__init__([Llama4TextMLP(config) for _ in range(config.num_local_experts)])
+ self.num_experts = config.num_local_experts
+
+ def forward(
+ self,
+ hidden_states: "torch.Tensor",
+ ) -> "torch.Tensor":
+ hidden_states = hidden_states.reshape(self.num_experts, -1, hidden_states.shape[-1])
+ routed_out = torch.zeros_like(hidden_states)
+ for expert_idx in range(self.num_experts):
+ routed_out[expert_idx] = self[expert_idx](hidden_states[expert_idx])
+ return routed_out
+
+
+MODULES_TO_PATCH_FOR_QUANTIZATION = {
+ "Llama4TextExperts": {
+ "module_name": SequentialLlama4TextExperts,
+ "quantization_methods": [
+ QuantizationMethod.COMPRESSED_TENSORS,
+ QuantizationMethod.BITS_AND_BYTES,
+ ],
+ }
+}
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_aqlm.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_aqlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d0fd7939d88ad4a417b5f92772f04de7f4fbc95
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_aqlm.py
@@ -0,0 +1,75 @@
+# Copyright 2024 The HuggingFace Inc. 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 importlib import metadata
+from typing import TYPE_CHECKING
+
+from packaging import version
+
+from .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import AqlmConfig
+
+from ..integrations import replace_with_aqlm_linear
+from ..utils import is_accelerate_available, is_aqlm_available, logging
+from ..utils.quantization_config import QuantizationConfigMixin
+
+
+logger = logging.get_logger(__name__)
+
+
+class AqlmHfQuantizer(HfQuantizer):
+ """
+ Quantizer of the AQLM method. Enables the loading of prequantized models.
+ """
+
+ requires_calibration = True
+ quantization_config: "AqlmConfig"
+
+ def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_accelerate_available():
+ raise ImportError("Using `aqlm` quantization requires Accelerate: `pip install accelerate`")
+
+ if not is_aqlm_available():
+ raise ImportError("Using `aqlm` quantization requires AQLM: `pip install aqlm[gpu,cpu]`")
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ replace_with_aqlm_linear(
+ model,
+ modules_to_not_convert=self.quantization_config.linear_weights_not_to_quantize,
+ quantization_config=self.quantization_config,
+ )
+
+ @property
+ def is_trainable(self) -> bool:
+ aqlm_supports_training = version.parse(metadata.version("aqlm")) >= version.parse("1.0.2")
+ if aqlm_supports_training:
+ return True
+ else:
+ logger.warning(
+ f"Currently installed `aqlm` version ({metadata.version('aqlm')}) doesn't support training. If you wish to train a quantized model, please update `aqlm` with `pip install aqlm>=1.0.2`"
+ )
+ return False
+
+ def is_serializable(self):
+ return True
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_auto_round.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_auto_round.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a52314013066b21fb90ed5646e101ec7d67cd09
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_auto_round.py
@@ -0,0 +1,71 @@
+# Copyright 2024 The HuggingFace Inc. 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 .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+
+from ..utils import is_auto_round_available, logging
+from ..utils.quantization_config import QuantizationConfigMixin
+
+
+logger = logging.get_logger(__name__)
+
+
+class AutoRoundQuantizer(HfQuantizer):
+ """
+ Quantizer of the AutoRound method. (https://huggingface.co/papers/2309.05516)
+ """
+
+ # AutoRound requires data calibration - we support only inference
+ requires_calibration = True
+
+ def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ self.device_map = kwargs.get("device_map")
+ if not is_auto_round_available():
+ raise ImportError(
+ "Loading an AutoRound quantized model requires auto-round library (`pip install 'auto-round>=0.5'`)"
+ )
+
+ def _process_model_before_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ if model.__class__.main_input_name != "input_ids":
+ logger.warning("AutoRound offers only limited support for models that are not strictly text-based.")
+ from auto_round.inference.convert_model import convert_hf_model, infer_target_device
+
+ if self.pre_quantized:
+ target_device = infer_target_device(self.device_map)
+ model, used_backends = convert_hf_model(model, target_device)
+ self.used_backends = used_backends
+
+ def _process_model_after_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ if self.pre_quantized:
+ from auto_round.inference.convert_model import post_init
+
+ post_init(model, self.used_backends)
+ else:
+ raise ValueError("AutoRound only sports pre-quantized models.")
+
+ @property
+ def is_trainable(self) -> bool:
+ return False
+
+ def is_serializable(self):
+ ## for gptq/awq models, the quantization config will be changed
+ return True
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_awq.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_awq.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a574ef13f8ff88cb033f650cbb71ee087644cb5
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_awq.py
@@ -0,0 +1,97 @@
+# Copyright 2024 The HuggingFace Inc. 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 importlib.metadata
+from typing import TYPE_CHECKING
+
+from packaging import version
+
+from .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import AwqConfig
+
+from ..utils import is_accelerate_available, is_gptqmodel_available, is_torch_available, logging
+from ..utils.quantization_config import AwqBackend
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+class AwqQuantizer(HfQuantizer):
+ """
+ 4-bit quantization for Activation-aware Weight Quantization(AWQ) (https://huggingface.co/papers/2306.00978)
+ """
+
+ # AWQ requires data calibration - we support only inference
+ requires_calibration = True
+ quantization_config: "AwqConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, **kwargs):
+ if not is_gptqmodel_available():
+ raise ImportError(
+ "Loading an AWQ quantized model requires gptqmodel. Please install it with `pip install gptqmodel`"
+ )
+
+ if not is_accelerate_available():
+ raise ImportError("Loading an AWQ quantized model requires accelerate (`pip install accelerate`)")
+
+ def update_dtype(self, dtype):
+ if dtype == torch.bfloat16 and (torch.cuda.is_available() or torch.xpu.is_available()):
+ logger.warning(
+ "`torch.bfloat16` is not supported for AWQ CUDA/XPU kernels yet. Casting to `torch.float16`."
+ )
+ dtype = torch.float16
+ elif dtype != torch.float16 and (torch.cuda.is_available() or torch.xpu.is_available()):
+ logger.warning("We suggest you to set `dtype=torch.float16` for better efficiency on CUDA/XPU with AWQ.")
+ return dtype
+
+ def _process_model_before_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ from ..integrations import replace_quantization_scales, replace_with_awq_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules, add_default_skips=True
+ )
+
+ model = replace_with_awq_linear(
+ model,
+ quantization_config=self.quantization_config,
+ modules_to_not_convert=self.modules_to_not_convert,
+ device_map=kwargs.get("device_map"),
+ )
+
+ model = replace_quantization_scales(model, model.config.model_type)
+
+ def _process_model_after_weight_loading(self, model, **kwargs):
+ from gptqmodel.utils.model import hf_gptqmodel_post_init
+
+ hf_gptqmodel_post_init(model, use_act_order=self.quantization_config.desc_act)
+
+ def is_serializable(self):
+ if self.quantization_config.backend in [AwqBackend.EXLLAMA_V1, AwqBackend.EXLLAMA_V2]:
+ logger.warning("You cannot save an AWQ model that uses Exllama backend!")
+ return False
+
+ return True
+
+ @property
+ def is_trainable(self):
+ return version.parse(importlib.metadata.version("gptqmodel")) >= version.parse("5.0.0")
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_bitnet.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_bitnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec22976939eefcec251ad171f5c7a12331ff8e3e
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_bitnet.py
@@ -0,0 +1,124 @@
+# Copyright 2024 The HuggingFace Inc. 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 .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import BitNetQuantConfig
+
+from ..utils import is_accelerate_available, is_torch_available, logging
+
+
+if is_torch_available():
+ import torch
+
+
+logger = logging.get_logger(__name__)
+
+
+class BitNetHfQuantizer(HfQuantizer):
+ """
+ 1.58-bit quantization from BitNet quantization method:
+ Before loading: it converts the linear layers into BitLinear layers during loading.
+
+ Check out the paper introducing this method: https://huggingface.co/papers/2402.17764
+ """
+
+ requires_calibration = True
+ quantization_config: "BitNetQuantConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_accelerate_available():
+ raise ImportError("Loading a BitNet quantized model requires accelerate (`pip install accelerate`)")
+
+ if not torch.cuda.is_available():
+ logger.warning_once(
+ "You don't have a GPU available to load the model, the inference will be slow because of weight unpacking"
+ )
+ return
+
+ device_map = kwargs.get("device_map")
+ if device_map is None:
+ logger.warning_once(
+ "You have loaded a BitNet model on CPU and have a CUDA device available, make sure to set "
+ "your model on a GPU device in order to run your model."
+ )
+ elif isinstance(device_map, dict):
+ if len(device_map) > 1 and "cpu" in device_map.values() or "disk" in device_map.values():
+ raise ValueError(
+ "You are attempting to load a BitNet model with a device_map that contains a CPU or disk device."
+ "This is not supported. Please remove the CPU or disk device from the device_map."
+ )
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ from ..integrations import replace_with_bitnet_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+
+ model = replace_with_bitnet_linear(
+ model,
+ modules_to_not_convert=self.modules_to_not_convert,
+ quantization_config=self.quantization_config,
+ )
+
+ def adjust_max_memory(self, max_memory: dict[str, int | str]) -> dict[str, int | str]:
+ max_memory = {key: val * 0.90 for key, val in max_memory.items()}
+ return max_memory
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return (
+ self.quantization_config.linear_class == "autobitlinear"
+ and self.quantization_config.quantization_mode == "online"
+ )
+
+ @property
+ def is_qat_trainable(self) -> bool:
+ """Flag indicating whether the quantized model can carry out quantization aware training"""
+ return (
+ self.quantization_config.linear_class == "autobitlinear"
+ and self.quantization_config.quantization_mode == "online"
+ )
+
+ def get_weight_conversions(self):
+ from ..core_model_loading import WeightConverter
+ from ..integrations.bitnet import BitNetDeserialize
+
+ if (
+ self.quantization_config.linear_class == "autobitlinear"
+ and self.quantization_config.quantization_mode == "offline"
+ ):
+ return [
+ WeightConverter(
+ source_patterns=["weight"],
+ target_patterns=["weight"],
+ operations=[BitNetDeserialize(self)],
+ )
+ ]
+ return []
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_bnb_4bit.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_bnb_4bit.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fd040bed10e9fce70473e667adb4513459163b4
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_bnb_4bit.py
@@ -0,0 +1,187 @@
+# Copyright 2024 The HuggingFace Inc. 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 .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import BitsAndBytesConfig
+
+from ..utils import (
+ ACCELERATE_MIN_VERSION,
+ BITSANDBYTES_MIN_VERSION,
+ is_accelerate_available,
+ is_bitsandbytes_available,
+ is_torch_available,
+ is_torch_hpu_available,
+ is_torch_npu_available,
+ is_torch_xpu_available,
+ logging,
+)
+
+
+if is_torch_available():
+ import torch
+
+ from ..core_model_loading import WeightConverter
+
+logger = logging.get_logger(__name__)
+
+
+class Bnb4BitHfQuantizer(HfQuantizer):
+ """
+ 4-bit quantization from bitsandbytes quantization method
+ """
+
+ requires_calibration = False
+ quantization_config: "BitsAndBytesConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_accelerate_available():
+ raise ImportError(
+ f"Using `bitsandbytes` 4-bit quantization requires accelerate: `pip install 'accelerate>={ACCELERATE_MIN_VERSION}'`"
+ )
+ if not is_bitsandbytes_available():
+ raise ImportError(
+ f"Using `bitsandbytes` 4-bit quantization requires bitsandbytes: `pip install -U bitsandbytes>={BITSANDBYTES_MIN_VERSION}`"
+ )
+
+ from ..integrations import validate_bnb_backend_availability
+
+ validate_bnb_backend_availability(raise_exception=True)
+
+ device_map = kwargs.get("device_map")
+ if not self.quantization_config.llm_int8_enable_fp32_cpu_offload and isinstance(device_map, dict):
+ values = set(device_map.values())
+ if values != {"cpu"} and ("cpu" in values or "disk" in values):
+ raise ValueError(
+ "Some modules are dispatched on the CPU or the disk. Make sure you have enough GPU RAM to fit the "
+ "quantized model. If you want to dispatch the model on the CPU or the disk while keeping these modules "
+ "in 32-bit, you need to set `llm_int8_enable_fp32_cpu_offload=True` and pass a custom `device_map` to "
+ "`from_pretrained`. Check "
+ "https://huggingface.co/docs/transformers/main/en/main_classes/quantization#offload-between-cpu-and-gpu "
+ "for more details. "
+ )
+
+ def param_element_size(self, model: "PreTrainedModel", param_name: str, param: "torch.Tensor") -> float:
+ "Return the element size (in bytes) for `param_name`."
+ if self.param_needs_quantization(model, param_name):
+ # 4 bit
+ return 0.5
+
+ return super().param_element_size(model, param_name, param)
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ import bitsandbytes as bnb
+
+ module, name = get_module_from_name(model, param_name)
+ return isinstance(module, bnb.nn.Linear4bit) and name != "bias"
+
+ def adjust_max_memory(self, max_memory: dict[str, int | str]) -> dict[str, int | str]:
+ # need more space for buffers that are created during quantization
+ max_memory = {key: val * 0.90 for key, val in max_memory.items()}
+ return max_memory
+
+ def update_device_map(self, device_map):
+ if device_map is None:
+ if torch.cuda.is_available():
+ device_map = {"": torch.cuda.current_device()}
+ elif is_torch_npu_available() and hasattr(torch, "npu"):
+ device_map = {"": f"npu:{torch.npu.current_device()}"}
+ elif is_torch_hpu_available() and hasattr(torch, "hpu"):
+ device_map = {"": f"hpu:{torch.hpu.current_device()}"}
+ elif is_torch_xpu_available():
+ device_map = {"": torch.xpu.current_device()}
+ else:
+ device_map = {"": "cpu"}
+ logger.info(
+ "The device_map was not initialized. "
+ f"Setting device_map to {device_map}. "
+ "If you want to use the model for inference, please set device_map ='auto' "
+ )
+ return device_map
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ device_map,
+ **kwargs,
+ ):
+ from ..integrations import replace_with_bnb_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.llm_int8_skip_modules, model._keep_in_fp32_modules
+ )
+
+ if self.quantization_config.llm_int8_enable_fp32_cpu_offload:
+ if isinstance(device_map, dict):
+ keys_on_cpu = [key for key, value in device_map.items() if value in ["disk", "cpu"]]
+ self.modules_to_not_convert.extend(keys_on_cpu)
+
+ model = replace_with_bnb_linear(
+ model,
+ modules_to_not_convert=self.modules_to_not_convert,
+ quantization_config=self.quantization_config,
+ pre_quantized=self.pre_quantized,
+ )
+
+ def _process_model_after_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ setattr(model, "is_loaded_in_4bit", True)
+ setattr(model, "is_4bit_serializable", self.is_serializable())
+ return model
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return True
+
+ def _dequantize(self, model, dtype=None):
+ from ..integrations import dequantize_and_replace
+
+ model = dequantize_and_replace(model, quantization_config=self.quantization_config, dtype=dtype)
+ return model
+
+ def get_quantize_ops(self):
+ from ..integrations.bitsandbytes import Bnb4bitQuantize
+
+ return Bnb4bitQuantize(self)
+
+ def get_weight_conversions(self):
+ from ..integrations.bitsandbytes import Bnb4bitDeserialize
+
+ if self.pre_quantized:
+ return [
+ WeightConverter(
+ source_patterns=[
+ "weight.nested_absmax",
+ "weight.nested_quant_map",
+ "weight.quant_map",
+ "weight.absmax",
+ "weight.quant_state.bitsandbytes__nf4",
+ "weight.quant_state.bitsandbytes__fp4",
+ "weight",
+ ],
+ target_patterns="weight",
+ operations=[Bnb4bitDeserialize(self)],
+ )
+ ]
+ return []
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_bnb_8bit.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_bnb_8bit.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf3192bcd72a48a9e0d27cec1baaec19236f0a85
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_bnb_8bit.py
@@ -0,0 +1,178 @@
+# Copyright 2024 The HuggingFace Inc. 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 .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import BitsAndBytesConfig
+
+from ..utils import (
+ ACCELERATE_MIN_VERSION,
+ BITSANDBYTES_MIN_VERSION,
+ is_accelerate_available,
+ is_bitsandbytes_available,
+ is_torch_available,
+ is_torch_hpu_available,
+ is_torch_npu_available,
+ is_torch_xpu_available,
+ logging,
+)
+from .quantizers_utils import get_module_from_name
+
+
+if is_torch_available():
+ import torch
+
+ from ..core_model_loading import WeightConverter
+
+logger = logging.get_logger(__name__)
+
+
+class Bnb8BitHfQuantizer(HfQuantizer):
+ """
+ 8-bit quantization from bitsandbytes quantization method
+ """
+
+ requires_calibration = False
+ quantization_config: "BitsAndBytesConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_accelerate_available():
+ raise ImportError(
+ f"Using `bitsandbytes` 8-bit quantization requires accelerate: `pip install 'accelerate>={ACCELERATE_MIN_VERSION}'`"
+ )
+ if not is_bitsandbytes_available():
+ raise ImportError(
+ f"Using `bitsandbytes` 8-bit quantization requires bitsandbytes: `pip install -U bitsandbytes>={BITSANDBYTES_MIN_VERSION}`"
+ )
+
+ from ..integrations import validate_bnb_backend_availability
+
+ validate_bnb_backend_availability(raise_exception=True)
+
+ device_map = kwargs.get("device_map")
+ if not self.quantization_config.llm_int8_enable_fp32_cpu_offload and isinstance(device_map, dict):
+ values = set(device_map.values())
+ if values != {"cpu"} and ("cpu" in values or "disk" in values):
+ raise ValueError(
+ "Some modules are dispatched on the CPU or the disk. Make sure you have enough GPU RAM to fit the "
+ "quantized model. If you want to dispatch the model on the CPU or the disk while keeping these modules "
+ "in 32-bit, you need to set `llm_int8_enable_fp32_cpu_offload=True` and pass a custom `device_map` to "
+ "`from_pretrained`. Check "
+ "https://huggingface.co/docs/transformers/main/en/main_classes/quantization#offload-between-cpu-and-gpu "
+ "for more details. "
+ )
+
+ def adjust_max_memory(self, max_memory: dict[str, int | str]) -> dict[str, int | str]:
+ # need more space for buffers that are created during quantization
+ max_memory = {key: val * 0.90 for key, val in max_memory.items()}
+ return max_memory
+
+ def update_device_map(self, device_map):
+ if device_map is None:
+ if torch.cuda.is_available():
+ device_map = {"": torch.cuda.current_device()}
+ elif is_torch_npu_available() and hasattr(torch, "npu"):
+ device_map = {"": f"npu:{torch.npu.current_device()}"}
+ elif is_torch_hpu_available() and hasattr(torch, "hpu"):
+ device_map = {"": f"hpu:{torch.hpu.current_device()}"}
+ elif is_torch_xpu_available():
+ device_map = {"": torch.xpu.current_device()}
+ else:
+ device_map = {"": "cpu"}
+ logger.info(
+ "The device_map was not initialized. "
+ f"Setting device_map to {device_map}. "
+ "If you want to use the model for inference, please set device_map ='auto' "
+ )
+ return device_map
+
+ def param_element_size(self, model: "PreTrainedModel", param_name: str, param: "torch.Tensor") -> float:
+ "Return the element size (in bytes) for `param_name`."
+ if self.param_needs_quantization(model, param_name):
+ # 8-bit
+ return 1
+ return super().param_element_size(model, param_name, param)
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ import bitsandbytes as bnb
+
+ module, name = get_module_from_name(model, param_name)
+ return isinstance(module, bnb.nn.Linear8bitLt) and name != "bias"
+
+ def _process_model_after_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ setattr(model, "is_loaded_in_8bit", True)
+ model.is_8bit_serializable = self.is_serializable()
+ return model
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ device_map,
+ **kwargs,
+ ):
+ from ..integrations import replace_with_bnb_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.llm_int8_skip_modules, model._keep_in_fp32_modules
+ )
+
+ if self.quantization_config.llm_int8_enable_fp32_cpu_offload:
+ if isinstance(device_map, dict):
+ keys_on_cpu = [key for key, value in device_map.items() if value in ["disk", "cpu"]]
+ self.modules_to_not_convert.extend(keys_on_cpu)
+
+ model = replace_with_bnb_linear(
+ model,
+ modules_to_not_convert=self.modules_to_not_convert,
+ quantization_config=self.quantization_config,
+ pre_quantized=self.pre_quantized,
+ )
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return True
+
+ def _dequantize(self, model, dtype=None):
+ from ..integrations import dequantize_and_replace
+
+ model = dequantize_and_replace(model, quantization_config=self.quantization_config, dtype=dtype)
+ return model
+
+ def get_quantize_ops(self):
+ from ..integrations.bitsandbytes import Bnb8bitQuantize
+
+ return Bnb8bitQuantize(self)
+
+ def get_weight_conversions(self):
+ from ..integrations.bitsandbytes import Bnb8bitDeserialize
+
+ if self.pre_quantized:
+ return [
+ WeightConverter(
+ source_patterns=["SCB", "weight_format", "weight"],
+ target_patterns="weight",
+ operations=[Bnb8bitDeserialize(self)],
+ )
+ ]
+ return []
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_compressed_tensors.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_compressed_tensors.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e1e4882beea28467043e85813757f764d175a97
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_compressed_tensors.py
@@ -0,0 +1,114 @@
+# Copyright 2024 The HuggingFace Inc. 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 ..utils import is_compressed_tensors_available, is_torch_available, logging
+from ..utils.quantization_config import CompressedTensorsConfig
+from .base import HfQuantizer
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+class CompressedTensorsHfQuantizer(HfQuantizer):
+ """
+ Quantizer for the compressed_tensors package. Loads and restores models to
+ quantized state with compressed_tensors
+ """
+
+ requires_calibration = True
+ quantization_config: CompressedTensorsConfig
+
+ def __init__(self, quantization_config: CompressedTensorsConfig, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ if not is_compressed_tensors_available():
+ raise ImportError(
+ "Using `compressed_tensors` quantized models requires the compressed-tensors library: "
+ "`pip install compressed-tensors`"
+ )
+
+ # Call post_init here to ensure proper config setup when `run_compressed`
+ # is provided directly via CompressedTensorsConfig, and to avoid duplicate logging.
+
+ quantization_config.post_init()
+ from compressed_tensors.compressors import ModelCompressor
+
+ self.compressor = ModelCompressor.from_compression_config(quantization_config)
+ self.run_compressed = quantization_config.run_compressed
+ self.quantization_config = quantization_config
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_compressed_tensors_available():
+ raise ImportError(
+ "Using `compressed_tensors` quantized models requires the compressed-tensors library: "
+ "`pip install compressed-tensors`"
+ )
+
+ def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
+ if dtype != torch.float16:
+ logger.info("We suggest you to set `dtype=torch.float16` for better efficiency with compressed_tensors.")
+ return dtype
+
+ def _process_model_before_weight_loading(self, model, **kwargs):
+ from compressed_tensors.quantization import apply_quantization_config
+
+ ct_quantization_config = self.compressor.quantization_config
+
+ # Always initialize compressed wrappers to match the checkpoint
+ apply_quantization_config(model, ct_quantization_config, self.run_compressed)
+ if (
+ self.quantization_config.is_quantization_compressed
+ or self.quantization_config.is_sparsification_compressed
+ ):
+ self.compressor.compress_model(model=model)
+
+ def _process_model_after_weight_loading(self, model, **kwargs):
+ """Decompress loaded model if necessary - need for qat"""
+
+ if (self.quantization_config.is_quantization_compressed and not self.run_compressed) or (
+ self.quantization_config.is_sparsification_compressed
+ ):
+ self.compressor.decompress_model(model=model)
+
+ # NOTE: TP plan override for compressed tensors removed - unsupported styles were used.
+ # TODO: Implement proper TP support for compressed tensors quantization
+ def update_tp_plan(self, config):
+ additional_plan = {
+ "layers.*.feed_forward.experts.*.gate_proj.weight": "colwise",
+ "layers.*.feed_forward.experts.*.gate_proj.weight_scale": "colwise",
+ "layers.*.feed_forward.experts.*.up_proj.weight": "colwise",
+ "layers.*.feed_forward.experts.*.up_proj.weight_scale": "colwise",
+ "layers.*.feed_forward.experts.*.down_proj.weight": "rowwise",
+ }
+ if config.get_text_config() is not None and config.get_text_config().base_model_tp_plan is not None:
+ config.get_text_config().base_model_tp_plan.update(additional_plan)
+
+ return config
+
+ @property
+ def is_trainable(self):
+ return True
+
+ def is_qat_trainable(self) -> bool:
+ """Loaded Models can carry out quantization aware training"""
+ # models need to be decompressed carry out qat
+ return not self.run_compressed or not self.quantization_config.is_quantization_compressed
+
+ def is_serializable(self) -> bool:
+ """Models quantized using compressed tensors can be saved to disk"""
+ return True
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_eetq.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_eetq.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce1d350f3d96438663c6f065e94af95cc8d5fc57
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_eetq.py
@@ -0,0 +1,110 @@
+# Copyright 2024 The HuggingFace Inc. 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 .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import EetqConfig
+
+from ..utils import is_accelerate_available, is_kernels_available, is_torch_available, logging
+from .quantizers_utils import get_module_from_name
+
+
+if is_torch_available():
+ import torch
+
+
+logger = logging.get_logger(__name__)
+
+
+class EetqHfQuantizer(HfQuantizer):
+ """
+ 8-bit quantization from EETQ quantization method
+ """
+
+ requires_calibration = False
+ quantization_config: "EetqConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_kernels_available():
+ raise ImportError("Loading an EETQ quantized model requires kernels (`pip install kernels`)")
+
+ if not is_accelerate_available():
+ raise ImportError("Loading an EETQ quantized model requires accelerate (`pip install accelerate`)")
+
+ if not torch.cuda.is_available():
+ raise RuntimeError("No GPU found. A GPU is needed for quantization.")
+
+ device_map = kwargs.get("device_map")
+ if device_map is None:
+ logger.warning_once(
+ "You have loaded an EETQ model on CPU and have a CUDA device available, make sure to set "
+ "your model on a GPU device in order to run your model."
+ )
+ elif isinstance(device_map, dict):
+ if len(device_map) > 1 and "cpu" in device_map.values() or "disk" in device_map.values():
+ raise ValueError(
+ "You are attempting to load an EETQ model with a device_map that contains a CPU or disk device."
+ " This is not supported. Please remove the CPU or disk device from the device_map."
+ )
+
+ def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
+ if dtype != torch.float16:
+ logger.info("We suggest you to set `dtype=torch.float16` for better efficiency with EETQ.")
+ return dtype
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ from ..integrations.eetq import EetqLinear
+
+ module, tensor_name = get_module_from_name(model, param_name)
+
+ if isinstance(module, EetqLinear):
+ if self.pre_quantized or tensor_name == "bias":
+ return False
+ else:
+ return True
+ return False
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ from ..integrations import replace_with_eetq_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+
+ model = replace_with_eetq_linear(
+ model, modules_to_not_convert=self.modules_to_not_convert, pre_quantized=self.pre_quantized
+ )
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return True
+
+ def get_quantize_ops(self):
+ from ..integrations.eetq import EetqQuantize
+
+ return EetqQuantize(self)
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_fbgemm_fp8.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_fbgemm_fp8.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cbc3cdcbe5f2413af19c4819692ba97a9178d98
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_fbgemm_fp8.py
@@ -0,0 +1,207 @@
+# Copyright 2024 The HuggingFace Inc. 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 .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import FbgemmFp8Config
+
+from ..utils import (
+ is_accelerate_available,
+ is_fbgemm_gpu_available,
+ is_kernels_available,
+ is_torch_available,
+ is_torch_cuda_available,
+ is_torch_xpu_available,
+ logging,
+)
+from .quantizers_utils import get_module_from_name
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+class FbgemmFp8HfQuantizer(HfQuantizer):
+ """
+ FP8 quantization using fbgemm kernels
+ """
+
+ requires_calibration = False
+ quantization_config: "FbgemmFp8Config"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_torch_cuda_available() and not is_torch_xpu_available():
+ raise ImportError("Using fbgemm fp8 quantization requires a GPU or XPU")
+ if is_torch_xpu_available() and not is_kernels_available():
+ raise ImportError("Using FP8 fbgemm on XPU requires kernels (`pip install kernels`)")
+ if is_torch_cuda_available() and not is_fbgemm_gpu_available():
+ raise ImportError(
+ "Loading an FP8 fbgemm quantized model on CUDA requires fbgemm-gpu library"
+ "Please install the latest version of fbgemm-gpu library by following : https://pytorch.org/FBGEMM/fbgemm_gpu-development/InstallationInstructions.html#fbgemm-gpu-install-libraries"
+ )
+ if not is_accelerate_available():
+ raise ImportError(
+ "Loading an FP8 quantized model requires accelerate (`pip install --upgrade accelerate`)"
+ )
+ if is_torch_cuda_available():
+ compute_capability = torch.cuda.get_device_capability()
+ major, _ = compute_capability
+ if major < 9:
+ raise ValueError(
+ "FP8 quantized models is only supported on GPUs with compute capability >= 9.0 (e.g H100)"
+ )
+
+ device_map = kwargs.get("device_map")
+ if device_map is None:
+ logger.warning_once(
+ "You have loaded an FP8 model on CPU and have a CUDA/XPU device available, make sure to set "
+ "your model on a GPU/XPU device in order to run your model. To remove this warning, pass device_map = 'cuda' or 'xpu' or 'auto'. "
+ )
+ elif isinstance(device_map, dict):
+ if not self.pre_quantized and ("cpu" in device_map.values() or "disk" in device_map.values()):
+ raise ValueError(
+ "You are attempting to load an FP8 model with a device_map that contains a CPU or disk device."
+ "This is not supported when the model is quantized on the fly. "
+ "Please use a quantized checkpoint or remove the CPU or disk device from the device_map."
+ )
+
+ def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
+ if dtype != torch.bfloat16:
+ logger.warning_once(
+ f"Setting dtype to {dtype}, but only bfloat16 is supported right now. Overwriting torch_dtype to bfloat16."
+ )
+ dtype = torch.bfloat16
+ return dtype
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ from ..integrations import FbgemmFp8Linear, FbgemmFp8Llama4TextExperts
+
+ module, tensor_name = get_module_from_name(model, param_name)
+
+ if isinstance(module, FbgemmFp8Linear):
+ if self.pre_quantized or tensor_name == "bias":
+ return False
+ else:
+ return True
+ if isinstance(module, FbgemmFp8Llama4TextExperts):
+ if self.pre_quantized or tensor_name == "bias":
+ return False
+ else:
+ return True
+ return False
+
+ def param_element_size(self, model: "PreTrainedModel", param_name: str, param: "torch.Tensor") -> float:
+ "Return the element size (in bytes) for `param_name`."
+ if self.param_needs_quantization(model, param_name):
+ # 8 bit, this is neeed as when `pre_quantized`` is False, we don't set the dtype of the FP8Linear in order to correctly load the weights
+ return 1
+ return super().param_element_size(model, param_name, param)
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ from ..integrations import replace_with_fbgemm_fp8_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+
+ model = replace_with_fbgemm_fp8_linear(
+ model,
+ modules_to_not_convert=self.modules_to_not_convert,
+ quantization_config=self.quantization_config,
+ pre_quantized=self.pre_quantized,
+ tp_plan=model._tp_plan,
+ )
+
+ def _process_model_after_weight_loading(self, model, **kwargs):
+ """
+ Force update the input scale upper bound after weight loading and device dispatch are complete.
+ This resolves issues where persistent buffers are zeroed out or overwritten during the loading process.
+ """
+ from ..integrations.fbgemm_fp8 import FbgemmFp8Linear, FbgemmFp8Llama4TextExperts
+
+ for m in model.modules():
+ if isinstance(m, (FbgemmFp8Linear, FbgemmFp8Llama4TextExperts)):
+ if hasattr(m, "input_scale_ub"):
+ # The model is now on the target device, so we can use fill_ directly.
+ m.input_scale_ub.fill_(self.quantization_config.activation_scale_ub)
+ return model
+
+ def update_tp_plan(self, config):
+ if "Llama4" in config.__class__.__name__:
+ text_plan = {
+ # We are using a different tp plan with local_colwise and local_rowwise for the attention because fbgemm operations cannot be parallelized
+ # With local_colwise and local_rowwise, all the operations are done locally, and we add a gather operation to gather the results instead of
+ # using dtensors
+ "layers.*.self_attn.q_proj.weight": "colwise",
+ "layers.*.self_attn.q_proj.weight_scale": "colwise",
+ "layers.*.self_attn.k_proj.weight": "colwise",
+ "layers.*.self_attn.k_proj.weight_scale": "colwise",
+ "layers.*.self_attn.v_proj.weight": "colwise",
+ "layers.*.self_attn.v_proj.weight_scale": "colwise",
+ "layers.*.self_attn.o_proj.weight": "rowwise",
+ # We keep the same sequence_parallel plan for layernorms
+ "layers.*.input_layernorm.weight": "sequence_parallel",
+ "layers.*.post_attention_layernorm.weight": "sequence_parallel",
+ "norm.weight": "sequence_parallel",
+ # We keep the same local_colwise and local_rowwise plan for the feed forward shared expert
+ # We also add scales for the shared expert, for local_colwise the scale is also local_colwise
+ # For local_rowwise the scale is replicated, so we don't need to add it
+ "layers.*.feed_forward.shared_expert.gate_proj.weight": "colwise",
+ "layers.*.feed_forward.shared_expert.gate_proj.weight_scale": "colwise",
+ "layers.*.feed_forward.shared_expert.up_proj.weight": "colwise",
+ "layers.*.feed_forward.shared_expert.up_proj.weight_scale": "colwise",
+ "layers.*.feed_forward.shared_expert.down_proj.weight": "rowwise",
+ "layers.*.feed_forward.experts.*.gate_proj.weight": "colwise",
+ "layers.*.feed_forward.experts.*.gate_proj.weight_scale": "colwise",
+ "layers.*.feed_forward.experts.*.up_proj.weight": "colwise",
+ "layers.*.feed_forward.experts.*.up_proj.weight_scale": "colwise",
+ "layers.*.feed_forward.experts.*.down_proj.weight": "rowwise",
+ # For Fused implementation we use local_packed_rowwise for the gate_up_proj, and the same for the packed scales
+ # We use local_colwise for the down_proj, and the scales are replicated so we don't add them
+ "layers.*.feed_forward.experts.gate_up_proj": "packed_rowwise",
+ "layers.*.feed_forward.experts.gate_up_proj_scale": "packed_rowwise",
+ "layers.*.feed_forward.experts.down_proj": "colwise",
+ }
+ if config.get_text_config() is not None:
+ config.get_text_config().base_model_tp_plan = text_plan
+ else:
+ config.base_model_tp_plan = text_plan
+ return config
+
+ return config
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return False
+
+ def get_quantize_ops(self):
+ from ..integrations.fbgemm_fp8 import FbgemmFp8Quantize
+
+ return FbgemmFp8Quantize(self)
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_finegrained_fp8.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_finegrained_fp8.py
new file mode 100644
index 0000000000000000000000000000000000000000..be10624d4842b189420de294cadf42660153a0f6
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_finegrained_fp8.py
@@ -0,0 +1,226 @@
+from typing import TYPE_CHECKING
+
+from ..utils import is_accelerate_available, is_torch_available, is_torch_xpu_available, logging
+from .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
+
+
+if is_torch_available():
+ import torch
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import FineGrainedFP8Config
+
+logger = logging.get_logger(__name__)
+
+
+class FineGrainedFP8HfQuantizer(HfQuantizer):
+ """
+ FP8 quantization implementation supporting both standard and MoE models.
+ Supports both e4m3fn formats based on platform.
+ """
+
+ requires_calibration = False
+ quantization_config: "FineGrainedFP8Config"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_accelerate_available():
+ raise ImportError("Loading an FP8 quantized model requires accelerate (`pip install accelerate`)")
+
+ if self.quantization_config.dequantize:
+ return
+
+ if not torch.cuda.is_available() and not is_torch_xpu_available():
+ if self.pre_quantized:
+ logger.warning_once(
+ "Using FP8 quantized models requires a GPU or XPU, we will default to dequantizing the model to bf16 since no GPU or XPU is available"
+ )
+ self.quantization_config.dequantize = True
+ return
+ else:
+ raise RuntimeError("No GPU or XPU found. A GPU or XPU is needed for FP8 quantization.")
+
+ if torch.cuda.is_available():
+ compute_capability = torch.cuda.get_device_capability()
+ major, minor = compute_capability
+ if (major < 8) or (major == 8 and minor < 9):
+ logger.warning_once(
+ "FP8 quantized models is only supported on GPUs with compute capability >= 8.9 (e.g 4090/H100)"
+ f", actual = `{major}.{minor}`. We will default to dequantizing the model to bf16. Feel free "
+ f"to use a different quantization method like bitsandbytes or torchao"
+ )
+ self.quantization_config.dequantize = True
+ return
+
+ device_map = kwargs.get("device_map")
+ if device_map is None:
+ logger.warning_once(
+ "You have loaded an FP8 model on CPU and have a CUDA or XPU device available, make sure to set "
+ "your model on a GPU or XPU device in order to run your model. To remove this warning, "
+ "pass device_map = 'cuda' or 'xpu'. "
+ )
+ elif isinstance(device_map, dict):
+ if (
+ not self.pre_quantized
+ and len(device_map) > 1
+ and "cpu" in device_map.values()
+ or "disk" in device_map.values()
+ ):
+ raise ValueError(
+ "You are attempting to load an FP8 model with a device_map that contains a cpu/disk device."
+ "This is not supported when the model is quantized on the fly. "
+ "Please use a quantized checkpoint or remove the cpu/disk device from the device_map."
+ )
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ from ..integrations.finegrained_fp8 import FP8Experts, FP8Linear
+
+ module, tensor_name = get_module_from_name(model, param_name)
+ if isinstance(module, (FP8Linear, FP8Experts)):
+ if self.pre_quantized or tensor_name == "bias":
+ return False
+ else:
+ return True
+ return False
+
+ def param_element_size(self, model: "PreTrainedModel", param_name: str, param: "torch.Tensor") -> float:
+ "Return the element size (in bytes) for `param_name`."
+ if self.param_needs_quantization(model, param_name):
+ # 8 bit, this is neeed as when `pre_quantized`` is False, we don't set the dtype of the FP8Linear in order to correctly load the weights
+ return 1
+ return super().param_element_size(model, param_name, param)
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ from ..integrations.finegrained_fp8 import replace_with_fp8_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+
+ model = replace_with_fp8_linear(
+ model,
+ modules_to_not_convert=self.modules_to_not_convert,
+ quantization_config=self.quantization_config,
+ pre_quantized=self.pre_quantized,
+ )
+
+ def update_tp_plan(self, config):
+ if "Qwen3" in config.__class__.__name__:
+ text_plan = {
+ "layers.*.self_attn.q_proj.weight": "colwise",
+ "layers.*.self_attn.q_proj.weight_scale_inv": "colwise",
+ "layers.*.self_attn.k_proj.weight": "colwise",
+ "layers.*.self_attn.k_proj.weight_scale_inv": "colwise",
+ "layers.*.self_attn.v_proj.weight": "colwise",
+ "layers.*.self_attn.v_proj.weight_scale_inv": "colwise",
+ "layers.*.self_attn.o_proj.weight": "rowwise",
+ "layers.*.self_attn.o_proj.weight_scale_inv": "rowwise",
+ "layers.*.mlp.gate_proj.weight": "colwise",
+ "layers.*.mlp.gate_proj.weight_scale_inv": "colwise",
+ "layers.*.mlp.up_proj.weight": "colwise",
+ "layers.*.mlp.up_proj.weight_scale_inv": "colwise",
+ "layers.*.mlp.down_proj.weight": "rowwise",
+ "layers.*.mlp.down_proj.weight_scale_inv": "rowwise",
+ }
+
+ config.base_model_tp_plan = text_plan
+
+ return config
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return False
+
+ @property
+ def is_compileable(self) -> bool:
+ return True
+
+ def get_quantize_ops(self):
+ from ..integrations.finegrained_fp8 import Fp8Quantize
+
+ return Fp8Quantize(self)
+
+ def get_weight_conversions(self):
+ from ..core_model_loading import WeightConverter
+ from ..integrations.finegrained_fp8 import Fp8Dequantize
+
+ if self.pre_quantized and self.quantization_config.dequantize:
+ return [
+ # either use the dollar sign, or permute the source patterns to start matching against the scales first
+ # We also collect the activation scales, they will not be used
+ WeightConverter(
+ source_patterns=["weight$", "weight_scale_inv", "activation_scale"],
+ target_patterns="weight",
+ operations=[Fp8Dequantize(self)],
+ )
+ ]
+ return []
+
+ def update_weight_conversions(self, weight_conversions):
+ """When loading with ``dequantize=True``, attach an :class:`Fp8Dequantize` op to
+ every existing :class:`WeightConverter` so that per-block scales are folded into
+ the weight *before* any later merge/concat ops collapse the per-expert structure.
+
+ For each model-supplied converter that has a ``.weight`` source, we:
+ 1. anchor the existing weight patterns with ``$`` so they don't accidentally
+ also match the ``.weight_scale_inv`` keys (the regex is searched, so the
+ unanchored prefix would match both, sending scales to the wrong bucket);
+ 2. add anchored ``*.weight_scale_inv`` sources next to each weight pattern so
+ the loader collects scale tensors alongside the weight tensors into the
+ *same* converter bucket (both keys rewrite to the same target);
+ 3. prepend a fresh :class:`Fp8Dequantize` op so dequant runs first, before
+ any merge/concat collapses the per-expert structure.
+
+ The generic ``weight$ + weight_scale_inv → weight`` converter from
+ :meth:`get_weight_conversions` is still appended at the end as a fallback for
+ plain ``nn.Linear`` weights with no model-specific converter.
+ """
+ if not (self.pre_quantized and self.quantization_config.dequantize):
+ return weight_conversions + self.get_weight_conversions()
+
+ from ..core_model_loading import WeightConverter, WeightRenaming
+ from ..integrations.finegrained_fp8 import Fp8Dequantize
+
+ # Some upstream FP8 checkpoints (e.g. DeepSeek-V4-Flash) ship per-block scales
+ # under a ``.scale`` suffix instead of HF's canonical ``.weight_scale_inv``.
+ # Prepending the rename here (instead of in each model's conversion_mapping)
+ # keeps the model-side mapping clean — the rename only kicks in when FP8 dequant
+ # is actually active, so a non-FP8 save / load round-trip doesn't see a stray
+ # rule that ``test_reverse_loading_mapping`` can't match.
+ scale_rename = WeightRenaming(source_patterns=r"^(.+)\.scale$", target_patterns=r"\1.weight_scale_inv")
+ weight_conversions = [scale_rename] + list(weight_conversions)
+
+ updated: list = []
+ for conv in weight_conversions:
+ # Only WeightConverter has ``.operations`` to extend with the dequant op;
+ # WeightRenaming (e.g. the ``scale_rename`` we prepended) just passes through.
+ if not isinstance(conv, WeightConverter):
+ updated.append(conv)
+ continue
+ weight_sources = [p for p in conv.source_patterns if p.endswith(".weight")]
+ if weight_sources:
+ anchored_weight = [p + "$" for p in weight_sources]
+ scale_sources = [p[: -len(".weight")] + ".weight_scale_inv$" for p in weight_sources]
+ other = [p for p in conv.source_patterns if not p.endswith(".weight")]
+ new_sources = anchored_weight + scale_sources + other
+ new_ops = [Fp8Dequantize(self)] + list(conv.operations)
+ conv = WeightConverter(
+ source_patterns=new_sources,
+ target_patterns=conv._original_target_patterns,
+ operations=new_ops,
+ )
+ updated.append(conv)
+ # Generic fallback for plain ``nn.Linear`` weights with no model-specific converter.
+ updated.extend(self.get_weight_conversions())
+ return updated
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_fouroversix.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_fouroversix.py
new file mode 100644
index 0000000000000000000000000000000000000000..79acb8cbb2161a9545229252270b53eaab99b9cf
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_fouroversix.py
@@ -0,0 +1,123 @@
+from typing import TYPE_CHECKING
+
+from ..utils.import_utils import is_fouroversix_available
+from .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import FourOverSixConfig
+
+from ..utils import (
+ is_torch_available,
+)
+
+
+if is_torch_available():
+ import torch
+
+
+class FourOverSixHfQuantizer(HfQuantizer):
+ """
+ FP4 quantization with fouroversix.
+ """
+
+ requires_calibration = False
+ quantization_config: "FourOverSixConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_fouroversix_available():
+ raise ImportError(
+ "Using `fouroversix` requires fouroversix: `pip install fouroversix --no-build-isolation`"
+ )
+
+ def param_element_size(
+ self,
+ model: "PreTrainedModel",
+ param_name: str,
+ param: "torch.Tensor",
+ ) -> float:
+ from fouroversix import QuantizedModule
+
+ module, tensor_name = get_module_from_name(model, param_name)
+
+ if QuantizedModule.is_quantized_module_type(type(module)):
+ return module.get_element_size(tensor_name)
+
+ return super().param_element_size(model, param_name, param)
+
+ def param_needs_quantization(
+ self,
+ model: "PreTrainedModel",
+ param_name: str,
+ **kwargs,
+ ) -> bool:
+ from fouroversix import QuantizedModule
+
+ module, tensor_name = get_module_from_name(model, param_name)
+
+ return QuantizedModule.is_quantized_module_type(type(module)) and tensor_name in module.parameters_to_quantize
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ device_map,
+ **kwargs,
+ ):
+ from fouroversix import QuantizedModule, quantize_model
+
+ from ..integrations.fouroversix import adapt_fouroversix_config
+
+ quantize_model(
+ model,
+ adapt_fouroversix_config(self.quantization_config),
+ )
+
+ # If the model has already been quantized, we need to delete the weight tensor here so that
+ # it's not expected when parameters are loaded from the checkpoint.
+ if self.pre_quantized and not self.quantization_config.keep_master_weights:
+ for _, module in model.named_modules():
+ if QuantizedModule.is_quantized_module_type(type(module)):
+ for parameter_name in module.parameters_to_quantize:
+ delattr(module, parameter_name)
+
+ def _process_model_after_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ return model
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return self.quantization_config.keep_master_weights
+
+ def get_quantize_ops(self):
+ from ..integrations.fouroversix import FourOverSixQuantize
+
+ return FourOverSixQuantize(self)
+
+ def get_weight_conversions(self):
+ """
+ Return weight conversions for loading pre-quantized checkpoints of
+ other pre-quantized models (not fouroversix models). After first use,
+ the pre_quantized_model_config_type attribute is set to None to ensure
+ subsequent calls (e.g., during save_pretrained) return an empty list
+ since, by then, the model will be saved with our framework's format
+ so weight conversions are no longer needed.
+ """
+ from fouroversix import WeightConversions
+
+ # pre_quantized_model_config_type is only set if we are loading a
+ # pre-quantized model so it is not guaranteed to exist.
+ if hasattr(self.quantization_config, "pre_quantized_model_config_type"):
+ model_config_type = self.quantization_config.pre_quantized_model_config_type
+ weight_conversions = WeightConversions.get_weight_conversions(
+ model_config_type,
+ )
+ return weight_conversions
+
+ return []
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_fp_quant.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_fp_quant.py
new file mode 100644
index 0000000000000000000000000000000000000000..c367b957d206fed69a361f11bd42b8e429bda5e5
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_fp_quant.py
@@ -0,0 +1,164 @@
+# Copyright 2025 The HuggingFace Inc. 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, Optional
+
+from .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import FPQuantConfig
+
+from ..utils import is_fp_quant_available, is_qutlass_available, is_torch_available, is_torch_xpu_available, logging
+from ..utils.quantization_config import QuantizationConfigMixin
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+class FPQuantHfQuantizer(HfQuantizer):
+ """
+ Quantizer for the FP-Quant method. Enables the loading of prequantized models and in-flight quantization of full-precision models.
+ """
+
+ requires_calibration = False
+ is_qat_trainable = True
+ quantization_config: "FPQuantConfig"
+
+ def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, device_map, **kwargs):
+ if not torch.cuda.is_available() and not is_torch_xpu_available():
+ raise NotImplementedError(
+ "FPQuant quantization is only supported on GPU or Intel XPU. Please use a different quantizer."
+ )
+
+ if not is_qutlass_available() and not self.quantization_config.pseudoquantization:
+ raise ImportError(
+ "Using `fp_quant` with real quantization requires a **Blackwell GPU** and qutlass: `git clone https://github.com/IST-DASLab/qutlass.git && cd qutlass && pip install --no-build-isolation .`. You can use `FPQuantConfig(pseudoquantization=True, ...)` to use Triton-based pseudo-quantization. It doesn't provide any speedups but emulates the quantization behavior of the real quantization."
+ )
+
+ if (
+ self.quantization_config.pseudoquantization
+ and self.quantization_config.forward_dtype == "nvfp4"
+ and torch.cuda.is_available()
+ and torch.cuda.get_device_capability()[0] < 9
+ ):
+ raise ValueError(
+ "NVFP4 pseudoquantization requires a GPU with compute capability >= 9.0 (Hopper or newer) "
+ "because the Triton kernel uses the `fp8e4nv` type. Please use `forward_dtype='mxfp4'` instead, "
+ "or use a GPU with compute capability >= 9.0."
+ )
+
+ if self.quantization_config.pseudoquantization:
+ logger.warning(
+ "Using pseudo-quantization for FP-Quant. This doesn't provide any speedups but emulates the quantization behavior of the real quantization."
+ )
+
+ if not is_fp_quant_available():
+ raise ImportError("Using `fp_quant` quantization requires fp_quant: `pip install fp_quant`")
+
+ if device_map is None and not self.quantization_config.pseudoquantization:
+ raise ValueError(
+ "You are attempting to load a FPQuant model without setting device_map."
+ " Please set device_map comprised of 'cuda' devices."
+ )
+ elif isinstance(device_map, dict):
+ if (
+ not self.quantization_config.pseudoquantization
+ and len(device_map) > 1
+ and "cpu" in device_map.values()
+ or "disk" in device_map.values()
+ ):
+ raise ValueError(
+ "You are attempting to load a FPQuant model with a device_map that contains a CPU or disk device."
+ " This is not supported. Please remove the CPU or disk device from the device_map."
+ )
+
+ def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
+ if dtype != torch.bfloat16:
+ logger.warning_once(
+ f"Setting dtype to {dtype}, but only bfloat16 is supported right now. Overwriting torch_dtype to bfloat16."
+ )
+ dtype = torch.bfloat16
+ return dtype
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ from fp_quant import FPQuantLinear
+
+ module, tensor_name = get_module_from_name(model, param_name)
+ if isinstance(module, FPQuantLinear) and tensor_name in ["weight", "qweight", "dqweight"]:
+ # Only quantize weights of FPQuantLinear modules that are not already quantized
+ return True
+ else:
+ return False
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ from fp_quant import replace_with_fp_quant_linear
+
+ from ..integrations.fp_quant import adapt_fp_quant_config
+
+ replace_with_fp_quant_linear(
+ model,
+ fp_quant_linear_config=adapt_fp_quant_config(self.quantization_config),
+ )
+
+ @property
+ def is_trainable(self, model: Optional["PreTrainedModel"] = None):
+ trainable = self.quantization_config.store_master_weights
+ if not trainable:
+ logger.warning(
+ "You are attempting to train a model with FPQuant quantization. This is only supported when `store_master_weights=True`. Please set `store_master_weights=True` to train the model."
+ )
+ return trainable
+
+ def is_serializable(self):
+ return True
+
+ def get_quantize_ops(self):
+ from ..integrations.fp_quant import FpQuantQuantize
+
+ return FpQuantQuantize(self)
+
+ def get_weight_conversions(self):
+ from ..core_model_loading import WeightConverter
+ from ..integrations.fp_quant import FpQuantDeserialize
+
+ if self.pre_quantized:
+ if self.quantization_config.pseudoquantization:
+ return [
+ WeightConverter(
+ source_patterns=[".dqweight"],
+ target_patterns=".dqweight",
+ operations=[FpQuantDeserialize(self)],
+ ),
+ ]
+ else:
+ return [
+ WeightConverter(
+ source_patterns=[".qweight"],
+ target_patterns=".qweight",
+ operations=[FpQuantDeserialize(self)],
+ ),
+ ]
+ return []
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_gptq.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_gptq.py
new file mode 100644
index 0000000000000000000000000000000000000000..f018704f494931d5c30f66d695d8ff96bacfc5d0
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_gptq.py
@@ -0,0 +1,111 @@
+# Copyright 2024 The HuggingFace Inc. 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 importlib import metadata
+from typing import TYPE_CHECKING
+
+from packaging import version
+
+from .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+
+from ..utils import is_gptqmodel_available, is_optimum_available, is_torch_available, logging
+from ..utils.quantization_config import GPTQConfig, QuantizationConfigMixin
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+MIN_GPTQ_VERSION = "1.4.3"
+MIN_OPTIMUM_VERSION = "1.24.0"
+
+
+class GptqHfQuantizer(HfQuantizer):
+ """
+ Quantizer of the GPTQ method - for GPTQ the quantizer support calibration of the model through
+ the GPT-QModel package (Python import name `gptqmodel`). Quantization is done under the hood for users if they
+ load a non-prequantized model.
+ """
+
+ requires_calibration = False
+ quantization_config: "GPTQConfig"
+
+ def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ if not is_optimum_available():
+ raise ImportError("Loading a GPTQ quantized model requires optimum (`pip install optimum`)")
+ from optimum.gptq import GPTQQuantizer
+
+ self.optimum_quantizer = GPTQQuantizer.from_dict(self.quantization_config.to_dict_optimum())
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_optimum_available():
+ raise ImportError("Loading a GPTQ quantized model requires optimum (`pip install optimum`)")
+
+ gptq_supports_cpu = is_gptqmodel_available()
+ if not gptq_supports_cpu and not torch.cuda.is_available():
+ raise RuntimeError("GPU is required to quantize or run quantize model.")
+ elif not is_gptqmodel_available():
+ raise ImportError("Loading a GPTQ quantized model requires gptqmodel (`pip install gptqmodel`) library.")
+ elif is_gptqmodel_available() and (
+ version.parse(metadata.version("gptqmodel")) < version.parse(MIN_GPTQ_VERSION)
+ or version.parse(metadata.version("optimum")) < version.parse(MIN_OPTIMUM_VERSION)
+ ):
+ raise ImportError(
+ f"The gptqmodel version should be >= {MIN_GPTQ_VERSION}, optimum version should >= {MIN_OPTIMUM_VERSION}"
+ )
+
+ def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
+ if dtype != torch.float16:
+ logger.info("We suggest you to set `dtype=torch.float16` for better efficiency with GPTQ.")
+ return dtype
+
+ def update_device_map(self, device_map):
+ if device_map is None:
+ device_map = {"": torch.device("cpu")}
+ return device_map
+
+ def _process_model_before_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ if model.__class__.main_input_name != "input_ids":
+ raise RuntimeError("We can only quantize pure text model.")
+
+ if self.pre_quantized:
+ # compat: latest optimum has gptqmodel refactor
+ if version.parse(metadata.version("optimum")) < version.parse(MIN_OPTIMUM_VERSION):
+ model = self.optimum_quantizer.convert_model(model)
+ else:
+ model = self.optimum_quantizer.convert_model(model, **kwargs)
+
+ def _process_model_after_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ if self.pre_quantized:
+ model = self.optimum_quantizer.post_init_model(model)
+ else:
+ if self.quantization_config.tokenizer is None:
+ self.quantization_config.tokenizer = model.name_or_path
+
+ self.optimum_quantizer.quantize_model(model, self.quantization_config.tokenizer)
+ model.config.quantization_config = GPTQConfig.from_dict(self.optimum_quantizer.to_dict())
+
+ @property
+ def is_trainable(self) -> bool:
+ return True
+
+ def is_serializable(self):
+ return True
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_higgs.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_higgs.py
new file mode 100644
index 0000000000000000000000000000000000000000..78d168aab59c2b097c17df6fcfb60483385eeeb0
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_higgs.py
@@ -0,0 +1,178 @@
+# Copyright 2024 The HuggingFace Inc. 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.logging import tqdm
+from .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import HiggsConfig
+
+from ..utils import is_accelerate_available, is_flute_available, is_hadamard_available, is_torch_available, logging
+from ..utils.quantization_config import QuantizationConfigMixin
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+class HiggsHfQuantizer(HfQuantizer):
+ """
+ Quantizer of the HIGGS method. Enables the loading of prequantized models and in-flight quantization of full-precision models.
+ """
+
+ requires_calibration = False
+ quantization_config: "HiggsConfig"
+
+ def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, device_map, **kwargs):
+ if not torch.cuda.is_available():
+ raise NotImplementedError("HIGGS quantization is only supported on GPU. Please use a different quantizer.")
+
+ if not is_accelerate_available():
+ raise ImportError("Using `higgs` quantization requires Accelerate: `pip install accelerate`")
+
+ if not is_flute_available():
+ raise ImportError("Using `higgs` quantization requires FLUTE: `pip install flute-kernel>=0.3.0`")
+
+ if not is_hadamard_available():
+ raise ImportError(
+ "Using `higgs` quantization requires fast_hadamard_transform: `pip install fast_hadamard_transform`"
+ )
+
+ if device_map is None:
+ raise ValueError(
+ "You are attempting to load a HIGGS model without setting device_map."
+ " Please set device_map comprised of 'cuda' devices."
+ )
+ elif isinstance(device_map, dict):
+ if "cpu" in device_map.values() or "disk" in device_map.values():
+ raise ValueError(
+ "You are attempting to load a HIGGS model with a device_map that contains a CPU or disk device."
+ " This is not supported. Please remove the CPU or disk device from the device_map."
+ )
+
+ def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
+ if dtype != torch.float16 and dtype != torch.bfloat16:
+ raise ValueError(
+ f"Invalid `dtype` {dtype}. HIGGS quantization only supports `dtype=torch.float16` or `dtype=torch.bfloat16`."
+ )
+
+ return dtype
+
+ # TODO: to remove
+ # Kept here in case we see some interest in adding support for it
+ # def create_quantized_param(
+ # self,
+ # model: "PreTrainedModel",
+ # param_value: "torch.Tensor",
+ # param_name: str,
+ # target_device: "torch.device",
+ # **kwargs,
+ # ):
+ # from ..integrations import quantize_with_higgs
+
+ # flute_dict = quantize_with_higgs(
+ # param_value.to(target_device),
+ # self.quantization_config.bits,
+ # self.quantization_config.p,
+ # self.quantization_config.group_size,
+ # self.quantization_config.hadamard_size,
+ # )
+ # del param_value
+
+ # module, _ = get_module_from_name(model, param_name)
+ # module_name = ".".join(param_name.split(".")[:-1])
+ # for key, value in flute_dict.items():
+ # if key in module._parameters:
+ # module._parameters[key] = torch.nn.Parameter(value, requires_grad=False)
+ # elif key in module._buffers:
+ # module._buffers[key] = torch.nn.Buffer(value)
+ # elif key == "tune_metadata":
+ # module.tune_metadata = value
+ # self.quantization_config.tune_metadata[module_name] = value.to_dict()
+ # else:
+ # raise ValueError(f"Unexpected key {key} in module {module}")
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ from ..integrations import replace_with_higgs_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+
+ replace_with_higgs_linear(
+ model,
+ quantization_config=self.quantization_config,
+ modules_to_not_convert=self.modules_to_not_convert,
+ )
+
+ def _process_model_after_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ from flute.tune import TuneMetaData, maybe_tune_and_repack
+ from flute.utils import make_workspace_streamk
+
+ from ..integrations import HiggsLinear
+
+ flute_workspaces = {}
+ flute_modules = {name: module for name, module in model.named_modules() if isinstance(module, HiggsLinear)}
+ for name, module in tqdm(flute_modules.items(), desc="Repacking HIGGS modules", leave=False):
+ # Every HiggsLinear needs a "workspace": a buffer for the unpacking operation.
+ # This buffer needs to be on the same device as the weights, but can be reused across modules otherwise.
+ if module.weight.device not in flute_workspaces:
+ flute_workspaces[module.weight.device] = make_workspace_streamk(device=module.weight.device)
+ module.workspace = flute_workspaces[module.weight.device]
+
+ # FLUTE weights are packed in a way that is optimized for a specific number of SMs (GPU streaming multiprocessors).
+ # If the model is loaded on a different device than the one it was saved on, we need to repack the weights.
+ module.tune_metadata = TuneMetaData.from_dict(self.quantization_config.tune_metadata[name])
+ module.weight.data, module.tune_metadata = maybe_tune_and_repack(
+ weight=module.weight.data,
+ scales=module.scales.data,
+ metadata=module.tune_metadata,
+ )
+ self.quantization_config.tune_metadata[name] = module.tune_metadata.to_dict()
+
+ @property
+ def is_trainable(self) -> bool:
+ return False
+
+ def is_serializable(self):
+ return True
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ from ..integrations import HiggsLinear
+
+ module, tensor_name = get_module_from_name(model, param_name)
+ if isinstance(module, HiggsLinear) and tensor_name == "weight":
+ # Only quantize weights of HiggsLinear modules that are not already quantized
+ return True
+ else:
+ return False
+
+ def _dequantize(self, model):
+ from ..integrations import dequantize_higgs
+
+ model = dequantize_higgs(model)
+ return model
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_hqq.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_hqq.py
new file mode 100644
index 0000000000000000000000000000000000000000..05dce3d996a0693a9db2349cbc5079f3aff52cd6
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_hqq.py
@@ -0,0 +1,264 @@
+# Copyright 2024 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 ..integrations import prepare_for_hqq_linear
+from ..utils import is_hqq_available, is_torch_available, logging
+from .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import HqqConfig
+
+
+if is_torch_available():
+ import torch
+
+if is_hqq_available():
+ from hqq.core.quantize import HQQLinear
+
+ # This is a compatibility hack. HQQ-quantized linear layers do not have a `weight` attribute,
+ # but some models attempt to access `weight.dtype` during the forward pass. To prevent runtime errors,
+ # we patch HQQLinear with a dummy `weight` property that returns an empty tensor with the correct dtype and device.
+ @property
+ def weight(self):
+ return torch.empty(0, dtype=self.compute_dtype, device=self.device)
+
+ HQQLinear.weight = weight
+
+logger = logging.get_logger(__name__)
+
+
+class HqqHfQuantizer(HfQuantizer):
+ """
+ HQQ quantizer base HF class.
+ nn.Linear modules are first tagged with quant_config in _process_model_before_weight_loading().
+ """
+
+ requires_calibration = False
+ quantization_config: "HqqConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ if not is_hqq_available():
+ raise ImportError(
+ "A valid HQQ version (>=0.2.1) is not available. Please follow the instructions to install it: `https://github.com/mobiusml/hqq/`."
+ )
+ super().__init__(quantization_config, **kwargs)
+ self.dtype = None
+ self.using_multi_gpu = False
+ # Keys that are serialized specifically by hqq
+ self.hqq_keys = HQQLinear(None, None).state_dict_keys() - {"bias"}
+
+ def validate_environment(self, *args, **kwargs):
+ if self.dtype is None:
+ if "dtype" in kwargs:
+ self.dtype = kwargs["dtype"]
+ else:
+ self.dtype = torch.float32
+ logger.info("Setting dtype to torch.float32 as the default value since it was not specified.")
+
+ device_map = kwargs.get("device_map")
+ if isinstance(device_map, dict):
+ if "cpu" in device_map.values() or "disk" in device_map.values():
+ raise ValueError(
+ "You are attempting to use an HQQ model with a device_map that contains a CPU or disk device."
+ " This is not supported. Please remove the CPU or disk device from the device_map."
+ )
+ else:
+ self.using_multi_gpu = len(set(device_map.values())) > 1
+
+ # TODO: to remove
+ # Kept here in case we see some interest in adding support for it
+ # # Adds missing keys for HQQLinear modules that are loaded but the model with initialized with torch.nn.Linear
+ # def update_expected_keys(
+ # self, model: "PreTrainedModel", expected_keys: list[str], loaded_keys: list[str]
+ # ) -> list[str]:
+ # if not self.pre_quantized:
+ # return expected_keys
+
+ # # Collects all quantizable (linear) layers
+ # def _find_hqq_quantizable_layers(model, layers):
+ # for name, module in model.named_children():
+ # if isinstance(module, (torch.nn.Linear)):
+ # layers.add(module.name)
+ # _find_hqq_quantizable_layers(module, layers)
+
+ # new_keys = set(expected_keys)
+
+ # # Name modules
+ # for name, module in model.named_modules():
+ # module.name = name
+
+ # # valid modules are Linear layers that have HQQLinear state_dict. We ignore skip_modules and any layers with Linear state_dict() params
+ # _valid_modules = set()
+ # _find_hqq_quantizable_layers(model, _valid_modules)
+
+ # # Remove skipped modules
+ # _skipped_modules = set()
+ # for _module in _valid_modules:
+ # for _skip_module in model.config.quantization_config["skip_modules"]:
+ # if _skip_module in _module:
+ # _skipped_modules.add(_module)
+ # _valid_modules -= _skipped_modules
+
+ # # Append new expected layers based on _ref_keys
+ # _ref_keys = HQQLinear(
+ # linear_layer=None,
+ # quant_config=None,
+ # compute_dtype=torch.float16,
+ # device="cpu",
+ # del_orig=False,
+ # ).state_dict_keys() - {"bias"}
+
+ # # Clean-up
+ # _rm_keys = set()
+ # for key in new_keys:
+ # if any(_module in key for _module in _valid_modules):
+ # _rm_keys.add(key)
+ # new_keys -= _rm_keys
+ # # At this point, new_keys contains all the keys of the layers that are NOT HQQLinear or torch.nn.Linear
+
+ # # Re-populate Linear/HQQLinear
+ # for _module in _valid_modules:
+ # if _module + ".weight" in loaded_keys:
+ # new_keys.add(_module + ".weight")
+ # else:
+ # new_keys.update({_module + "." + _ref_key for _ref_key in _ref_keys})
+ # if _module + ".bias" in loaded_keys:
+ # new_keys.add(_module + ".bias")
+
+ # return list(new_keys)
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ module, _ = get_module_from_name(model, param_name)
+ # Since we do not prepare the modules in advance, we need every param of the Linear layer to go through
+ # `create_quantized_param`, even when `self.is_quantized == True`
+ return isinstance(module, torch.nn.Linear)
+
+ # TODO: to remove
+ # def create_quantized_param(
+ # self,
+ # model: "PreTrainedModel",
+ # param_value: "torch.Tensor",
+ # param_name: str,
+ # target_device: "torch.device",
+ # **kwargs,
+ # ):
+ # module, tensor_name = get_module_from_name(model, param_name)
+ # module_name = param_name.rsplit(".", 1)[0]
+ # parent_module, node = get_module_from_name(model, module_name)
+
+ # quant_config = model.config.quantization_config["quant_config"]
+ # skip_modules = model.config.quantization_config["skip_modules"]
+
+ # # In this case we do not quantize this layer (it's explicitly skipped) -> simply load param
+ # if any(skip_module in module.name for skip_module in skip_modules):
+ # module.load_state_dict(
+ # {tensor_name: param_value.to(device=target_device, dtype=self.dtype)}, strict=False, assign=True
+ # )
+ # return
+
+ # # We need this hack as the model is not pre-prepared as an empty skeleton on meta device
+ # if self.pre_quantized:
+ # # Save them for later
+ # if not hasattr(self, "hqq_params"):
+ # self.hqq_params = defaultdict(dict)
+ # self.hqq_params[module_name].update({tensor_name: param_value})
+ # hqq_params = self.hqq_params[module_name]
+
+ # # If they are all present and saved, make it a HQQLinear layer! (we cannot do it param after param because
+ # # hqq does not support it...)
+ # if all(k in hqq_params for k in self.hqq_keys) and ("bias" in hqq_params or module.bias is None):
+ # hqq_layer = HQQLinear(
+ # linear_layer=None,
+ # quant_config=None,
+ # compute_dtype=self.dtype,
+ # device=target_device,
+ # del_orig=False,
+ # )
+ # hqq_layer.load_state_dict(hqq_params)
+
+ # if hqq_layer.bias is not None and isinstance(hqq_layer.bias, torch.Tensor):
+ # hqq_layer.bias = torch.nn.Parameter(hqq_layer.bias)
+ # if self.using_multi_gpu:
+ # hqq_layer = self._patch_layer_for_multigpu(hqq_layer)
+
+ # setattr(parent_module, node, hqq_layer)
+ # del self.hqq_params[module_name], module
+ # return
+
+ # # Load param in the module (without caring about device or dtype, it will be changed later)
+ # module.load_state_dict({tensor_name: param_value}, strict=False, assign=True)
+
+ # # If both the weight and bias have already been loaded, time to quantize!
+ # module_is_ready = module.weight.device.type != "meta" and (
+ # module.bias is None or module.bias.device.type != "meta"
+ # )
+
+ # if module_is_ready:
+ # module_tag = ".".join(module.name.split(".")[-2:])
+ # if "weight_quant_params" in quant_config:
+ # module_quant_config = quant_config
+ # elif module_tag in quant_config:
+ # module_quant_config = quant_config[module_tag]
+
+ # hqq_layer = HQQLinear(
+ # module,
+ # quant_config=module_quant_config,
+ # compute_dtype=self.dtype,
+ # device=target_device,
+ # del_orig=True,
+ # )
+
+ # if hqq_layer.bias is not None and isinstance(hqq_layer.bias, torch.Tensor):
+ # hqq_layer.bias = torch.nn.Parameter(hqq_layer.bias)
+
+ # if self.using_multi_gpu:
+ # hqq_layer = self._patch_layer_for_multigpu(hqq_layer)
+
+ # setattr(parent_module, node, hqq_layer)
+
+ def _patch_layer_for_multigpu(self, hqq_layer):
+ def forward_with_device(self, x):
+ out = torch.matmul(x.to(self.device), self.dequantize().t())
+ if self.bias is not None:
+ out += self.bias
+ return out
+
+ hqq_layer.forward = lambda x: forward_with_device(hqq_layer, x)
+ return hqq_layer
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ # Add the corresponding quant_config to each valid module. This allows us to do the actual nn.Linear -> HQQLinear conversion in create_quantized_param().
+ # prepare_for_hqq_linear() also sets the right quantization config inside the model (model.config.quantization_config) and the layers (hqq_layer.quant_config)
+ model = prepare_for_hqq_linear(model, quantization_config=self.quantization_config)
+
+ def _process_model_after_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ setattr(model, "is_hqq_quantized", True)
+ setattr(model, "is_hqq_serializable", self.is_serializable())
+ return model
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return True
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_metal.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_metal.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3706ed7e2b44d7b30aad5715097bf6a0c5351f9
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_metal.py
@@ -0,0 +1,130 @@
+# Copyright 2025 The HuggingFace Inc. 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, Any
+
+from ..utils import is_kernels_available, is_torch_available, logging
+from .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
+
+
+if is_torch_available():
+ import torch
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import MetalConfig
+
+logger = logging.get_logger(__name__)
+
+
+class MetalHfQuantizer(HfQuantizer):
+ """
+ Quantizer for Metal affine quantization on Apple Silicon (MPS) devices.
+
+ Uses the ``quantization-mlx`` Metal kernels from the Hub to pack weights into
+ low-bit (2/4/8) uint32 tensors with per-group scales and biases, and performs
+ fused dequant + matmul in the forward pass.
+ """
+
+ requires_calibration = False
+ quantization_config: "MetalConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if self.quantization_config.dequantize:
+ return
+
+ if not torch.backends.mps.is_available():
+ if self.pre_quantized:
+ logger.warning_once(
+ "Metal quantization requires an Apple Silicon GPU (MPS), but none is available. "
+ "We will default to dequantizing the model to the original dtype."
+ )
+ self.quantization_config.dequantize = True
+ return
+ else:
+ raise RuntimeError("Metal quantization requires an Apple Silicon GPU (MPS). No MPS device found.")
+
+ if not is_kernels_available():
+ raise ImportError("Metal quantization requires kernels: `pip install kernels`")
+
+ device_map = kwargs.get("device_map")
+ if device_map is None:
+ logger.warning_once(
+ "You have loaded a Metal quantized model on CPU and have an MPS device available. "
+ "Set device_map='mps' to use the Metal kernels."
+ )
+ elif isinstance(device_map, dict):
+ if not self.pre_quantized and ("cpu" in device_map.values() or "disk" in device_map.values()):
+ raise ValueError(
+ "Metal quantization on the fly does not support CPU or disk in the device_map. "
+ "Please use a pre-quantized checkpoint or remove CPU/disk from device_map."
+ )
+
+ def update_device_map(self, device_map: dict[str, Any] | None) -> dict[str, Any] | None:
+ if device_map is None:
+ device_map = {"": "mps"}
+ return device_map
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ from ..integrations.metal_quantization import MetalLinear
+
+ module, tensor_name = get_module_from_name(model, param_name)
+ if isinstance(module, MetalLinear):
+ if self.pre_quantized or tensor_name != "weight":
+ return False
+ return True
+ return False
+
+ def _process_model_before_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ from ..integrations.metal_quantization import replace_with_metal_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+
+ model = replace_with_metal_linear(
+ model,
+ modules_to_not_convert=self.modules_to_not_convert,
+ quantization_config=self.quantization_config,
+ pre_quantized=self.pre_quantized,
+ )
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return False
+
+ def get_quantize_ops(self):
+ from ..integrations.metal_quantization import MetalQuantize
+
+ return MetalQuantize(self)
+
+ def get_weight_conversions(self):
+ from ..core_model_loading import WeightConverter
+ from ..integrations.metal_quantization import MetalDequantize
+
+ if self.pre_quantized and self.quantization_config.dequantize:
+ return [
+ WeightConverter(
+ source_patterns=["weight$", "scales", "qbiases"],
+ target_patterns="weight",
+ operations=[MetalDequantize(self)],
+ )
+ ]
+ return []
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_mxfp4.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_mxfp4.py
new file mode 100644
index 0000000000000000000000000000000000000000..7859a8ff739ad41674f0f0ad5c28bbcfe3639ab9
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_mxfp4.py
@@ -0,0 +1,315 @@
+# Copyright 2025 The HuggingFace Inc. 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 .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import Mxfp4Config
+
+from ..utils import (
+ is_accelerate_available,
+ is_kernels_available,
+ is_torch_available,
+ is_triton_available,
+ logging,
+)
+from .quantizers_utils import get_module_from_name
+
+
+if is_torch_available():
+ import torch
+
+ from ..core_model_loading import WeightConverter
+
+logger = logging.get_logger(__name__)
+triton_kernels_hub = None
+
+
+class Mxfp4HfQuantizer(HfQuantizer):
+ """
+ FP4 quantization using fbgemm kernels
+ """
+
+ requires_calibration = False
+ quantization_config: "Mxfp4Config"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+ self.triton_kernels_hub = None
+
+ def _lazy_import_kernels(self):
+ """Lazy import and initialize kernels only when needed"""
+ if self.triton_kernels_hub is None:
+ try:
+ from ..integrations.hub_kernels import get_kernel
+
+ self.triton_kernels_hub = get_kernel("kernels-community/gpt-oss-triton-kernels")
+ except ImportError:
+ raise ImportError("kernels package is required for MXFP4 quantization")
+ return self.triton_kernels_hub
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_torch_available():
+ raise ImportError(
+ "Using mxfp4 quantization requires torch"
+ "Please install the latest version of torch ( pip install --upgrade torch )"
+ )
+
+ if self.quantization_config.dequantize:
+ return
+
+ if not is_accelerate_available():
+ raise ImportError("Using mxfp4 requires Accelerate: `pip install accelerate`")
+
+ device = torch.accelerator.current_accelerator() or torch.device("cpu")
+ if device.type not in ["cuda", "xpu", "cpu"]:
+ if self.pre_quantized:
+ logger.warning_once(
+ f"Using MXFP4 quantized models requires model on cuda/xpu/cpu, but found {device}, we will default to dequantizing the model to bf16. To use mxfp4, please disable the current accelerator."
+ )
+ self.quantization_config.dequantize = True
+ return
+ else:
+ raise RuntimeError(
+ f"Quantizing a model using MXFP4 requires model on cuda/xpu/cpu, but found {device}. To use mxfp4, please disable the current accelerator."
+ )
+
+ if torch.xpu.is_available():
+ is_device_supported_mxfp4 = True
+ triton_available = is_triton_available("3.5.0")
+ kernels_installed = is_kernels_available()
+ elif torch.cuda.is_available():
+ compute_capability = torch.cuda.get_device_capability()
+ is_device_supported_mxfp4 = compute_capability >= (7, 5)
+ triton_available = is_triton_available("3.4.0")
+ kernels_installed = is_kernels_available()
+ elif device.type == "cpu":
+ is_device_supported_mxfp4 = True
+ triton_available = is_triton_available("3.5.0")
+ kernels_installed = is_kernels_available()
+ else:
+ is_device_supported_mxfp4 = False
+ triton_available = False
+ kernels_installed = False
+
+ if self.pre_quantized:
+ if not is_device_supported_mxfp4:
+ logger.warning_once(
+ "MXFP4 quantization is only supported on GPUs with compute capability >= 7.5 "
+ "(e.g T4, A100, L4, H100, or B200) or XPUs (e.g Intel® Data Center GPU Max Series). "
+ "We will default to dequantizing the model to bf16."
+ )
+ self.quantization_config.dequantize = True
+ return
+
+ if not triton_available:
+ logger.warning_once(
+ "MXFP4 quantization requires Triton: CUDA requires Triton >= 3.4.0, "
+ "XPU/CPU requires Triton >= 3.5.0. Please install triton: `pip install triton`. "
+ "We will default to dequantizing the model to bf16."
+ )
+ self.quantization_config.dequantize = True
+ return
+
+ if not kernels_installed:
+ logger.warning_once(
+ "MXFP4 quantization requires the `kernels` package: "
+ "`pip install kernels>=0.12.0`. "
+ "We will default to dequantizing the model to bf16."
+ )
+ self.quantization_config.dequantize = True
+ return
+ elif not is_device_supported_mxfp4:
+ raise ValueError(
+ "MXFP4 quantization is only supported on GPUs with compute capability >= 7.5 "
+ "(e.g T4, A100, L4, H100, or B200) or XPUs (e.g Intel® Data Center GPU Max Series) or CPU"
+ )
+ elif not triton_available:
+ raise ValueError(
+ "MXFP4 quantization requires Triton: CUDA requires Triton >= 3.4.0, "
+ "XPU/CPU requires Triton >= 3.5.0. Please install triton: `pip install triton`"
+ )
+ elif not kernels_installed:
+ raise ValueError("MXFP4 quantization requires the `kernels` package: `pip install kernels>=0.12.0`")
+
+ if not self.pre_quantized:
+ self._lazy_import_kernels()
+
+ device_map = kwargs.get("device_map")
+ if device_map is not None and isinstance(device_map, dict):
+ if not self.pre_quantized and "disk" in device_map.values():
+ raise ValueError(
+ "You are attempting to load an FP4 model with a device_map that contains a disk device."
+ "This is not supported when the model is quantized on the fly. "
+ "Please use a quantized checkpoint or remove the disk device from the device_map."
+ )
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ from ..integrations import Mxfp4GptOssExperts
+
+ module, tensor_name = get_module_from_name(model, param_name)
+ if isinstance(module, Mxfp4GptOssExperts):
+ if tensor_name in ["down_proj_bias", "gate_up_proj_bias"]:
+ return False
+ return True
+ return False
+
+ def _process_model_after_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ # clean cache due to triton ops
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ elif torch.xpu.is_available():
+ torch.xpu.empty_cache()
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ use_kernels: bool = False,
+ **kwargs,
+ ):
+ from ..integrations import replace_with_mxfp4_linear
+
+ # if we are using kernels, we can't use the quantized model, since the forward pass is different and needs special handling
+ # only CPU kernels can work with pre-quantized models
+ device = torch.accelerator.current_accelerator() or torch.device("cpu")
+ if use_kernels and device.type not in ["cpu"]:
+ logger.warning_once(
+ "You are using full precision kernels, we will dequantize the model to bf16. "
+ "To use the quantized model with quantization kernels, please set use_kernels=False"
+ )
+ self.quantization_config.dequantize = True
+
+ if not use_kernels and device.type in ["cpu"]:
+ logger.warning_once(
+ "MXFP4 inference on CPU requires use_kernels=True, but use_kernels is disabled. "
+ "We will dequantize the model to bf16. To run MXFP4 natively on CPU, please set use_kernels=True."
+ )
+ self.quantization_config.dequantize = True
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+
+ model = replace_with_mxfp4_linear(
+ model, modules_to_not_convert=self.modules_to_not_convert, quantization_config=self.quantization_config
+ )
+
+ def update_tp_plan(self, config):
+ if "GptOssConfig" in config.__class__.__name__:
+ if getattr(config, "base_model_tp_plan", None) is not None:
+ config.base_model_tp_plan.update(
+ {
+ "layers.*.mlp.experts.gate_up_proj_blocks": "grouped_gemm",
+ "layers.*.mlp.experts.gate_up_proj_scales": "grouped_gemm",
+ "layers.*.mlp.experts.down_proj_blocks": "grouped_gemm",
+ "layers.*.mlp.experts.down_proj_scales": "grouped_gemm",
+ }
+ )
+ return config
+
+ def update_ep_plan(self, config):
+ if "GptOssConfig" in config.__class__.__name__:
+ if getattr(config, "base_model_ep_plan", None) is not None:
+ config.base_model_ep_plan.update(
+ {
+ "layers.*.mlp.experts.gate_up_proj_blocks": "grouped_gemm",
+ "layers.*.mlp.experts.gate_up_proj_scales": "grouped_gemm",
+ "layers.*.mlp.experts.down_proj_blocks": "grouped_gemm",
+ "layers.*.mlp.experts.down_proj_scales": "grouped_gemm",
+ }
+ )
+ return config
+
+ def get_state_dict_and_metadata(self, model):
+ from ..integrations import Mxfp4GptOssExperts
+
+ state_dict = model.state_dict()
+ num_local_experts = getattr(model.config, "num_local_experts", 32)
+ hidden_size = getattr(model.config, "hidden_size", 2880)
+
+ for name, module in model.named_modules():
+ if not (
+ isinstance(module, Mxfp4GptOssExperts)
+ and hasattr(module, "gate_up_proj")
+ and hasattr(module, "down_proj")
+ ):
+ continue
+
+ for proj in ("gate_up_proj", "down_proj"):
+ triton_tensor = getattr(module, proj)
+ precision_config = getattr(module, f"{proj}_precision_config")
+
+ blocks = triton_tensor.storage.layout.unswizzle_data(triton_tensor.storage.data).transpose(-1, -2)
+ if proj == "gate_up_proj":
+ blocks = blocks.reshape(num_local_experts, -1, 90, 16)
+ else:
+ blocks = blocks.reshape(num_local_experts, hidden_size, 90, -1)
+
+ scales = precision_config.weight_scale.storage.layout.unswizzle_data(
+ precision_config.weight_scale.storage.data
+ ).transpose(-1, -2)
+
+ state_dict[f"{name}.{proj}_blocks"] = blocks
+ state_dict[f"{name}.{proj}_scales"] = scales
+
+ metadata = {}
+ return state_dict, metadata
+
+ def is_serializable(self):
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ logger.warning_once(
+ "MXFP4 quantization don't support training, please consider dequantizing the model first by passing quantization_config=Mxfp4Config(dequantize=True) to .from_pretrained()"
+ )
+ return False
+
+ def get_quantize_ops(self):
+ from ..integrations.mxfp4 import Mxfp4Quantize
+
+ return Mxfp4Quantize(self)
+
+ def get_weight_conversions(self):
+ from ..integrations.mxfp4 import Mxfp4Dequantize, Mxfp4Deserialize
+
+ if self.pre_quantized and self.quantization_config.dequantize:
+ return [
+ WeightConverter(
+ source_patterns=["down_proj_blocks", "down_proj_scales"],
+ target_patterns=r"down_proj$",
+ operations=[Mxfp4Dequantize(self)],
+ ),
+ WeightConverter(
+ source_patterns=["gate_up_proj_blocks", "gate_up_proj_scales"],
+ target_patterns=["gate_up_proj$"],
+ operations=[Mxfp4Dequantize(self)],
+ ),
+ ]
+
+ return [
+ WeightConverter(
+ source_patterns=["gate_up_proj_blocks", "gate_up_proj_scales"],
+ target_patterns=r"gate_up_proj$",
+ operations=[Mxfp4Deserialize(self)],
+ ),
+ WeightConverter(
+ source_patterns=["down_proj_blocks", "down_proj_scales"],
+ target_patterns=r"down_proj$",
+ operations=[Mxfp4Deserialize(self)],
+ ),
+ ]
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_quanto.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_quanto.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b08ec271356b1c8236f48a6e6418d4afbbd5768
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_quanto.py
@@ -0,0 +1,122 @@
+# Copyright 2024 The HuggingFace Inc. 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 .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+
+from ..utils import (
+ is_accelerate_available,
+ is_optimum_quanto_available,
+ is_torch_available,
+ logging,
+)
+from ..utils.quantization_config import QuantoConfig
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+class QuantoHfQuantizer(HfQuantizer):
+ """
+ Quantizer for the quanto library
+ """
+
+ requires_calibration = False
+ quantization_config: "QuantoConfig"
+
+ def __init__(self, quantization_config: QuantoConfig, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+ map_to_param_size = {
+ "int8": 1,
+ "float8": 1,
+ "int4": 0.5,
+ "int2": 0.25,
+ }
+ self.quantized_param_size = map_to_param_size.get(self.quantization_config.weights, None)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_optimum_quanto_available():
+ raise ImportError(
+ "Loading an optimum-quanto quantized model requires optimum-quanto library (`pip install optimum-quanto`)"
+ )
+ if not is_accelerate_available():
+ raise ImportError(
+ "Loading an optimum-quanto quantized model requires accelerate library (`pip install accelerate`)"
+ )
+ device_map = kwargs.get("device_map")
+ if isinstance(device_map, dict):
+ if len(device_map) > 1 and "cpu" in device_map.values() or "disk" in device_map.values():
+ raise ValueError(
+ "You are attempting to load an model with a device_map that contains a CPU or disk device."
+ "This is not supported with quanto when the model is quantized on the fly. "
+ "Please remove the CPU or disk device from the device_map."
+ )
+ if self.quantization_config.activations is not None:
+ raise ValueError(
+ "We don't support quantizing the activations with transformers library."
+ "Use quanto library for more complex use cases such as activations quantization, calibration and quantization aware training."
+ )
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ from optimum.quanto import QModuleMixin
+
+ module, tensor_name = get_module_from_name(model, param_name)
+ # We only quantize the weights and the bias is not quantized.
+ if isinstance(module, QModuleMixin) and "weight" in tensor_name:
+ # if the weights are quantized, don't need to recreate it again with `create_quantized_param`
+ return not module.frozen
+ else:
+ return False
+
+ def adjust_max_memory(self, max_memory: dict[str, int | str]) -> dict[str, int | str]:
+ max_memory = {key: val * 0.90 for key, val in max_memory.items()}
+ return max_memory
+
+ def param_element_size(self, model: "PreTrainedModel", param_name: str, param: "torch.Tensor") -> float:
+ "Return the element size (in bytes) for `param_name`."
+ if self.param_needs_quantization(model, param_name) and self.quantized_param_size is not None:
+ return self.quantized_param_size
+
+ return super().param_element_size(model, param_name, param)
+
+ def _process_model_before_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ from ..integrations import replace_with_quanto_layers
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+
+ model = replace_with_quanto_layers(
+ model, modules_to_not_convert=self.modules_to_not_convert, quantization_config=self.quantization_config
+ )
+
+ @property
+ def is_trainable(self) -> bool:
+ return True
+
+ def is_serializable(self):
+ return False
+
+ def get_quantize_ops(self):
+ from ..integrations.quanto import QuantoQuantize
+
+ return QuantoQuantize(self)
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_quark.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_quark.py
new file mode 100644
index 0000000000000000000000000000000000000000..590159cce77cb765b6d3c53a439ee3d9eb60d45a
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_quark.py
@@ -0,0 +1,104 @@
+# Copyright 2025 Advanced Micro Devices, Inc. and The HuggingFace Inc. 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 .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import QuarkConfig
+
+from ..utils import is_quark_available, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+CHECKPOINT_KEYS = {
+ "weight_scale": "weight_quantizer.scale",
+ "bias_scale": "bias_quantizer.scale",
+ "input_scale": "input_quantizer.scale",
+ "output_scale": "output_quantizer.scale",
+ "weight_zero_point": "weight_quantizer.zero_point",
+ "bias_zero_point": "bias_quantizer.zero_point",
+ "input_zero_point": "input_quantizer.zero_point",
+ "output_zero_point": "output_quantizer.zero_point",
+}
+
+
+class QuarkHfQuantizer(HfQuantizer):
+ """
+ Quark quantizer (https://quark.docs.amd.com/latest/).
+ """
+
+ requires_calibration = True # On-the-fly quantization with quark is not supported for now.
+ quantization_config: "QuarkConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ self.json_export_config = quantization_config.json_export_config
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_quark_available():
+ raise ImportError(
+ "Loading a Quark quantized model requires the `quark` library but it was not found in the environment. Please refer to https://quark.docs.amd.com/latest/install.html."
+ )
+
+ def _process_model_before_weight_loading(self, model: "PreTrainedModel", **kwargs):
+ from quark.torch.export.api import _map_to_quark
+
+ _map_to_quark(
+ model,
+ self.quantization_config.quant_config,
+ pack_method=self.json_export_config.pack_method,
+ custom_mode=self.quantization_config.custom_mode,
+ )
+
+ return model
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ return True
+
+ def is_serializable(self):
+ return False
+
+ @property
+ def is_trainable(self):
+ return False
+
+ def get_weight_conversions(self):
+ from ..core_model_loading import WeightConverter
+ from ..integrations.quark import QuarkDeserialize
+
+ # In Quark, quantization is managed through a QParamsLinear module, which holds
+ # separate quantizers for the weights, inputs, and biases (e.g. weight_quantizer
+ # input_quantizer, bias_quantizer, etc.).
+ #
+ # The checkpoint stores keys like `weight_scale`, `input_scale`, etc.
+ # but the model's state_dict() exposes `weight_quantizer.scale`, `input_quantizer.scale`, etc.
+ # We rename from checkpoint format to model format, and the QuarkDeserialize operation
+ # handles assigning values into the corresponding quantizer attributes.
+ converters = []
+ for source_key, target_key in CHECKPOINT_KEYS.items():
+ converters.append(
+ WeightConverter(
+ source_patterns=[source_key],
+ target_patterns=target_key,
+ operations=[QuarkDeserialize(self)],
+ )
+ )
+ return converters
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_sinq.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_sinq.py
new file mode 100644
index 0000000000000000000000000000000000000000..d42d4cc8296d2e0fba5535075235cf13c99d63a1
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_sinq.py
@@ -0,0 +1,262 @@
+# Copyright 2026 The HuggingFace Inc. 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 __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..utils import is_torch_available, logging
+from ..utils.quantization_config import SinqConfig
+from .base import HfQuantizer
+from .quantizers_utils import get_module_from_name
+
+
+if is_torch_available():
+ import torch
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+
+logger = logging.get_logger(__name__)
+
+
+class SinqHfQuantizer(HfQuantizer):
+ """
+ HF v5 quantizer for SINQ.
+
+ Modes:
+ - method="sinq" (default):
+ * weight-only SINQ
+ * param-level ConversionOps (`SinqQuantize`) during load for pure language models
+ (each Linear.weight is turned into a SINQLinear module)
+ * module-level quantization after load for multimodal models
+ - method="asinq":
+ * A-SINQ (activation-aware) SINQ quantization
+ """
+
+ requires_parameters_quantization: bool = True
+ quantization_config: SinqConfig
+
+ def __init__(self, quantization_config: SinqConfig, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ self._normalized_device_str: str | None = None
+ self._do_param_level_sinq: bool = False
+
+ def is_serializable(self) -> bool:
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ return True
+
+ def update_device_map(self, device_map):
+ if device_map is None:
+ if torch.cuda.is_available():
+ device_map = {"": torch.cuda.current_device()}
+ else:
+ device_map = {"": "cpu"}
+ logger.info(
+ "The device_map was not initialized. "
+ f"Setting device_map to {device_map}. "
+ "If you want to use the model for inference, please set device_map='auto'"
+ )
+ return device_map
+
+ def update_dtype(self, dtype: torch.dtype) -> torch.dtype:
+ if dtype is None:
+ dtype = torch.bfloat16
+ self.dtype = dtype
+ return dtype
+
+ def validate_environment(self, *args, **kwargs) -> None:
+ from ..utils import is_sinq_available
+
+ if not is_sinq_available():
+ raise ImportError("The 'sinq' package is not installed. Please install it with: pip install sinq")
+
+ if not torch.cuda.is_available():
+ logger.warning(
+ "No CUDA device is available. Quantization and inference will run on the CPU. Please note that this will significantly slow down inference speed and increase quantization time."
+ )
+
+ device_map = kwargs.get("device_map")
+
+ if isinstance(device_map, dict):
+ device_map_values = set(device_map.values())
+ if len(device_map_values) > 1:
+ raise RuntimeError(
+ "SinqHfQuantizer: multi-GPU device_map detected, but SINQ currently supports only a single CUDA "
+ f"device. Got {sorted(device_map_values)}. Please use device_map=None."
+ )
+
+ if self.quantization_config.method == "asinq" and not self.pre_quantized:
+ raise ValueError(
+ "You are using `method='asinq'` in the quantization config. Right now the calibrated version of SINQ"
+ " is not supported in Hugging Face, please refer and use the official SINQ repository "
+ "`to quantize a model with this method. "
+ )
+
+ def _build_sinq_quant_dict(self, cfg: SinqConfig) -> dict:
+ """
+ Build the dict that SINQLinear expects as quant_config.
+ """
+ from sinq.sinqlinear_hf import sinq_base_quant_config as sinq_base_quant_config_fn
+
+ method = cfg.method
+ return sinq_base_quant_config_fn(
+ nbits=int(cfg.nbits),
+ group_size=int(cfg.group_size) if cfg.group_size is not None else None,
+ quant_zero=False,
+ quant_scale=False,
+ view_as_float=False,
+ axis=1,
+ tiling_mode=str(cfg.tiling_mode),
+ method=method,
+ )
+
+ def param_needs_quantization(self, model: PreTrainedModel, param_name: str, **kwargs) -> bool:
+ """
+ Called per-parameter to decide whether to run `SinqQuantize` on it.
+
+ - If `self.pre_quantized`, we do *not* quantize again (handled by SinqDeserialize instead).
+ - For method="asinq": return False (ASINQ is not supported in Hugging Face).
+ - For method="sinq": True only for SINQLinear.weight not in modules_to_not_convert.
+
+ Note: After _process_model_before_weight_loading(), the modules are already SINQLinear,
+ not nn.Linear. We check for SINQLinear modules that are not yet quantized (ready=False).
+ """
+ from sinq.sinqlinear_hf import SINQLinear
+
+ if self.pre_quantized:
+ return False
+
+ if self.quantization_config.method == "asinq":
+ return False
+
+ # SINQ param-level only if deemed safe
+ if not self._do_param_level_sinq:
+ return False
+
+ module, tensor_name = get_module_from_name(model, param_name)
+
+ if tensor_name != "weight":
+ return False
+
+ # Check if it's an unquantized SINQLinear
+ is_sinq = isinstance(module, SINQLinear)
+ is_ready = getattr(module, "ready", True)
+ result = is_sinq and not is_ready
+ return result
+
+ def get_quantize_ops(self):
+ """
+ Return the ConversionOps used for param-level quantization (Sinq).
+ The actual SINQLinear construction is in integrations/sinq.py.
+ """
+ from ..integrations.sinq import SinqQuantize
+
+ return SinqQuantize(self)
+
+ def get_weight_conversions(self):
+ """
+ If `pre_quantized=True`, interpret a checkpoint produced by SINQLinear.state_dict:
+
+ <prefix>.W_q
+ <prefix>.bias
+ <prefix>.meta
+
+ via a WeightConverter + SinqDeserialize so that we reconstruct a SINQLinear
+ module instead of a plain nn.Linear.
+ """
+ from ..core_model_loading import WeightConverter
+
+ if self.pre_quantized:
+ from ..integrations.sinq import SinqDeserialize
+
+ return [
+ WeightConverter(
+ source_patterns=[
+ ".W_q",
+ ".meta",
+ ".bias",
+ ],
+ target_patterns=[".weight"],
+ operations=[SinqDeserialize(self)],
+ )
+ ]
+ return []
+
+ def _process_model_before_weight_loading(
+ self,
+ model: PreTrainedModel,
+ device_map,
+ keep_in_fp32_modules: list[str] | None = None,
+ **kwargs,
+ ):
+ """
+ Called on meta-initialized model, before loading any weights.
+
+ For SINQ, we replace nn.Linear modules with empty SINQLinear modules here.
+ The actual quantization happens later in SinqQuantize.convert() when weights are loaded.
+ """
+ from ..integrations.sinq import replace_with_sinq_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, (self.quantization_config.modules_to_not_convert or []), keep_in_fp32_modules
+ )
+
+ # Enable param-level quantization for SINQ method
+ self._do_param_level_sinq = self.quantization_config.method == "sinq" and not self.pre_quantized
+
+ sinq_quant_dict = None if self.pre_quantized else self._build_sinq_quant_dict(self.quantization_config)
+
+ # Extract device from device_map (guaranteed to be set by update_device_map)
+ if isinstance(device_map, dict):
+ first_device = next(iter(device_map.values()), 0)
+ if isinstance(first_device, int):
+ device_str = f"cuda:{first_device}"
+ else:
+ device_str = str(first_device)
+ else:
+ device_str = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+ model = replace_with_sinq_linear(
+ model,
+ modules_to_not_convert=self.modules_to_not_convert,
+ quant_config=sinq_quant_dict,
+ compute_dtype=self.dtype,
+ device=device_str,
+ pre_quantized=self.pre_quantized,
+ )
+
+ def _process_model_after_weight_loading(
+ self,
+ model: PreTrainedModel,
+ **kwargs,
+ ):
+ """
+ Called after *all* weights have been loaded.
+
+ For SINQ:
+ 1. Move non-SINQLinear modules to GPU (embeddings, norms, lm_head, etc.)
+ - SINQLinear modules already have GemLite buffers on GPU
+ - We skip moving SINQLinear's W_q/meta to avoid memory duplication
+ 2. Patch HF save/load methods for SINQ serialization
+ """
+ from sinq.hf_io import patch_hf_pretrained_io
+
+ # Patch HF save/load methods for SINQ serialization
+ patch_hf_pretrained_io()
+
+ return model
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_spqr.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_spqr.py
new file mode 100644
index 0000000000000000000000000000000000000000..918b7c6a01b5e2717a600f21c2982088ef4694d3
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_spqr.py
@@ -0,0 +1,81 @@
+# Copyright 2024 The HuggingFace Inc. 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/lic enses/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 .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import SpQRConfig
+
+from ..integrations import replace_with_spqr_linear
+from ..utils import is_accelerate_available, is_spqr_available, is_torch_available, logging
+from ..utils.quantization_config import QuantizationConfigMixin
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+class SpQRHfQuantizer(HfQuantizer):
+ """
+ Quantizer of the SpQR method. Enables the loading of prequantized models.
+ """
+
+ requires_calibration = True
+ quantization_config: "SpQRConfig"
+
+ def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not torch.cuda.is_available():
+ raise RuntimeError("GPU is required to run SpQR quantized model.")
+
+ if not is_accelerate_available():
+ raise ImportError("Using `spqr` quantization requires Accelerate: `pip install accelerate`")
+
+ if not is_spqr_available():
+ raise ImportError("Using `spqr` quantization requires SpQR: `pip install spqr_quant[gpu]`")
+
+ def update_dtype(self, dtype: "torch.dtype") -> "torch.dtype":
+ if dtype != torch.float16:
+ raise ValueError(
+ "You cannot use any type other than torch.float16 for SpQR. Please set it totorch.float16 explicitly."
+ )
+ return dtype
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+ replace_with_spqr_linear(
+ model,
+ quantization_config=self.quantization_config,
+ modules_to_not_convert=self.modules_to_not_convert,
+ )
+
+ @property
+ def is_trainable(self):
+ return False
+
+ def is_serializable(self):
+ return True
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_torchao.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_torchao.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd117b08023b598c334d80c1140707de5717c93c
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_torchao.py
@@ -0,0 +1,196 @@
+# Copyright 2024 The HuggingFace Inc. 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 re
+from typing import TYPE_CHECKING
+
+from .base import HfQuantizer
+from .quantizers_utils import get_module_from_name, should_convert_module
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import TorchAoConfig
+
+from safetensors import safe_open
+
+from ..utils import is_torch_available, is_torchao_available, logging
+
+
+MIN_TORCH_VERSION = "2.5.0"
+
+
+if is_torch_available():
+ from ..core_model_loading import WeightConverter
+
+
+if is_torch_available():
+ import torch
+
+if is_torchao_available():
+ from torchao.prototype.safetensors.safetensors_support import (
+ flatten_tensor_state_dict,
+ )
+
+
+logger = logging.get_logger(__name__)
+
+
+def _fuzzy_match_size(config_name: str) -> str | None:
+ """
+ Extract the size digit from torchao config class names like "Int4WeightOnlyConfig", "Int8WeightOnlyConfig".
+ Returns the digit as a string if found, otherwise None.
+ """
+ match = re.search(r"(\d)weight", config_name.lower())
+ return match.group(1) if match else None
+
+
+class TorchAoHfQuantizer(HfQuantizer):
+ """
+ Quantizer for torchao: https://github.com/pytorch/ao/
+ """
+
+ requires_calibration = False
+ quantization_config: "TorchAoConfig"
+
+ def __init__(self, quantization_config, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ size_digit = _fuzzy_match_size(type(self.quantization_config.quant_type).__name__)
+ self.quantized_param_size = 0.5 if size_digit == "4" else 1
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_torchao_available():
+ raise ImportError("Loading an torchao quantized model requires torchao library (`pip install torchao`)")
+
+ device_map = kwargs.get("device_map")
+ self.offload_to_cpu = False
+ if isinstance(device_map, dict):
+ if ("disk" in device_map.values() or "cpu" in device_map.values()) and len(device_map) > 1:
+ self.offload_to_cpu = "cpu" in device_map.values()
+ if self.pre_quantized and "disk" in device_map.values():
+ raise ValueError(
+ "You are attempting to perform disk offload with a pre-quantized torchao model "
+ "This is not supported yet . Please remove the disk device from the device_map."
+ )
+
+ def get_state_dict_and_metadata(self, model):
+ """
+ We flatten the state dict of tensor subclasses so that it is compatible with the safetensors format.
+ """
+ return flatten_tensor_state_dict(model.state_dict())
+
+ def param_element_size(self, model: "PreTrainedModel", param_name: str, param: "torch.Tensor") -> float:
+ "Return the element size (in bytes) for `param_name`."
+ if self.param_needs_quantization(model, param_name) and self.quantized_param_size is not None:
+ return self.quantized_param_size
+
+ return super().param_element_size(model, param_name, param)
+
+ def adjust_max_memory(self, max_memory: dict[str, int | str]) -> dict[str, int | str]:
+ # need more space for the quantization parameters (e.g. scale). Tested with int4 wo and group size = 128
+ max_memory = {key: val * 0.9 for key, val in max_memory.items()}
+ return max_memory
+
+ def _process_model_before_weight_loading(self, model: "PreTrainedModel", checkpoint_files=None, **kwargs):
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+ if self.quantization_config.include_input_output_embeddings:
+ input_emb = model.get_input_embeddings()
+ input_emb_names = [name for name, module in model.named_modules() if id(module) == id(input_emb)]
+ output_emb = model.get_output_embeddings()
+ output_emb_names = [name for name, module in model.named_modules() if id(module) == id(output_emb)]
+ self.modules_to_not_convert = [
+ x for x in self.modules_to_not_convert if x not in input_emb_names + output_emb_names
+ ]
+ if checkpoint_files is not None:
+ # Torchao needs access to all metadata later
+ self.set_metadata(checkpoint_files)
+
+ def param_needs_quantization(self, model: "PreTrainedModel", param_name: str, **kwargs) -> bool:
+ # check if the param_name is not in self.modules_to_not_convert
+ if not should_convert_module(param_name, self.modules_to_not_convert):
+ return False
+
+ # we only quantize the weight of nn.Linear and nn.Embedding
+ module, tensor_name = get_module_from_name(model, param_name)
+ _QUANTIZABLE = [torch.nn.Linear]
+ if self.quantization_config.include_input_output_embeddings:
+ _QUANTIZABLE.append(torch.nn.Embedding)
+
+ from torchao.quantization import FqnToConfig, fqn_matches_fqn_config
+
+ if isinstance(self.quantization_config.quant_type, FqnToConfig):
+ module_fqn, _ = param_name.rsplit(".", 1)
+ if (
+ fqn_matches_fqn_config(module_fqn, self.quantization_config.quant_type)
+ or fqn_matches_fqn_config(param_name, self.quantization_config.quant_type)
+ or (
+ "_default" in self.quantization_config.quant_type.fqn_to_config
+ and isinstance(module, tuple(_QUANTIZABLE))
+ )
+ ):
+ return True
+
+ return isinstance(module, tuple(_QUANTIZABLE)) and tensor_name == "weight"
+
+ def is_serializable(self) -> bool:
+ return True
+
+ @property
+ def is_trainable(self) -> bool:
+ # Only 8-bit quantization (e.g. Int8WeightOnly, Int8DynamicActivationInt8Weight) supports training
+ return _fuzzy_match_size(type(self.quantization_config.quant_type).__name__) == "8"
+
+ @property
+ def is_compileable(self) -> bool:
+ return True
+
+ def set_metadata(self, checkpoint_files: list[str]):
+ if checkpoint_files[0].endswith(".safetensors"):
+ metadata = {}
+ for checkpoint in checkpoint_files:
+ with safe_open(checkpoint, framework="pt") as f:
+ metadata_ = f.metadata() or {}
+ metadata.update(metadata_)
+ # Save it
+ self.metadata = metadata
+
+ def get_quantize_ops(self):
+ from ..integrations.torchao import TorchAoQuantize
+
+ return TorchAoQuantize(self)
+
+ def get_weight_conversions(self):
+ from ..integrations.torchao import TorchAoDeserialize
+
+ if self.pre_quantized:
+ return [
+ WeightConverter(
+ # TODO: incr flexibility by generalizing the source patterns to match the format of "_weight_"
+ # note that the matching logic is greedy, so for ex, if _weight_scale is before _weight_scale_and_zero in this list, it will match _weight_scale always (this is incorrect)
+ # thus, the order of source_patterns is intentional
+ source_patterns=[
+ "_weight_qdata",
+ "_weight_scale_and_zero",
+ "_weight_per_tensor_scale",
+ "_weight_scale",
+ "_weight_zero_point",
+ "_weight_act_pre_scale",
+ ],
+ target_patterns="weight",
+ operations=[TorchAoDeserialize(self)],
+ ),
+ ]
+ return []
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizer_vptq.py b/lib/python3.11/site-packages/transformers/quantizers/quantizer_vptq.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d60559b09d36e7b401c24fa0bcbfcdc1106a165
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizer_vptq.py
@@ -0,0 +1,75 @@
+# Copyright 2024 The HuggingFace Inc. 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 .base import HfQuantizer
+
+
+if TYPE_CHECKING:
+ from ..modeling_utils import PreTrainedModel
+ from ..utils.quantization_config import VptqConfig
+
+from ..utils import is_accelerate_available, is_torch_available, is_vptq_available, logging
+from ..utils.quantization_config import QuantizationConfigMixin
+
+
+if is_torch_available():
+ import torch
+
+logger = logging.get_logger(__name__)
+
+
+class VptqHfQuantizer(HfQuantizer):
+ """
+ Quantizer of the VPTQ method. Enables the loading of prequantized models.
+ """
+
+ requires_calibration = True
+ quantization_config: "VptqConfig"
+
+ def __init__(self, quantization_config: QuantizationConfigMixin, **kwargs):
+ super().__init__(quantization_config, **kwargs)
+
+ def validate_environment(self, *args, **kwargs):
+ if not is_accelerate_available():
+ raise ImportError("Using `vptq` quantization requires Accelerate: `pip install accelerate`")
+
+ if not is_vptq_available():
+ raise ImportError("Using `vptq` quantization requires VPTQ>=0.0.4: `pip install -U vptq`")
+
+ if not torch.cuda.is_available():
+ raise RuntimeError("GPU is required to run VTPQ quantized model.")
+
+ def _process_model_before_weight_loading(
+ self,
+ model: "PreTrainedModel",
+ **kwargs,
+ ):
+ from ..integrations import replace_with_vptq_linear
+
+ self.modules_to_not_convert = self.get_modules_to_not_convert(
+ model, self.quantization_config.modules_to_not_convert, model._keep_in_fp32_modules
+ )
+ replace_with_vptq_linear(
+ model,
+ quantization_config=self.quantization_config,
+ modules_to_not_convert=self.modules_to_not_convert,
+ )
+
+ @property
+ def is_trainable(self) -> bool:
+ return False
+
+ def is_serializable(self):
+ return True
diff --git a/lib/python3.11/site-packages/transformers/quantizers/quantizers_utils.py b/lib/python3.11/site-packages/transformers/quantizers/quantizers_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e90e238ec4a6ed4a392b170c95d1c6895025a80
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/quantizers/quantizers_utils.py
@@ -0,0 +1,41 @@
+# Copyright 2024 The HuggingFace Inc. 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 re
+from typing import Any
+
+
+def get_module_from_name(module, tensor_name: str) -> tuple[Any, str]:
+ if "." in tensor_name:
+ module_name, tensor_name = tensor_name.rsplit(".", 1)
+ module = module.get_submodule(module_name)
+ return module, tensor_name
+
+
+def should_convert_module(full_name, patterns: list[str] | None = None):
+ if patterns is None:
+ return True
+
+ # We should avoid converting in the following situations:
+ # 1. The pattern appears as a prefix followed by a dot in `full_name`
+ # (e.g., "model.decoder.layer.11." matches "model.decoder.layer.11.attn.weight").
+ # 2. The pattern matches `full_name` exactly or via regex
+ # (e.g., "lm_head" matches "lm_head"; "model.decoder.layer.*" matches "model.decoder.layer.11.attn.weight").
+ # 3. `full_name` ends with the pattern
+ # (e.g., "fc1" matches "model.decoder.layers.23.fc1").
+
+ should_not_convert = any(
+ re.match(f"{key}\\.", full_name) or re.match(f"{key}", full_name) or full_name.endswith(key)
+ for key in patterns
+ )
+ return not should_not_convert
diff --git a/lib/python3.11/site-packages/transformers/utils/__init__.py b/lib/python3.11/site-packages/transformers/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d95eae42f698a58c9b97dc42634efc3fc32f95a
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/__init__.py
@@ -0,0 +1,339 @@
+#!/usr/bin/env python
+
+# Copyright 2021 The HuggingFace Inc. 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 functools import lru_cache
+
+from packaging import version
+
+from .. import __version__
+from .auto_docstring import (
+ ClassAttrs,
+ ClassDocstring,
+ ImageProcessorArgs,
+ ModelArgs,
+ ModelOutputArgs,
+ auto_class_docstring,
+ auto_docstring,
+ get_args_doc_from_source,
+ parse_docstring,
+ set_min_indent,
+)
+from .chat_template_utils import DocstringParsingException, TypeHintParsingException, get_json_schema
+from .constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD
+from .doc import (
+ add_code_sample_docstrings,
+ add_end_docstrings,
+ add_start_docstrings,
+ add_start_docstrings_to_model_forward,
+ copy_func,
+ replace_return_docstrings,
+)
+from .generic import (
+ ContextManagers,
+ ExplicitEnum,
+ ModelOutput,
+ PaddingStrategy,
+ TensorType,
+ TransformersKwargs,
+ _is_tensor_or_array_like,
+ can_return_loss,
+ can_return_tuple,
+ expand_dims,
+ filter_out_non_signature_kwargs,
+ find_labels,
+ flatten_dict,
+ is_numpy_array,
+ is_tensor,
+ is_timm_config_dict,
+ is_timm_local_checkpoint,
+ is_torch_device,
+ is_torch_dtype,
+ is_torch_tensor,
+ reshape,
+ safe_load_json_file,
+ squeeze,
+ strtobool,
+ tensor_size,
+ to_numpy,
+ to_py_obj,
+ torch_float,
+ torch_int,
+ transpose,
+)
+from .hub import (
+ CHAT_TEMPLATE_DIR,
+ CHAT_TEMPLATE_FILE,
+ CLOUDFRONT_DISTRIB_PREFIX,
+ HF_MODULES_CACHE,
+ LEGACY_PROCESSOR_CHAT_TEMPLATE_FILE,
+ S3_BUCKET_PREFIX,
+ TRANSFORMERS_DYNAMIC_MODULE_NAME,
+ EntryNotFoundError,
+ PushInProgress,
+ PushToHubMixin,
+ RepositoryNotFoundError,
+ RevisionNotFoundError,
+ cached_file,
+ define_sagemaker_information,
+ extract_commit_hash,
+ has_file,
+ http_user_agent,
+ list_repo_templates,
+ try_to_load_from_cache,
+)
+from .import_utils import (
+ ACCELERATE_MIN_VERSION,
+ BITSANDBYTES_MIN_VERSION,
+ ENV_VARS_TRUE_AND_AUTO_VALUES,
+ ENV_VARS_TRUE_VALUES,
+ GGUF_MIN_VERSION,
+ TRITON_MIN_VERSION,
+ XLA_FSDPV2_MIN_VERSION,
+ DummyObject,
+ OptionalDependencyNotAvailable,
+ _LazyModule,
+ check_torch_load_is_safe,
+ direct_transformers_import,
+ enable_tf32,
+ get_torch_version,
+ is_accelerate_available,
+ is_apex_available,
+ is_apollo_torch_available,
+ is_aqlm_available,
+ is_auto_round_available,
+ is_av_available,
+ is_bitsandbytes_available,
+ is_bs4_available,
+ is_causal_conv1d_available,
+ is_coloredlogs_available,
+ is_compressed_tensors_available,
+ is_cuda_platform,
+ is_cv2_available,
+ is_cython_available,
+ is_datasets_available,
+ is_decord_available,
+ is_detectron2_available,
+ is_env_variable_false,
+ is_env_variable_true,
+ is_essentia_available,
+ is_faiss_available,
+ is_fbgemm_gpu_available,
+ is_flash_attn_2_available,
+ is_flash_attn_3_available,
+ is_flash_attn_4_available,
+ is_flash_attn_greater_or_equal,
+ is_flash_attn_greater_or_equal_2_10,
+ is_flash_linear_attention_available,
+ is_flute_available,
+ is_fouroversix_available,
+ is_fp_quant_available,
+ is_fsdp_available,
+ is_g2p_en_available,
+ is_galore_torch_available,
+ is_gguf_available,
+ is_gptqmodel_available,
+ is_grokadamw_available,
+ is_grouped_mm_available,
+ is_habana_gaudi1,
+ is_hadamard_available,
+ is_hqq_available,
+ is_huggingface_hub_greater_or_equal,
+ is_in_notebook,
+ is_ipython_available,
+ is_jinja_available,
+ is_jmespath_available,
+ is_jumanpp_available,
+ is_kenlm_available,
+ is_kernels_available,
+ is_levenshtein_available,
+ is_libcst_available,
+ is_librosa_available,
+ is_liger_kernel_available,
+ is_llm_awq_available,
+ is_lomo_available,
+ is_matplotlib_available,
+ is_mistral_common_available,
+ is_mlx_available,
+ is_multipart_available,
+ is_natten_available,
+ is_ninja_available,
+ is_nltk_available,
+ is_num2words_available,
+ is_numba_available,
+ is_onnx_available,
+ is_openai_available,
+ is_optimum_available,
+ is_optimum_quanto_available,
+ is_pandas_available,
+ is_peft_available,
+ is_phonemizer_available,
+ is_pretty_midi_available,
+ is_protobuf_available,
+ is_psutil_available,
+ is_py3nvml_available,
+ is_pyctcdecode_available,
+ is_pytesseract_available,
+ is_pytest_available,
+ is_pytest_order_available,
+ is_pytorch_quantization_available,
+ is_quanto_greater,
+ is_quark_available,
+ is_qutlass_available,
+ is_rich_available,
+ is_rjieba_available,
+ is_rocm_platform,
+ is_sacremoses_available,
+ is_sagemaker_dp_enabled,
+ is_sagemaker_mp_enabled,
+ is_schedulefree_available,
+ is_scipy_available,
+ is_sentencepiece_available,
+ is_seqio_available,
+ is_serve_available,
+ is_sinq_available,
+ is_sklearn_available,
+ is_soundfile_available,
+ is_spacy_available,
+ is_speech_available,
+ is_spqr_available,
+ is_sudachi_available,
+ is_sudachi_projection_available,
+ is_tiktoken_available,
+ is_timm_available,
+ is_tokenizers_available,
+ is_torch_accelerator_available,
+ is_torch_available,
+ is_torch_bf16_available_on_device,
+ is_torch_bf16_gpu_available,
+ is_torch_cuda_available,
+ is_torch_deterministic,
+ is_torch_flex_attn_available,
+ is_torch_fp16_available_on_device,
+ is_torch_fx_proxy,
+ is_torch_greater_or_equal,
+ is_torch_hpu_available,
+ is_torch_mlu_available,
+ is_torch_mps_available,
+ is_torch_musa_available,
+ is_torch_neuron_available,
+ is_torch_neuroncore_available,
+ is_torch_npu_available,
+ is_torch_optimi_available,
+ is_torch_tensorrt_fx_available,
+ is_torch_tf32_available,
+ is_torch_tpu_available,
+ is_torch_xla_available,
+ is_torch_xpu_available,
+ is_torchao_available,
+ is_torchaudio_available,
+ is_torchcodec_available,
+ is_torchdistx_available,
+ is_torchdynamo_compiling,
+ is_torchdynamo_exporting,
+ is_torchvision_available,
+ is_torchvision_v2_available,
+ is_tracing,
+ is_training_run_on_sagemaker,
+ is_triton_available,
+ is_uroman_available,
+ is_vision_available,
+ is_vptq_available,
+ is_xlstm_available,
+ is_yt_dlp_available,
+ requires_backends,
+ torch_compilable_check,
+ torch_only_method,
+)
+from .kernel_config import KernelConfig
+from .peft_utils import (
+ ADAPTER_CONFIG_NAME,
+ ADAPTER_SAFE_WEIGHTS_NAME,
+ ADAPTER_WEIGHTS_NAME,
+ check_peft_version,
+ find_adapter_config_file,
+)
+
+
+WEIGHTS_NAME = "pytorch_model.bin"
+WEIGHTS_INDEX_NAME = "pytorch_model.bin.index.json"
+SAFE_WEIGHTS_NAME = "model.safetensors"
+SAFE_WEIGHTS_INDEX_NAME = "model.safetensors.index.json"
+CONFIG_NAME = "config.json"
+FEATURE_EXTRACTOR_NAME = "preprocessor_config.json"
+IMAGE_PROCESSOR_NAME = "preprocessor_config.json"
+VIDEO_PROCESSOR_NAME = "video_preprocessor_config.json"
+AUDIO_TOKENIZER_NAME = "audio_tokenizer_config.json"
+PROCESSOR_NAME = "processor_config.json"
+GENERATION_CONFIG_NAME = "generation_config.json"
+MODEL_CARD_NAME = "modelcard.json"
+
+
+SENTENCEPIECE_UNDERLINE = "▁"
+SPIECE_UNDERLINE = SENTENCEPIECE_UNDERLINE # Kept for backward compatibility
+
+MULTIPLE_CHOICE_DUMMY_INPUTS = [
+ [[0, 1, 0, 1], [1, 0, 0, 1]]
+] * 2 # Needs to have 0s and 1s only since XLM uses it for langs too.
+DUMMY_INPUTS = [[7, 6, 0, 0, 1], [1, 2, 3, 0, 0], [0, 0, 0, 4, 5]]
+DUMMY_MASK = [[1, 1, 1, 1, 1], [1, 1, 1, 0, 0], [0, 0, 0, 1, 1]]
+
+
+def check_min_version(min_version):
+ if version.parse(__version__) < version.parse(min_version):
+ if "dev" in min_version:
+ error_message = (
+ "This example requires a source install from HuggingFace Transformers (see "
+ "`https://huggingface.co/docs/transformers/installation#install-from-source`),"
+ )
+ else:
+ error_message = f"This example requires a minimum version of {min_version},"
+ error_message += f" but the version found is {__version__}.\n"
+ raise ImportError(
+ error_message
+ + "Check out https://github.com/huggingface/transformers/tree/main/examples#important-note for the examples corresponding to other "
+ "versions of HuggingFace Transformers."
+ )
+
+
+@lru_cache
+def get_available_devices() -> frozenset[str]:
+ """
+ Returns a frozenset of devices available for the current PyTorch installation.
+ """
+ devices = {"cpu"} # `cpu` is always supported as a device in PyTorch
+
+ if is_torch_cuda_available():
+ devices.add("cuda")
+
+ if is_torch_mps_available():
+ devices.add("mps")
+
+ if is_torch_xpu_available():
+ devices.add("xpu")
+
+ if is_torch_npu_available():
+ devices.add("npu")
+
+ if is_torch_hpu_available():
+ devices.add("hpu")
+
+ if is_torch_mlu_available():
+ devices.add("mlu")
+
+ if is_torch_musa_available():
+ devices.add("musa")
+
+ return frozenset(devices)
diff --git a/lib/python3.11/site-packages/transformers/utils/attention_visualizer.py b/lib/python3.11/site-packages/transformers/utils/attention_visualizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f9b9699101269cabdf84d9e79f8c91e10ff772a
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/attention_visualizer.py
@@ -0,0 +1,255 @@
+# Copyright 2025 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.
+import io
+
+import httpx
+from PIL import Image
+
+from ..masking_utils import create_causal_mask
+from ..models.auto.auto_factory import _get_model_class
+from ..models.auto.configuration_auto import AutoConfig
+from ..models.auto.modeling_auto import MODEL_FOR_PRETRAINING_MAPPING, MODEL_MAPPING
+from ..models.auto.processing_auto import PROCESSOR_MAPPING_NAMES, AutoProcessor
+from ..models.auto.tokenization_auto import AutoTokenizer
+from .import_utils import is_torch_available
+
+
+if is_torch_available():
+ import torch
+ import torch.nn as nn
+
+# Print the matrix with words as row labels
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+RESET = "\033[0m"
+BLACK_SQUARE = "■"
+WHITE_SQUARE = "⬚"
+
+
+def generate_attention_matrix_from_mask(
+ words, mask, img_token="<img>", sliding_window=None, token_type_ids=None, image_seq_length=None
+):
+ """
+ Generates an attention matrix from a given attention mask.
+
+ Optionally applies a sliding window mask (e.g., for Gemma2/3) and
+ marks regions where image tokens occur based on the specified `img_token`.
+ """
+ mask = mask.int()
+ if mask.ndim == 3:
+ mask = mask[0, :, :]
+ if mask.ndim == 4:
+ mask = mask[0, 0, :, :]
+
+ n = len(words)
+ max_word_length = max(len(repr(word)) for word in words)
+ first_img_idx = 0
+ output = []
+
+ for i, k in enumerate(words):
+ if k == img_token and not first_img_idx:
+ first_img_idx = i
+ mask[i, i] = 2 # Mark yellow regions
+ if first_img_idx > 0 and (k != img_token or i == n - 1):
+ if i == n - 1:
+ i += 1
+ mask[first_img_idx:i, first_img_idx:i] = 2 # Mark yellow regions
+ first_img_idx = 0
+
+ # Generate sliding window mask (size = 4), excluding img_token
+ sliding_window_mask = None
+ if sliding_window is not None:
+ sliding_window_mask = [[1 if (0 <= i - j < sliding_window) else 0 for j in range(n)] for i in range(n)]
+
+ row_dummy = " ".join(
+ f"{YELLOW}{BLACK_SQUARE}{RESET}"
+ if mask[0, j]
+ else f"{GREEN}{BLACK_SQUARE}{RESET}"
+ if j == 0
+ else BLACK_SQUARE
+ if mask[0, j]
+ else WHITE_SQUARE
+ for j in range(n)
+ )
+
+ if token_type_ids is not None:
+ is_special = token_type_ids == 1
+ token_type_buckets = torch.where(
+ (token_type_ids.cumsum(-1) % 5 + is_special).bool(), token_type_ids.cumsum(-1), 0
+ )
+ boundaries = torch.arange(0, image_seq_length + 1, image_seq_length)
+ token_type_buckets = torch.bucketize(token_type_buckets, boundaries=boundaries)
+
+ # Print headers
+ legend = f"{GREEN}{BLACK_SQUARE}{RESET}: i == j (diagonal) {YELLOW}{BLACK_SQUARE}{RESET}: token_type_ids"
+ output.append(" " + legend)
+ f_string = " " * (max_word_length + 5) + "Attention Matrix".ljust(len(row_dummy) // 2)
+ if sliding_window is not None:
+ f_string += "Sliding Window Mask"
+ output.append(f_string)
+
+ vertical_header = []
+ for idx, word in enumerate(words):
+ if mask[idx, idx] == 2:
+ vertical_header.append([f"{YELLOW}{k}{RESET}" for k in list(str(idx).rjust(len(str(n))))])
+ else:
+ vertical_header.append(list(str(idx).rjust(len(str(n)))))
+
+ vertical_header = list(map(list, zip(*vertical_header))) # Transpose
+
+ for row in vertical_header:
+ output.append(
+ (max_word_length + 5) * " " + " ".join(row) + " | " + " ".join(row)
+ if sliding_window is not None
+ else ""
+ )
+ for i, word in enumerate(words):
+ word_repr = repr(word).ljust(max_word_length)
+ colored_word = f"{YELLOW}{word_repr}{RESET}" if img_token in word else word_repr
+ row_display = " ".join(
+ f"{YELLOW}{BLACK_SQUARE}{RESET}"
+ if img_token in words[j] and mask[i, j] and img_token in word
+ else f"{GREEN}{BLACK_SQUARE}{RESET}"
+ if i == j
+ else BLACK_SQUARE
+ if mask[i, j]
+ else WHITE_SQUARE
+ for j in range(n)
+ )
+ sliding_window_row = ""
+ if sliding_window is not None:
+ sliding_window_row = " ".join(
+ f"{YELLOW}{BLACK_SQUARE}{RESET}"
+ if img_token in words[j] and img_token in word and token_type_buckets[0, i] == token_type_buckets[0, j]
+ else f"{GREEN}{BLACK_SQUARE}{RESET}"
+ if i == j
+ else BLACK_SQUARE
+ if sliding_window_mask[i][j]
+ else WHITE_SQUARE
+ for j in range(n)
+ )
+
+ output.append(f"{colored_word}: {str(i).rjust(2)} {row_display} | {sliding_window_row}")
+
+ return "\n".join(output)
+
+
+class AttentionMaskVisualizer:
+ def __init__(self, model_name: str):
+ config = AutoConfig.from_pretrained(model_name)
+ self.image_token = "<img>"
+ if hasattr(config.get_text_config(), "sliding_window"):
+ self.sliding_window = getattr(config.get_text_config(), "sliding_window", None)
+ try:
+ mapped_cls = _get_model_class(config, MODEL_MAPPING)
+ except Exception:
+ mapped_cls = _get_model_class(config, MODEL_FOR_PRETRAINING_MAPPING)
+
+ if mapped_cls is None:
+ raise ValueError(f"Model name {model_name} is not supported for attention visualization")
+ self.mapped_cls = mapped_cls
+
+ class _ModelWrapper(mapped_cls, nn.Module):
+ def __init__(self, config, model_name):
+ nn.Module.__init__(self)
+ self.dummy_module = nn.Linear(1, 1)
+ self.config = config
+
+ self.model = _ModelWrapper(config, model_name)
+ self.model.to(config.dtype)
+ self.repo_id = model_name
+ self.config = config
+
+ def __call__(self, input_sentence: str, suffix=""):
+ self.visualize_attention_mask(input_sentence, suffix=suffix)
+
+ def visualize_attention_mask(self, input_sentence: str, suffix=""):
+ model = self.model
+ kwargs = {}
+ image_seq_length = None
+ if self.config.model_type in PROCESSOR_MAPPING_NAMES:
+ img = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg?download=true"
+ img = Image.open(io.BytesIO(httpx.get(img, follow_redirects=True).content))
+ image_seq_length = 5
+ processor = AutoProcessor.from_pretrained(self.repo_id, image_seq_length=image_seq_length)
+ if hasattr(processor, "image_token"):
+ image_token = processor.image_token
+ else:
+ image_token = processor.tokenizer.convert_ids_to_tokens([processor.image_token_id])[0]
+
+ if image_token:
+ input_sentence = input_sentence.replace("<img>", image_token)
+
+ inputs = processor(images=img, text=input_sentence, suffix=suffix, return_tensors="pt")
+
+ self.image_token = processor.tokenizer.convert_ids_to_tokens([processor.image_token_id])[0]
+
+ attention_mask = inputs["attention_mask"]
+ if "token_type_ids" in inputs: # TODO inspect signature of update causal mask
+ kwargs["token_type_ids"] = inputs["token_type_ids"]
+ tokens = processor.tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
+ else:
+ tokenizer = AutoTokenizer.from_pretrained(self.repo_id)
+ if tokenizer is None:
+ raise ValueError(f"Could not load tokenizer for {self.repo_id}")
+ tokens = tokenizer.tokenize(input_sentence)
+ attention_mask = tokenizer(input_sentence, return_tensors="pt")["attention_mask"]
+ if attention_mask is None:
+ raise ValueError(f"Model type {self.config.model_type} does not support attention visualization")
+
+ model.config._attn_implementation = "eager"
+ model.train()
+
+ batch_size, seq_length = attention_mask.shape
+ inputs_embeds = torch.zeros((batch_size, seq_length, model.config.hidden_size), dtype=self.model.dtype)
+
+ causal_mask = create_causal_mask(
+ config=model.config,
+ inputs_embeds=inputs_embeds,
+ attention_mask=attention_mask,
+ past_key_values=None,
+ )
+
+ if causal_mask is None:
+ # attention_mask must be a tensor here
+ attention_mask = attention_mask.unsqueeze(1).unsqueeze(1).expand(batch_size, 1, seq_length, seq_length)
+ elif isinstance(causal_mask, torch.Tensor):
+ attention_mask = ~causal_mask.to(dtype=torch.bool)
+ else:
+ attention_mask = ~causal_mask
+
+ top_bottom_border = "##" * (
+ len(f"Attention visualization for {self.config.model_type} | {self.mapped_cls}") + 4
+ ) # Box width adjusted to text length
+ side_border = "##"
+ print(f"\n{top_bottom_border}")
+ print(
+ "##"
+ + f" Attention visualization for \033[1m{self.config.model_type}:{self.repo_id}\033[0m {self.mapped_cls.__name__}".center(
+ len(top_bottom_border)
+ )
+ + " "
+ + side_border,
+ )
+ print(f"{top_bottom_border}")
+ f_string = generate_attention_matrix_from_mask(
+ tokens,
+ attention_mask,
+ img_token=self.image_token,
+ sliding_window=getattr(self.config, "sliding_window", None),
+ token_type_ids=kwargs.get("token_type_ids"),
+ image_seq_length=image_seq_length,
+ )
+ print(f_string)
+ print(f"{top_bottom_border}")
diff --git a/lib/python3.11/site-packages/transformers/utils/auto_docstring.py b/lib/python3.11/site-packages/transformers/utils/auto_docstring.py
new file mode 100644
index 0000000000000000000000000000000000000000..419579891e35530a2bface37fe7f7ecfedad1e91
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/auto_docstring.py
@@ -0,0 +1,4515 @@
+# Copyright 2025 HuggingFace Inc. 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 __future__ import annotations
+
+import inspect
+import os
+from collections.abc import Mapping
+from functools import lru_cache
+from pathlib import Path
+from types import UnionType
+from typing import ClassVar, Union, get_args, get_origin
+
+import regex as re
+import typing_extensions
+
+from .doc import (
+ MODELS_TO_PIPELINE,
+ PIPELINE_TASKS_TO_SAMPLE_DOCSTRINGS,
+ PT_SAMPLE_DOCSTRINGS,
+)
+from .generic import ModelOutput
+
+
+PATH_TO_TRANSFORMERS = Path("src").resolve() / "transformers"
+
+
+AUTODOC_FILES = [
+ "configuration_*.py",
+ "modeling_*.py",
+ "tokenization_*.py",
+ "processing_*.py",
+ "image_processing_pil_*.py",
+ "image_processing_*.py",
+ "feature_extractor_*.py",
+]
+
+PLACEHOLDER_TO_AUTO_MODULE = {
+ "image_processor_class": ("image_processing_auto", "IMAGE_PROCESSOR_MAPPING_NAMES"),
+ "tokenizer_class": ("tokenization_auto", "TOKENIZER_MAPPING_NAMES"),
+ "video_processor_class": ("video_processing_auto", "VIDEO_PROCESSOR_MAPPING_NAMES"),
+ "feature_extractor_class": ("feature_extraction_auto", "FEATURE_EXTRACTOR_MAPPING_NAMES"),
+ "processor_class": ("processing_auto", "PROCESSOR_MAPPING_NAMES"),
+ "config_class": ("configuration_auto", "CONFIG_MAPPING_NAMES"),
+ "model_class": ("modeling_auto", "MODEL_MAPPING_NAMES"),
+}
+
+UNROLL_KWARGS_METHODS = {
+ "preprocess",
+ "__call__",
+}
+
+UNROLL_KWARGS_CLASSES = {
+ "BaseImageProcessor",
+ "ProcessorMixin",
+}
+BASIC_KWARGS_TYPES = ["TextKwargs", "ImagesKwargs", "VideosKwargs", "AudioKwargs"]
+
+# Short indicator added to unrolled kwargs to distinguish them from regular args
+KWARGS_INDICATOR = ", *kwargs*"
+
+HARDCODED_CONFIG_FOR_MODELS = {
+ "openai": "OpenAIGPTConfig",
+ "x-clip": "XCLIPConfig",
+ "kosmos2": "Kosmos2Config",
+ "kosmos2-5": "Kosmos2_5Config",
+ "donut": "DonutSwinConfig",
+ "esmfold": "EsmConfig",
+ "parakeet": "ParakeetCTCConfig",
+ "privacy-filter": "OpenAIPrivacyFilterConfig",
+ "lasr": "LasrCTCConfig",
+ "wav2vec2-with-lm": "Wav2Vec2Config",
+}
+
+_re_checkpoint = re.compile(r"\[(.+?)\]\((https://huggingface\.co/.+?)\)")
+
+# Pre-compiled patterns used repeatedly at runtime. Compiling once here avoids
+# repeated compilation overhead (and cache lookups) on every decorator call.
+_re_example_or_return = re.compile(r"(?m)^([ \t]*)(?=Example|Return|```)")
+_re_return = re.compile(r"(?m)^([ \t]*)(?=Return)")
+_re_example = re.compile(r"(?m)^([ \t]*)(?=Example|```)")
+_re_args_section = re.compile(r"(?:Args:)(\n.*)?(\n)?$", re.DOTALL)
+_re_shape = re.compile(r"(of shape\s*(?:`.*?`|\(.*?\)))")
+_re_default = re.compile(r"(defaults to \s*[^)]*)")
+_re_param = re.compile(
+ r"^\s{0,0}(\w+)\s*\(\s*([^, \)]*)(\s*.*?)\s*\)\s*:\s*((?:(?!\n^\s{0,0}\w+\s*\().)*)",
+ re.DOTALL | re.MULTILINE,
+)
+_re_forward_ref = re.compile(r"ForwardRef\('([\w.]+)'\)")
+_re_optional = re.compile(r"Optional\[(.*?)\]")
+_re_placeholders = re.compile(r"{(.*?)}")
+_re_model_task = None # built lazily because PT_SAMPLE_DOCSTRINGS isn't available yet
+
+
+class ImageProcessorArgs:
+ images = {
+ "description": """
+ Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If
+ passing in images with pixel values between 0 and 1, set `do_rescale=False`.
+ """,
+ "shape": None,
+ }
+
+ videos = {
+ "description": """
+ Video to preprocess. Expects a single or batch of videos with pixel values ranging from 0 to 255. If
+ passing in videos with pixel values between 0 and 1, set `do_rescale=False`.
+ """,
+ "shape": None,
+ }
+
+ do_resize = {
+ "description": """
+ Whether to resize the image.
+ """,
+ "shape": None,
+ }
+
+ size = {
+ "description": """
+ Describes the maximum input dimensions to the model.
+ """,
+ "shape": None,
+ }
+
+ size_divisor = {
+ "description": """
+ The size by which to make sure both the height and width can be divided.
+ """,
+ "shape": None,
+ }
+
+ default_to_square = {
+ "description": """
+ Whether to default to a square image when resizing, if size is an int.
+ """,
+ "shape": None,
+ }
+
+ resample = {
+ "description": """
+ Resampling filter to use if resizing the image. This can be one of the enum `PILImageResampling`. Only
+ has an effect if `do_resize` is set to `True`.
+ """,
+ "shape": None,
+ }
+
+ do_center_crop = {
+ "description": """
+ Whether to center crop the image.
+ """,
+ "shape": None,
+ }
+
+ crop_size = {
+ "description": """
+ Size of the output image after applying `center_crop`.
+ """,
+ "shape": None,
+ }
+
+ do_pad = {
+ "description": """
+ Whether to pad the image. Padding is done either to the largest size in the batch
+ or to a fixed square size per image. The exact padding strategy depends on the model.
+ """,
+ "shape": None,
+ }
+
+ pad_size = {
+ "description": """
+ The size in `{"height": int, "width" int}` to pad the images to. Must be larger than any image size
+ provided for preprocessing. If `pad_size` is not provided, images will be padded to the largest
+ height and width in the batch. Applied only when `do_pad=True.`
+ """,
+ "shape": None,
+ }
+
+ do_rescale = {
+ "description": """
+ Whether to rescale the image.
+ """,
+ "shape": None,
+ }
+
+ rescale_factor = {
+ "description": """
+ Rescale factor to rescale the image by if `do_rescale` is set to `True`.
+ """,
+ "shape": None,
+ }
+
+ do_normalize = {
+ "description": """
+ Whether to normalize the image.
+ """,
+ "shape": None,
+ }
+
+ image_mean = {
+ "description": """
+ Image mean to use for normalization. Only has an effect if `do_normalize` is set to `True`.
+ """,
+ "shape": None,
+ }
+
+ image_std = {
+ "description": """
+ Image standard deviation to use for normalization. Only has an effect if `do_normalize` is set to
+ `True`.
+ """,
+ "shape": None,
+ }
+
+ do_convert_rgb = {
+ "description": """
+ Whether to convert the image to RGB.
+ """,
+ "shape": None,
+ }
+
+ return_tensors = {
+ "description": """
+ Returns stacked tensors if set to `'pt'`, otherwise returns a list of tensors.
+ """,
+ "shape": None,
+ }
+
+ data_format = {
+ "description": """
+ Only `ChannelDimension.FIRST` is supported. Added for compatibility with slow processors.
+ """,
+ "shape": None,
+ }
+
+ input_data_format = {
+ "description": """
+ The channel dimension format for the input image. If unset, the channel dimension format is inferred
+ from the input image. Can be one of:
+ - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
+ - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
+ - `"none"` or `ChannelDimension.NONE`: image in (height, width) format.
+ """,
+ "shape": None,
+ }
+
+ device = {
+ "description": """
+ The device to process the images on. If unset, the device is inferred from the input images.
+ """,
+ "shape": None,
+ }
+
+ disable_grouping = {
+ "description": """
+ Whether to disable grouping of images by size to process them individually and not in batches.
+ If None, will be set to True if the images are on CPU, and False otherwise. This choice is based on
+ empirical observations, as detailed here: https://github.com/huggingface/transformers/pull/38157
+ """,
+ "shape": None,
+ }
+
+ image_seq_length = {
+ "description": """
+ The number of image tokens to be used for each image in the input.
+ Added for backward compatibility but this should be set as a processor attribute in future models.
+ """,
+ "shape": None,
+ }
+
+ # Used for the **kwargs summary line when unrolling typed kwargs (key: "__kwargs__")
+ __kwargs__ = {
+ "description": """
+ Additional image preprocessing options. Model-specific kwargs are listed above; see the TypedDict class
+ for the complete list of supported arguments.
+ """,
+ "shape": None,
+ }
+
+
+class ProcessorArgs:
+ # __init__ arguments
+ image_processor = {
+ "description": """
+ The image processor is a required input.
+ """,
+ "type": "{image_processor_class}",
+ }
+
+ tokenizer = {
+ "description": """
+ The tokenizer is a required input.
+ """,
+ "type": "{tokenizer_class}",
+ }
+
+ video_processor = {
+ "description": """
+ The video processor is a required input.
+ """,
+ "type": "{video_processor_class}",
+ }
+
+ audio_processor = {
+ "description": """
+ The audio processor is a required input.
+ """,
+ "type": "{audio_processor_class}",
+ }
+
+ feature_extractor = {
+ "description": """
+ The feature extractor is a required input.
+ """,
+ "type": "{feature_extractor_class}",
+ }
+
+ chat_template = {
+ "description": """
+ A Jinja template to convert lists of messages in a chat into a tokenizable string.
+ """,
+ "type": "str",
+ }
+
+ # __call__ arguments
+ text = {
+ "description": """
+ The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings
+ (pretokenized string). If you pass a pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs.
+ """,
+ }
+
+ audio = {
+ "description": """
+ The audio or batch of audios to be prepared. Each audio can be a NumPy array or PyTorch tensor.
+ In case of a NumPy array/PyTorch tensor, each audio should be of shape (C, T), where C is a number of channels,
+ and T is the sample length of the audio.
+ """,
+ }
+
+ audios = {
+ "description": """
+ The audio or batch of audios to be prepared. Each audio can be a NumPy array or PyTorch tensor.
+ In case of a NumPy array/PyTorch tensor, each audio should be of shape (C, T), where C is a number of channels,
+ and T is the sample length of the audio.
+ """,
+ }
+
+ return_tensors = {
+ "description": """
+ If set, will return tensors of a particular framework. Acceptable values are:
+
+ - `'pt'`: Return PyTorch `torch.Tensor` objects.
+ - `'np'`: Return NumPy `np.ndarray` objects.
+ """,
+ "shape": None,
+ }
+
+ # Standard tokenizer arguments
+ add_special_tokens = {
+ "description": """
+ Whether or not to add special tokens when encoding the sequences. This will use the underlying
+ [`PretrainedTokenizerBase.build_inputs_with_special_tokens`] function, which defines which tokens are
+ automatically added to the input ids. This is useful if you want to add `bos` or `eos` tokens
+ automatically.
+ """,
+ "type": "bool",
+ }
+
+ padding = {
+ "description": """
+ Activates and controls padding. Accepts the following values:
+
+ - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+ sequence is provided).
+ - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
+ acceptable input length for the model if that argument is not provided.
+ - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
+ lengths).
+ """,
+ "type": "bool, str or [`~utils.PaddingStrategy`]",
+ }
+
+ truncation = {
+ "description": """
+ Activates and controls truncation. Accepts the following values:
+
+ - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or
+ to the maximum acceptable input length for the model if that argument is not provided. This will
+ truncate token by token, removing a token from the longest sequence in the pair if a pair of
+ sequences (or a batch of pairs) is provided.
+ - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the
+ maximum acceptable input length for the model if that argument is not provided. This will only
+ truncate the first sequence of a pair if a pair of sequences (or a batch of pairs) is provided.
+ - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the
+ maximum acceptable input length for the model if that argument is not provided. This will only
+ truncate the second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.
+ - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths
+ greater than the model maximum admissible input size).
+ """,
+ "type": "bool, str or [`~tokenization_utils_base.TruncationStrategy`]",
+ }
+
+ max_length = {
+ "description": """
+ Controls the maximum length to use by one of the truncation/padding parameters.
+
+ If left unset or set to `None`, this will use the predefined model maximum length if a maximum length
+ is required by one of the truncation/padding parameters. If the model has no specific maximum input
+ length (like XLNet) truncation/padding to a maximum length will be deactivated.
+ """,
+ "type": "int",
+ }
+
+ stride = {
+ "description": """
+ If set to a number along with `max_length`, the overflowing tokens returned when
+ `return_overflowing_tokens=True` will contain some tokens from the end of the truncated sequence
+ returned to provide some overlap between truncated and overflowing sequences. The value of this
+ argument defines the number of overlapping tokens.
+ """,
+ "type": "int",
+ }
+
+ pad_to_multiple_of = {
+ "description": """
+ If set will pad the sequence to a multiple of the provided value. Requires `padding` to be activated.
+ This is especially useful to enable using Tensor Cores on NVIDIA hardware with compute capability
+ `>= 7.5` (Volta).
+ """,
+ "type": "int",
+ }
+
+ return_token_type_ids = {
+ "description": """
+ Whether to return token type IDs. If left to the default, will return the token type IDs according to
+ the specific tokenizer's default, defined by the `return_outputs` attribute.
+
+ [What are token type IDs?](../glossary#token-type-ids)
+ """,
+ "type": "bool",
+ }
+
+ return_attention_mask = {
+ "description": """
+ Whether to return the attention mask. If left to the default, will return the attention mask according
+ to the specific tokenizer's default, defined by the `return_outputs` attribute.
+
+ [What are attention masks?](../glossary#attention-mask)
+ """,
+ "type": "bool",
+ }
+
+ return_overflowing_tokens = {
+ "description": """
+ Whether or not to return overflowing token sequences. If a pair of sequences of input ids (or a batch
+ of pairs) is provided with `truncation_strategy = longest_first` or `True`, an error is raised instead
+ of returning overflowing tokens.
+ """,
+ "type": "bool",
+ }
+
+ return_special_tokens_mask = {
+ "description": """
+ Whether or not to return special tokens mask information.
+ """,
+ "type": "bool",
+ }
+
+ return_offsets_mapping = {
+ "description": """
+ Whether or not to return `(char_start, char_end)` for each token.
+
+ This is only available on fast tokenizers inheriting from [`PreTrainedTokenizerFast`], if using
+ Python's tokenizer, this method will raise `NotImplementedError`.
+ """,
+ "type": "bool",
+ }
+
+ return_length = {
+ "description": """
+ Whether or not to return the lengths of the encoded inputs.
+ """,
+ "type": "bool",
+ }
+
+ verbose = {
+ "description": """
+ Whether or not to print more information and warnings.
+ """,
+ "type": "bool",
+ }
+
+ text_pair = {
+ "description": """
+ Optional second sequence to be encoded. This can be a string, a list of strings (tokenized string using
+ the `tokenize` method) or a list of integers (tokenized string ids using the `convert_tokens_to_ids`
+ method).
+ """,
+ "type": "str, list[str] or list[int]",
+ }
+
+ text_target = {
+ "description": """
+ The sequence or batch of sequences to be encoded as target texts. Each sequence can be a string or a
+ list of strings (pretokenized string). If you pass pretokenized input, set `is_split_into_words=True`
+ to avoid ambiguity with batched inputs.
+ """,
+ "type": "str, list[str] or list[list[str]]",
+ }
+
+ text_pair_target = {
+ "description": """
+ The sequence or batch of sequences to be encoded as target texts. Each sequence can be a string or a
+ list of strings (pretokenized string). If you pass pretokenized input, set `is_split_into_words=True`
+ to avoid ambiguity with batched inputs.
+ """,
+ "type": "str, list[str] or list[list[str]]",
+ }
+
+ is_split_into_words = {
+ "description": """
+ Whether or not the input is already pre-tokenized (e.g., split into words). If set to `True`, the
+ tokenizer assumes the input is already split into words (for instance, by splitting it on whitespace)
+ which it will tokenize. This is useful for NER or token classification.
+ """,
+ "type": "bool",
+ }
+
+ boxes = {
+ "description": """
+ Word-level bounding boxes. Each bounding box should be normalized to be on a 0-1000 scale.
+ """,
+ "type": "list[list[int]] or list[list[list[int]]]",
+ }
+
+ word_labels = {
+ "description": """
+ Word-level integer labels (for token classification tasks such as FUNSD, CORD).
+ """,
+ "type": "list[int] or list[list[int]]",
+ }
+
+ # Used for the **kwargs summary line when unrolling typed kwargs (key: "__kwargs__")
+ __kwargs__ = {
+ "description": """
+ Additional processing options for each modality (text, images, videos, audio). Model-specific parameters
+ are listed above; see the TypedDict class for the complete list of supported arguments.
+ """,
+ "shape": None,
+ }
+
+
+class ConfigArgs:
+ output_hidden_states = {
+ "description": """
+ Whether or not the model should return all hidden-states.
+ """,
+ }
+
+ chunk_size_feed_forward = {
+ "description": """
+ The `dtype` of the weights. This attribute can be used to initialize the model to a non-default `dtype`
+ (which is normally `float32`) and thus allow for optimal storage allocation. For example, if the saved
+ model is `float16`, ideally we want to load it back using the minimal amount of memory needed to load
+ `float16` weights.
+ """,
+ }
+
+ dtype = {
+ "description": """
+ The chunk size of all feed forward layers in the residual attention blocks. A chunk size of `0` means that
+ the feed forward layer is not chunked. A chunk size of n means that the feed forward layer processes `n` <
+ sequence_length embeddings at a time. For more information on feed forward chunking, see [How does Feed
+ Forward Chunking work?](../glossary.html#feed-forward-chunking).
+ """,
+ }
+
+ id2label = {
+ "description": """
+ A map from index (for instance prediction index, or target index) to label.
+ """,
+ }
+
+ label2id = {
+ "description": """
+ A map from label to index for the model.
+ """,
+ }
+
+ problem_type = {
+ "description": """
+ Problem type for `XxxForSequenceClassification` models. Can be one of `"regression"`,
+ `"single_label_classification"` or `"multi_label_classification"`.
+ """,
+ }
+
+ tokenizer_class = {
+ "description": """
+ The class name of model's tokenizer.
+ """,
+ }
+
+ vocab_size = {
+ "description": """
+ Vocabulary size of the model. Defines the number of different tokens that can be represented by the `input_ids`.
+ """,
+ }
+
+ hidden_size = {
+ "description": """
+ Dimension of the hidden representations.
+ """,
+ }
+
+ intermediate_size = {
+ "description": """
+ Dimension of the MLP representations.
+ """,
+ }
+
+ head_dim = {
+ "description": """
+ The attention head dimension. If None, it will default to hidden_size // num_attention_heads
+ """
+ }
+
+ num_hidden_layers = {
+ "description": """
+ Number of hidden layers in the Transformer decoder.
+ """,
+ }
+
+ num_attention_heads = {
+ "description": """
+ Number of attention heads for each attention layer in the Transformer decoder.
+ """,
+ }
+
+ num_key_value_heads = {
+ "description": """
+ This is the number of key_value heads that should be used to implement Grouped Query Attention. If
+ `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if
+ `num_key_value_heads=1` the model will use Multi Query Attention (MQA) otherwise GQA is used. When
+ converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed
+ by meanpooling all the original heads within that group. For more details, check out [this
+ paper](https://huggingface.co/papers/2305.13245). If it is not specified, will default to
+ `num_attention_heads`.
+ """,
+ }
+ hidden_act = {
+ "description": """
+ The non-linear activation function (function or string) in the decoder. For example, `"gelu"`,
+ `"relu"`, `"silu"`, etc.
+ """,
+ }
+
+ max_position_embeddings = {
+ "description": """
+ The maximum sequence length that this model might ever be used with.
+ """,
+ }
+
+ initializer_range = {
+ "description": """
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+ """,
+ }
+
+ rms_norm_eps = {
+ "description": """
+ The epsilon used by the rms normalization layers.
+ """,
+ }
+
+ use_cache = {
+ "description": """
+ Whether or not the model should return the last key/values attentions (not used by all models). Only
+ relevant if `config.is_decoder=True` or when the model is a decoder-only generative model.
+ """,
+ }
+
+ rope_parameters = {
+ "description": """
+ Dictionary containing the configuration parameters for the RoPE embeddings. The dictionary should contain
+ a value for `rope_theta` and optionally parameters used for scaling in case you want to use RoPE
+ with longer `max_position_embeddings`.
+ """,
+ }
+
+ attention_bias = {
+ "description": """
+ Whether to use a bias in the query, key, value and output projection layers during self-attention.
+ """,
+ }
+
+ mlp_bias = {
+ "description": """
+ Whether to use a bias in up_proj, down_proj and gate_proj layers in the MLP layers.
+ """,
+ }
+
+ attention_dropout = {
+ "description": """
+ The dropout ratio for the attention probabilities.
+ """,
+ }
+
+ pretraining_tp = {
+ "description": """
+ Experimental feature. Tensor parallelism rank used during pretraining. Please refer to [this
+ document](https://huggingface.co/docs/transformers/main/perf_train_gpu_many#tensor-parallelism) to
+ understand more about it. This value is necessary to ensure exact reproducibility of the pretraining
+ results. Please refer to [this issue](https://github.com/pytorch/pytorch/issues/76232).
+ """,
+ }
+
+ pad_token_id = {
+ "description": """
+ Token id used for padding in the vocabulary.
+ """,
+ }
+
+ eos_token_id = {
+ "description": """
+ Token id used for end-of-stream in the vocabulary.
+ """,
+ }
+
+ bos_token_id = {
+ "description": """
+ Token id used for beginning-of-stream in the vocabulary.
+ """,
+ }
+
+ sep_token_id = {
+ "description": """
+ Token id used for separator in the vocabulary.
+ """,
+ }
+
+ cls_token_id = {
+ "description": """
+ Token id used for CLS in the vocabulary.
+ """,
+ }
+
+ tie_word_embeddings = {
+ "description": """
+ Whether to tie weight embeddings according to model's `tied_weights_keys` mapping.
+ """,
+ }
+
+ d_model = {
+ "description": """
+ Size of the encoder layers and the pooler layer.
+ """,
+ }
+
+ d_kv = {
+ "description": """
+ Size of the key, query, value projections per attention head. The `inner_dim` of the projection layer will
+ be defined as `num_heads * d_kv`.
+ """,
+ }
+
+ num_decoder_layers = {
+ "description": """
+ Number of hidden layers in the Transformer decoder. Will use the same value as `num_layers` if not set.
+ """,
+ }
+
+ num_encoder_layers = {
+ "description": """
+ Number of hidden layers in the Transformer encoder. Will use the same value as `num_layers` if not set.
+ """,
+ }
+
+ dropout_rate = {
+ "description": """
+ The ratio for all dropout layers.
+ """,
+ }
+
+ classifier_dropout = {
+ "description": """
+ The dropout ratio for classifier.
+ """,
+ }
+
+ layer_norm_eps = {
+ "description": """
+ The epsilon used by the layer normalization layers.
+ """,
+ }
+
+ initializer_factor = {
+ "description": """
+ A factor for initializing all weight matrices (should be kept to 1, used internally for initialization
+ testing).
+ """,
+ }
+
+ encoder_attention_heads = {
+ "description": """
+ Number of attention heads for each attention layer in the Transformer encoder.
+ """,
+ }
+
+ decoder_attention_heads = {
+ "description": """
+ Number of attention heads for each attention layer in the Transformer decoder.
+ """,
+ }
+
+ decoder_ffn_dim = {
+ "description": """
+ Dimensionality of the "intermediate" (often named feed-forward) layer in decoder.
+ """,
+ }
+
+ encoder_ffn_dim = {
+ "description": """
+ Dimensionality of the "intermediate" (often named feed-forward) layer in encoder.
+ """,
+ }
+
+ activation_dropout = {
+ "description": """
+ The dropout ratio for activations inside the fully connected layer.
+ """,
+ }
+
+ encoder_layerdrop = {
+ "description": """
+ The LayerDrop probability for the encoder. See the [LayerDrop paper](see https://huggingface.co/papers/1909.11556)
+ for more details.
+ """,
+ }
+
+ decoder_layerdrop = {
+ "description": """
+ The LayerDrop probability for the decoder. See the [LayerDrop paper](see https://huggingface.co/papers/1909.11556)
+ for more details.
+ """,
+ }
+
+ scale_embedding = {
+ "description": """
+ Whether to scale embeddings by dividing by sqrt(d_model).
+ """,
+ }
+
+ forced_eos_token_id = {
+ "description": """
+ The id of the token to force as the last generated token when `max_length` is reached. Usually set to
+ `eos_token_id`.
+ """,
+ }
+
+ moe_intermediate_size = {
+ "description": """
+ Intermediate size of the routed expert MLPs.
+ """,
+ }
+
+ num_experts = {
+ "description": """
+ Number of routed experts in MoE layers.
+
+ """,
+ }
+
+ num_experts_per_tok = {
+ "description": """
+ Number of experts to route each token to. This is the top-k value for the token-choice routing.
+ """,
+ }
+
+ num_shared_experts = {
+ "description": """
+ Number of shared experts that are always activated for all tokens.
+ """,
+ }
+
+ layer_types = {
+ "description": """
+ A list that explicitly maps each layer index with its layer type. If not provided, it will be automatically
+ generated based on config values.
+ """,
+ }
+
+ norm_topk_prob = {
+ "description": """
+ Whether to normalize the weights of the routed experts.
+
+ """,
+ }
+
+ topk_group = {
+ "description": """
+ Number of selected groups for each token (for each token, ensuring the selected experts is only within `topk_group` groups).
+ """,
+ }
+
+ qk_rope_head_dim = {
+ "description": """
+ Dimension of the query/key heads that use rotary position embeddings.
+ """,
+ }
+
+ v_head_dim = {
+ "description": """
+ Dimension of the value heads.
+ """,
+ }
+
+ qk_nope_head_dim = {
+ "description": """
+ Dimension of the query/key heads that don't use rotary position embeddings.
+ """,
+ }
+
+ kv_lora_rank = {
+ "description": """
+ Rank of the LoRA matrices for key and value projections.
+ """,
+ }
+
+ q_lora_rank = {
+ "description": """
+ Rank of the LoRA matrices for query projections.
+ """,
+ }
+
+ routed_scaling_factor = {
+ "description": """
+ Scaling factor or routed experts.
+ """,
+ }
+
+ n_routed_experts = {
+ "description": """
+ Number of routed experts.
+ """,
+ }
+
+ n_shared_experts = {
+ "description": """
+ Number of shared experts.
+ """,
+ }
+
+ vision_config = {
+ "description": """
+ The config object or dictionary of the vision backbone.
+ """,
+ }
+
+ text_config = {
+ "description": """
+ The config object or dictionary of the text backbone.
+ """,
+ }
+
+ projector_hidden_act = {
+ "description": """
+ The activation function used by the multimodal projector.
+ """,
+ }
+
+ vision_feature_select_strategy = {
+ "description": """
+ The feature selection strategy used to select the vision feature from the vision backbone.
+ """,
+ }
+
+ vision_feature_layer = {
+ "description": """
+ The index of the layer to select the vision feature. If multiple indices are provided,
+ the vision feature of the corresponding indices will be concatenated to form the
+ vision features.
+ """,
+ }
+
+ multimodal_projector_bias = {
+ "description": """
+ Whether to use bias in the multimodal projector.
+ """,
+ }
+
+ image_token_id = {
+ "description": """
+ The image token index used as a placeholder for input images.
+ """,
+ }
+
+ video_token_id = {
+ "description": """
+ The video token index used as a placeholder for input videos.
+ """,
+ }
+
+ audio_token_id = {
+ "description": """
+ The audio token index used as a placeholder for input audio.
+ """,
+ }
+
+ image_seq_length = {
+ "description": """
+ Sequence length of one image embedding.
+ """,
+ }
+
+ video_seq_length = {
+ "description": """
+ Sequence length of one video embedding.
+ """,
+ }
+
+ add_cross_attention = {
+ "description": """
+ Whether cross-attention layers should be added to the model.
+ """,
+ }
+
+ is_decoder = {
+ "description": """
+ Whether the model is used as a decoder or not. If `False`, the model is used as an encoder.
+ """,
+ }
+
+ sliding_window = {
+ "description": """
+ Sliding window attention window size. If `None`, no sliding window is applied.
+ """,
+ }
+
+ use_sliding_window = {
+ "description": """
+ Whether to use sliding window attention.
+ """,
+ }
+
+ shared_expert_intermediate_size = {
+ "description": """
+ Intermediate size of the shared expert MLPs.
+ """,
+ }
+
+ decoder_sparse_step = {
+ "description": """
+ The frequency of adding a sparse MoE layer. The default is 1, which means all decoder layers are sparse MoE.
+ """,
+ }
+
+ output_router_logits = {
+ "description": """
+ Whether or not the router logits should be returned by the model. Enabling this will also allow the model
+ to output the auxiliary loss, including load balancing loss and router z-loss.
+ """,
+ }
+
+ router_aux_loss_coef = {
+ "description": """
+ Auxiliary load balancing loss coefficient. Used to penalize uneven expert routing in MoE models.
+ """,
+ }
+
+ out_indices = {
+ "description": """
+ Indices of the intermediate hidden states (feature maps) to return from the backbone. Each index
+ corresponds to one stage of the model.
+ """,
+ }
+
+ out_features = {
+ "description": """
+ Names of the intermediate hidden states (feature maps) to return from the backbone. One of `"stem"`,
+ `"stage1"`, `"stage2"`, etc.
+ """,
+ }
+
+ image_size = {
+ "description": """
+ The size (resolution) of each image.
+ """,
+ }
+
+ patch_size = {
+ "description": """
+ The size (resolution) of each patch.
+ """,
+ }
+
+ num_channels = {
+ "description": """
+ The number of input channels.
+ """,
+ }
+
+ num_mel_bins = {
+ "description": """
+ Number of mel features used per input frame. Should correspond to the value used in the
+ `AutoFeatureExtractor` class.
+ """,
+ }
+
+ sampling_rate = {
+ "description": """
+ The sampling rate at which the audio files should be digitalized expressed in hertz (Hz).
+ """,
+ }
+
+ hidden_dropout = {
+ "description": """
+ The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
+ """,
+ }
+
+ mlp_ratio = {
+ "description": """
+ Ratio of the MLP hidden dim to the embedding dim.
+ """,
+ }
+
+ qkv_bias = {
+ "description": """
+ Whether to add a bias to the queries, keys and values.
+ """,
+ }
+
+ n_embd = {
+ "description": """
+ Dimensionality of the embeddings and hidden states.
+ """,
+ }
+
+ resid_pdrop = {
+ "description": """
+ The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
+ """,
+ }
+
+ embd_pdrop = {
+ "description": """
+ The dropout ratio for the embeddings.
+ """,
+ }
+
+ clip_qkv = {
+ "description": """
+ If not `None`, cap the absolute value of the query, key, and value tensors to this value.
+ """,
+ }
+
+ type_vocab_size = {
+ "description": """
+ The vocabulary size of the `token_type_ids`.
+ """,
+ }
+
+ audio_config = {
+ "description": """
+ The config object or dictionary of the audio backbone.
+ """,
+ }
+
+ layerdrop = {
+ "description": """
+ The LayerDrop probability. See the [LayerDrop paper](see https://huggingface.co/papers/1909.11556) for
+ more details.
+ """,
+ }
+
+ expert_capacity = {
+ "description": """
+ The number of tokens that each expert can process. If `None`, `expert_capacity` will be set to
+ `(sequence_length / num_experts) * capacity_factor`.
+ """,
+ }
+
+ decoder_start_token_id = {
+ "description": """
+ If an encoder-decoder model starts decoding with a different token than `bos`, the id of that token.
+ """,
+ }
+
+ is_encoder_decoder = {
+ "description": """
+ Whether the model is used as an encoder/decoder or not.
+ """,
+ }
+
+ num_codebooks = {
+ "description": """
+ The number of parallel codebooks used by the model.
+ """,
+ }
+
+ codebook_dim = {
+ "description": """
+ Dimensionality of each codebook embedding vector.
+ """,
+ }
+
+ hidden_sizes = {
+ "description": """
+ Dimensionality (hidden size) at each stage of the model.
+ """,
+ }
+
+ depths = {
+ "description": """
+ Depth of each layer in the Transformer.
+ """,
+ }
+
+ patch_sizes = {
+ "description": """
+ Patch size at each stage of the model.
+ """,
+ }
+
+ strides = {
+ "description": """
+ Stride at each stage of the model.
+ """,
+ }
+
+ router_jitter_noise = {
+ "description": """
+ Amount of noise to add to the router logits during training for better load balancing.
+ """,
+ }
+
+ num_local_experts = {
+ "description": """
+ Number of local experts on each device. `num_experts` should be divisible by `num_local_experts`.
+ """,
+ }
+
+ qk_layernorm = {
+ "description": """
+ Whether to use query-key normalization in the attention.
+ """,
+ }
+
+ backbone_config = {
+ "description": """
+ The configuration of the backbone model.
+ """,
+ }
+
+ no_object_weight = {
+ "description": """
+ Relative classification weight of the no-object class in the object detection loss.
+ """,
+ }
+
+ class_weight = {
+ "description": """
+ Relative weight of the classification error in the Hungarian matching cost.
+ """,
+ }
+
+ mask_weight = {
+ "description": """
+ Relative weight of the focal loss in the panoptic segmentation loss.
+ """,
+ }
+
+ dice_weight = {
+ "description": """
+ Relative weight of the dice loss in the panoptic segmentation loss.
+ """,
+ }
+
+ class_cost = {
+ "description": """
+ Relative weight of the classification error in the Hungarian matching cost.
+ """,
+ }
+
+ bbox_cost = {
+ "description": """
+ Relative weight of the L1 bounding box error in the Hungarian matching cost.
+ """,
+ }
+
+ giou_cost = {
+ "description": """
+ Relative weight of the generalized IoU loss in the Hungarian matching cost.
+ """,
+ }
+
+ focal_alpha = {
+ "description": """
+ Alpha parameter in the focal loss.
+ """,
+ }
+
+ mask_loss_coefficient = {
+ "description": """
+ Relative weight of the focal loss in the panoptic segmentation loss.
+ """,
+ }
+
+ giou_loss_coefficient = {
+ "description": """
+ Relative weight of the generalized IoU loss in the panoptic segmentation loss.
+ """,
+ }
+
+ bbox_loss_coefficient = {
+ "description": """
+ Relative weight of the L1 bounding box loss in the panoptic segmentation loss.
+ """,
+ }
+
+ cls_loss_coefficient = {
+ "description": """
+ Relative weight of the classification loss in the panoptic segmentation loss.
+ """,
+ }
+
+ dice_loss_coefficient = {
+ "description": """
+ Relative weight of the dice loss in the panoptic segmentation loss.
+ """,
+ }
+
+ semantic_loss_ignore_index = {
+ "description": """
+ The index that is ignored by the loss function of the semantic segmentation model.
+ """,
+ }
+
+ projection_dim = {
+ "description": """
+ Dimensionality of text and vision projection layers.
+ """,
+ }
+
+ logit_scale_init_value = {
+ "description": """
+ The initial value of the *logit_scale* parameter.
+ """,
+ }
+
+ num_dense_layers = {
+ "description": """
+ Number of initial dense layers before MoE layers begin. Layers with index < num_dense_layers will use
+ standard dense MLPs instead of MoE.
+ """,
+ }
+
+ drop_path_rate = {
+ "description": """
+ Drop path rate for the patch fusion.
+ """,
+ }
+
+ vq_config = {
+ "description": """
+ Configuration dict of the vector quantize module.
+ """,
+ }
+
+ num_embeddings = {
+ "description": """
+ Number of codebook embeddings.
+ """,
+ }
+
+ double_latent = {
+ "description": """
+ Whether to use double z channels.
+ """,
+ }
+
+ latent_channels = {
+ "description": """
+ Number of channels for the latent space.
+ """,
+ }
+
+ qformer_config = {
+ "description": """
+ Configuration dict of the Q-Former module.
+ """,
+ }
+
+ conv_kernel_size = {
+ "description": """
+ The size of the convolutional kernel.
+ """,
+ }
+
+ output_stride = {
+ "description": """
+ The ratio between the spatial resolution of the input and output feature maps.
+ """,
+ }
+
+ depth_multiplier = {
+ "description": """
+ Shrinks or expands the number of channels in each layer. This is sometimes also called "alpha" or "width multiplier".
+ """,
+ }
+
+ use_absolute_position_embeddings = {
+ "description": """
+ Whether to use absolute position embeddings.
+ """,
+ }
+
+ use_relative_position_bias = {
+ "description": """
+ Whether to use relative position bias in the self-attention layers.
+ """,
+ }
+
+ layer_scale_init_value = {
+ "description": """
+ Scale to use in the self-attention layers. 0.1 for base, 1e-6 for large. Set 0 to disable layer scale.
+ """,
+ }
+
+ vlm_config = {
+ "description": """
+ The config object or dictionary of the vision-language backbone.
+ """,
+ }
+
+ init_xavier_std = {
+ "description": """
+ The scaling factor used for the Xavier initialization of the cross-attention weights.
+ """,
+ }
+
+ auxiliary_loss = {
+ "description": """
+ Whether auxiliary decoding losses (losses at each decoder layer) are to be used.
+ """,
+ }
+
+ encoder_config = {
+ "description": """
+ The config object or dictionary of the encoder backbone.
+ """,
+ }
+
+ decoder_config = {
+ "description": """
+ The config object or dictionary of the decoder backbone.
+ """,
+ }
+
+ embedding_multiplier = {
+ "description": """
+ Scaling factor applied to the word embeddings. Used to scale the embeddings relative to the hidden size.
+ """,
+ }
+
+ logits_scaling = {
+ "description": """
+ Scaling factor applied to the output logits before computing the probability distribution.
+ """,
+ }
+
+ residual_multiplier = {
+ "description": """
+ Scaling factor applied to the residual connections.
+ """,
+ }
+
+ attention_multiplier = {
+ "description": """
+ Scaling factor applied to the attention weights.
+ """,
+ }
+
+ classifier_activation = {
+ "description": """
+ The activation function for the classification head.
+ """,
+ }
+
+ return_dict = {
+ "description": """
+ Whether to return a `ModelOutput` (dataclass) instead of a plain tuple.
+ """,
+ }
+
+ router_z_loss_coef = {
+ "description": """
+ Coefficient for the router z-loss, which penalizes large router logits to improve training stability.
+ """,
+ }
+
+ final_logit_softcapping = {
+ "description": """
+ Soft-capping value applied to the final logits before computing the probability distribution. Logits are
+ scaled by `tanh(logit / cap) * cap`.
+ """,
+ }
+
+ cross_attention_hidden_size = {
+ "description": """
+ Hidden size of the encoder outputs projected into the cross-attention key/value space of the decoder. Used
+ when the encoder and decoder have different hidden sizes.
+ """,
+ }
+
+ input_dim = {
+ "description": """
+ Dimensionality of the input acoustic features (e.g., number of mel-filterbank channels).
+ """,
+ }
+
+ use_auxiliary_loss = {
+ "description": """
+ Whether to calculate loss using intermediate predictions from transformer decoder.
+ """,
+ }
+
+ batch_norm_eps = {
+ "description": """
+ The epsilon used by the batch normalization layers.
+ """,
+ }
+
+ max_window_layers = {
+ "description": """
+ The number of layers using full attention. The first `max_window_layers` layers will use full attention, while any
+ additional layer afterwards will use SWA (Sliding Window Attention).
+ """,
+ }
+
+ ctc_loss_reduction = {
+ "description": """
+ Specifies the reduction to apply to the output of `torch.nn.CTCLoss`. Only relevant when training.
+ """,
+ }
+
+ mask_feature_prob = {
+ "description": """
+ Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The
+ masking procedure generates `mask_feature_prob*len(feature_axis)/mask_time_length` independent masks over
+ the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector
+ span to be masked, *mask_feature_prob* should be `prob_vector_start*mask_feature_length`. Note that overlap
+ may decrease the actual percentage of masked vectors. This is only relevant if `apply_spec_augment` is
+ `True`.
+ """,
+ }
+
+ eos_coefficient = {
+ "description": """
+ Relative classification weight of the 'no-object' class in the object detection loss.
+ """,
+ }
+
+ num_labels = {
+ "description": """
+ Number of labels to use in the last layer added to the model, typically for a classification task.
+ """,
+ }
+
+ depth = {
+ "description": """
+ Number of Transformer layers in the vision encoder.
+ """,
+ }
+
+ temporal_patch_size = {
+ "description": """
+ Temporal patch size used in the 3D patch embedding for video inputs.
+ """,
+ }
+
+ spatial_merge_size = {
+ "description": """
+ The size of the spatial merge window used to reduce the number of visual tokens by merging neighboring patches.
+ """,
+ }
+
+ vision_start_token_id = {
+ "description": """
+ Token ID that marks the start of a visual segment in the multimodal input sequence.
+ """,
+ }
+
+ vision_end_token_id = {
+ "description": """
+ Token ID that marks the end of a visual segment in the multimodal input sequence.
+ """,
+ }
+
+ mamba_n_heads = {
+ "description": """
+ The number of mamba heads used in the v2 implementation.
+ """,
+ }
+
+ mamba_d_head = {
+ "description": """
+ Head embedding dimension size
+ """,
+ }
+
+ mamba_n_groups = {
+ "description": """
+ The number of the mamba groups used in the v2 implementation.
+ """,
+ }
+
+ mamba_d_conv = {
+ "description": """
+ The size of the mamba convolution kernel
+ """,
+ }
+
+ mamba_expand = {
+ "description": """
+ Expanding factor (relative to hidden_size) used to determine the mamba intermediate size
+ """,
+ }
+
+ mamba_chunk_size = {
+ "description": """
+ The chunks in which to break the sequence when doing prefill/training
+ """,
+ }
+
+ mamba_conv_bias = {
+ "description": """
+ Flag indicating whether or not to use bias in the convolution layer of the mamba mixer block.
+ """,
+ }
+
+ mamba_proj_bias = {
+ "description": """
+ Flag indicating whether or not to use bias in the input and output projections (["in_proj", "out_proj"]) of the mamba mixer block
+ """,
+ }
+
+ time_step_min = {
+ "description": """
+ Minimum `time_step` used to bound `dt_proj.bias`.
+ """,
+ }
+
+ time_step_max = {
+ "description": """
+ Maximum `time_step` used to bound `dt_proj.bias`.
+ """,
+ }
+
+ time_step_limit = {
+ "description": """
+ Accepted range of time step values for clamping.
+ """,
+ }
+
+ expand_ratio = {
+ "description": """
+ Expand ratio to set the output dimensions for the expansion
+ """,
+ }
+
+ state_size = {
+ "description": """
+ Size of the SSM state (latent state dimension) in the Mamba layers.
+ """,
+ }
+
+ time_step_rank = {
+ "description": """
+ Rank of the delta (time step) projection. Can be `"auto"` to set it automatically.
+ """,
+ }
+
+ time_step_floor = {
+ "description": """
+ Minimum allowed value for the discrete time step delta after softplus activation.
+ """,
+ }
+
+ time_step_scale = {
+ "description": """
+ Scale applied to the time step delta before discretization.
+ """,
+ }
+
+ time_step_init_scheme = {
+ "description": """
+ Initialization scheme for the time step delta. Can be `"random"` or `"uniform"`.
+ """,
+ }
+
+ mamba_d_ssm = {
+ "description": """
+ Inner state size of the SSM (state-space model) in the Mamba layers of FalconH1.
+ """,
+ }
+
+ mamba_norm_before_gate = {
+ "description": """
+ Whether to apply normalization before the gating mechanism in the Mamba mixer.
+ """,
+ }
+
+ mamba_rms_norm = {
+ "description": """
+ Whether to use RMS normalization in the Mamba layers (as opposed to standard LayerNorm).
+ """,
+ }
+
+ mamba_d_state = state_size
+ mamba_num_heads = mamba_n_heads
+ mamba_head_dim = mamba_d_head
+ num_input_channels = num_channels
+ audio_channels = num_channels
+ input_channels = num_channels
+ in_channels = num_channels
+ in_chans = num_channels
+ scale_attn_weights = scale_embedding
+ attention_probs_dropout_prob = attention_dropout
+ attn_pdrop = attention_dropout
+ attn_dropout = attention_dropout
+ dropout = dropout_rate
+ resid_dropout = resid_pdrop
+ residual_dropout = resid_pdrop
+ emb_pdrop = embd_pdrop
+ embed_dropout = embd_pdrop
+ embedding_dropout = embd_pdrop
+ hidden_dropout_prob = hidden_dropout
+ hidden_dropout_rate = hidden_dropout
+ classifier_dropout_prob = classifier_dropout
+ classifier_dropout_rate = classifier_dropout
+ dropout_prob = dropout
+ dropout_p = dropout
+ decoder_attention_dropout = attention_dropout
+ decoder_dropout = dropout
+ encoder_dropout = dropout
+
+ route_scale = routed_scaling_factor
+ activation_function = hidden_act
+ hidden_dim = hidden_size
+ num_decoder_attention_heads = decoder_attention_heads
+ num_encoder_attention_heads = encoder_attention_heads
+ decoder_num_heads = decoder_attention_heads
+ decoder_num_attention_heads = decoder_attention_heads
+ encoder_num_heads = encoder_attention_heads
+ encoder_num_attention_heads = encoder_attention_heads
+ encoder_layers = num_encoder_layers
+ decoder_layers = num_decoder_layers
+ decoder_num_layers = num_decoder_layers
+ encoder_num_layers = num_encoder_layers
+ d_ff = intermediate_size
+ dim_ff = intermediate_size
+ n_inner = intermediate_size
+ decoder_intermediate_size = intermediate_size
+ num_kv_heads = num_key_value_heads
+ num_layers = num_hidden_layers
+ n_layers = num_hidden_layers
+ n_layer = num_hidden_layers
+ layers = num_layers
+ encoder_num_hidden_layers = encoder_layers
+ decoder_num_hidden_layers = decoder_layers
+ num_heads = num_attention_heads
+ n_heads = num_attention_heads
+ n_head = num_attention_heads
+ hidden_activation = hidden_act
+ activation = hidden_act
+ mlp_hidden_act = hidden_act
+ d_head = head_dim
+ d_inner = intermediate_size
+ dim_head = head_dim
+ ffn_dim = intermediate_size
+ attention_heads = num_attention_heads
+ n_positions = max_position_embeddings
+ init_std = initializer_range
+ initializer_std = initializer_range
+ projector_bias = multimodal_projector_bias
+ image_token_index = image_token_id
+ video_token_index = video_token_id
+ audio_token_index = audio_token_id
+ embedding_size = n_embd
+ embed_dim = n_embd
+ projection_hidden_act = projector_hidden_act
+ layer_norm_epsilon = layer_norm_eps
+ rms_norm = rms_norm_eps
+ norm_eps = layer_norm_eps
+ eps = layer_norm_eps
+ norm_epsilon = layer_norm_eps
+ qk_layernorms = qk_layernorm
+ use_qk_norm = qk_layernorm
+ use_qkv_bias = qkv_bias
+
+ decoder_hidden_act = hidden_act
+ decoder_hidden_dim = hidden_size
+ decoder_hidden_size = hidden_size
+ encoder_hidden_dim = hidden_size
+ encoder_hidden_size = hidden_size
+ layer_scale_initial_scale = layer_scale_init_value
+ multi_modal_projector_bias = projector_bias
+ projector_hidden_size = projection_dim
+ projection_size = projection_dim
+ kernel_size = conv_kernel_size
+ conv_kernel = conv_kernel_size
+ use_absolute_embeddings = use_absolute_position_embeddings
+ use_abs_pos = use_absolute_position_embeddings
+ use_rel_pos = use_relative_position_bias
+ aux_loss_coef = router_aux_loss_coef
+ embedding_dimension = embed_dim
+ embedding_dim = embed_dim
+ emb_dim = embed_dim
+ n_codebooks = num_codebooks
+ codebook_size = num_codebooks
+ layers_block_type = layer_types
+ sample_rate = sampling_rate
+ text_vocab_size = vocab_size
+
+
+class ModelArgs:
+ labels = {
+ "description": """
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ num_logits_to_keep = {
+ "description": """
+ Calculate logits for the last `num_logits_to_keep` tokens. If `0`, calculate logits for all
+ `input_ids` (special case). Only last token logits are needed for generation, and calculating them only for that
+ token can save memory, which becomes pretty significant for long sequences or large vocabulary size.
+ """,
+ "shape": None,
+ }
+
+ input_ids = {
+ "description": """
+ Indices of input sequence tokens in the vocabulary. Padding will be ignored by default.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are input IDs?](../glossary#input-ids)
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ input_values = {
+ "description": """
+ Float values of input raw speech waveform. Values can be obtained by loading a `.flac` or `.wav` audio file
+ into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library
+ (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
+ To prepare the array into `input_values`, the [`AutoProcessor`] should be used for padding and conversion
+ into a tensor of type `torch.FloatTensor`. See [`{processor_class}.__call__`] for details.
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ attention_mask = {
+ "description": """
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+
+ [What are attention masks?](../glossary#attention-mask)
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ decoder_attention_mask = {
+ "description": """
+ Mask to avoid performing attention on certain token indices. By default, a causal mask will be used, to
+ make sure the model can only look at previous inputs in order to predict the future.
+ """,
+ "shape": "of shape `(batch_size, target_sequence_length)`",
+ }
+
+ encoder_hidden_states = {
+ "description": """
+ Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
+ if the model is configured as a decoder.
+ """,
+ "shape": "of shape `(batch_size, sequence_length, hidden_size)`",
+ }
+
+ encoder_attention_mask = {
+ "description": """
+ Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
+ the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`:
+
+ - 1 for tokens that are **not masked**,
+ - 0 for tokens that are **masked**.
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ token_type_ids = {
+ "description": """
+ Segment token indices to indicate first and second portions of the inputs. Indices are selected in `[0, 1]`:
+
+ - 0 corresponds to a *sentence A* token,
+ - 1 corresponds to a *sentence B* token.
+
+ [What are token type IDs?](../glossary#token-type-ids)
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ mm_token_type_ids = {
+ "description": """
+ Indices of input sequence tokens matching each modality. For example text (0), image (1), video (2).
+ Multimodal token type ids can be obtained using [`AutoProcessor`]. See [`ProcessorMixin.__call__`] for details.
+
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ position_ids = {
+ "description": """
+ Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, config.n_positions - 1]`.
+
+ [What are position IDs?](../glossary#position-ids)
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ past_key_values = {
+ "description": """
+ Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
+ blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values`
+ returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.
+
+ Only [`~cache_utils.Cache`] instance is allowed as input, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+ If no `past_key_values` are passed, [`~cache_utils.DynamicCache`] will be initialized by default.
+
+ The model will output the same cache format that is fed as input.
+
+ If `past_key_values` are used, the user is expected to input only unprocessed `input_ids` (those that don't
+ have their past key value states given to this model) of shape `(batch_size, unprocessed_length)` instead of all `input_ids`
+ of shape `(batch_size, sequence_length)`.
+ """,
+ "shape": None,
+ }
+
+ inputs_embeds = {
+ "description": """
+ Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
+ is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
+ model's internal embedding lookup matrix.
+ """,
+ "shape": "of shape `(batch_size, sequence_length, hidden_size)`",
+ }
+
+ decoder_input_ids = {
+ "description": """
+ Indices of decoder input sequence tokens in the vocabulary.
+
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+ [`PreTrainedTokenizer.__call__`] for details.
+
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
+ """,
+ "shape": "of shape `(batch_size, target_sequence_length)`",
+ }
+
+ decoder_inputs_embeds = {
+ "description": """
+ Optionally, instead of passing `decoder_input_ids` you can choose to directly pass an embedded
+ representation. If `past_key_values` is used, optionally only the last `decoder_inputs_embeds` have to be
+ input (see `past_key_values`). This is useful if you want more control over how to convert
+ `decoder_input_ids` indices into associated vectors than the model's internal embedding lookup matrix.
+
+ If `decoder_input_ids` and `decoder_inputs_embeds` are both unset, `decoder_inputs_embeds` takes the value
+ of `inputs_embeds`.
+ """,
+ "shape": "of shape `(batch_size, target_sequence_length, hidden_size)`",
+ }
+
+ use_cache = {
+ "description": """
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+ `past_key_values`).
+ """,
+ "shape": None,
+ }
+
+ output_attentions = {
+ "description": """
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+ tensors for more detail.
+ """,
+ "shape": None,
+ }
+
+ output_hidden_states = {
+ "description": """
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+ more detail.
+ """,
+ "shape": None,
+ }
+
+ return_dict = {
+ "description": """
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+ """,
+ "shape": None,
+ }
+
+ hidden_states = {
+ "description": """ input to the layer of shape `(batch, seq_len, embed_dim)""",
+ "shape": None,
+ }
+
+ interpolate_pos_encoding = {
+ "description": """
+ Whether to interpolate the pre-trained position encodings.
+ """,
+ "shape": None,
+ }
+
+ position_embeddings = {
+ "description": """
+ Tuple containing the cosine and sine positional embeddings of shape `(batch_size, seq_len, head_dim)`,
+ with `head_dim` being the embedding dimension of each attention head.
+ """,
+ "shape": None,
+ }
+
+ config = {
+ "description": """
+ Model configuration class with all the parameters of the model. Initializing with a config file does not
+ load the weights associated with the model, only the configuration. Check out the
+ [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+ """,
+ "shape": None,
+ }
+
+ start_positions = {
+ "description": """
+ Labels for position (index) of the start of the labelled span for computing the token classification loss.
+ Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
+ are not taken into account for computing the loss.
+ """,
+ "shape": "of shape `(batch_size,)`",
+ }
+
+ end_positions = {
+ "description": """
+ Labels for position (index) of the end of the labelled span for computing the token classification loss.
+ Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
+ are not taken into account for computing the loss.
+ """,
+ "shape": "of shape `(batch_size,)`",
+ }
+
+ encoder_outputs = {
+ "description": """
+ Tuple consists of (`last_hidden_state`, *optional*: `hidden_states`, *optional*: `attentions`)
+ `last_hidden_state` of shape `(batch_size, sequence_length, hidden_size)`, *optional*) is a sequence of
+ hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.
+ """,
+ "shape": None,
+ }
+
+ output_router_logits = {
+ "description": """
+ Whether or not to return the logits of all the routers. They are useful for computing the router loss, and
+ should not be returned during inference.
+ """,
+ "shape": None,
+ }
+
+ logits_to_keep = {
+ "description": """
+ If an `int`, compute logits for the last `logits_to_keep` tokens. If `0`, calculate logits for all
+ `input_ids` (special case). Only last token logits are needed for generation, and calculating them only for that
+ token can save memory, which becomes pretty significant for long sequences or large vocabulary size.
+ If a `torch.Tensor`, must be 1D corresponding to the indices to keep in the sequence length dimension.
+ This is useful when using packed tensor format (single dimension for batch and sequence length).
+ """,
+ "shape": None,
+ }
+
+ pixel_values = {
+ "description": """
+ The tensors corresponding to the input images. Pixel values can be obtained using
+ [`{image_processor_class}`]. See [`{image_processor_class}.__call__`] for details ([`{processor_class}`] uses
+ [`{image_processor_class}`] for processing images).
+ """,
+ "shape": "of shape `(batch_size, num_channels, image_size, image_size)`",
+ }
+
+ pixel_values_videos = {
+ "description": """
+ The tensors corresponding to the input video. Pixel values for videos can be obtained using
+ [`{video_processor_class}`]. See [`{video_processor_class}.__call__`] for details ([`{processor_class}`] uses
+ [`{video_processor_class}`] for processing videos).
+ """,
+ "shape": "of shape `(batch_size, num_frames, num_channels, frame_size, frame_size)`",
+ }
+
+ vision_feature_layer = {
+ "description": """
+ The index of the layer to select the vision feature. If multiple indices are provided,
+ the vision feature of the corresponding indices will be concatenated to form the
+ vision features.
+ """,
+ "shape": None,
+ }
+
+ vision_feature_select_strategy = {
+ "description": """
+ The feature selection strategy used to select the vision feature from the vision backbone.
+ Can be one of `"default"` or `"full"`.
+ """,
+ "shape": None,
+ }
+
+ image_sizes = {
+ "description": """
+ The sizes of the images in the batch, being (height, width) for each image.
+ """,
+ "shape": "of shape `(batch_size, 2)`",
+ }
+
+ pixel_mask = {
+ "description": """
+ Mask to avoid performing attention on padding pixel values. Mask values selected in `[0, 1]`:
+
+ - 1 for pixels that are real (i.e. **not masked**),
+ - 0 for pixels that are padding (i.e. **masked**).
+
+ [What are attention masks?](../glossary#attention-mask)
+ """,
+ "shape": "of shape `(batch_size, height, width)`",
+ }
+
+ input_features = {
+ "description": """
+ The tensors corresponding to the input audio features. Audio features can be obtained using
+ [`{feature_extractor_class}`]. See [`{feature_extractor_class}.__call__`] for details ([`{processor_class}`] uses
+ [`{feature_extractor_class}`] for processing audios).
+ """,
+ "shape": "of shape `(batch_size, sequence_length, feature_dim)`",
+ }
+
+
+class ModelOutputArgs:
+ last_hidden_state = {
+ "description": """
+ Sequence of hidden-states at the output of the last layer of the model.
+ """,
+ "shape": "of shape `(batch_size, sequence_length, hidden_size)`",
+ }
+
+ past_key_values = {
+ "description": """
+ It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if
+ `config.is_encoder_decoder=True` in the cross-attention blocks) that can be used (see `past_key_values`
+ input) to speed up sequential decoding.
+ """,
+ "shape": None,
+ "additional_info": "returned when `use_cache=True` is passed or when `config.use_cache=True`",
+ }
+
+ hidden_states = {
+ "description": """
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
+ one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.
+
+ Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.
+ """,
+ "shape": None,
+ "additional_info": "returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`",
+ }
+
+ attentions = {
+ "description": """
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`.
+
+ Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
+ heads.
+ """,
+ "shape": None,
+ "additional_info": "returned when `output_attentions=True` is passed or when `config.output_attentions=True`",
+ }
+
+ pooler_output = {
+ "description": """
+ Last layer hidden-state after a pooling operation on the spatial dimensions.
+ """,
+ "shape": "of shape `(batch_size, hidden_size)`",
+ }
+
+ cross_attentions = {
+ "description": """
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`.
+
+ Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the
+ weighted average in the cross-attention heads.
+ """,
+ "shape": None,
+ "additional_info": "returned when `output_attentions=True` is passed or when `config.output_attentions=True`",
+ }
+
+ decoder_hidden_states = {
+ "description": """
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
+ one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.
+
+ Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.
+ """,
+ "shape": None,
+ "additional_info": "returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`",
+ }
+
+ decoder_attentions = {
+ "description": """
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`.
+
+ Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
+ self-attention heads.
+ """,
+ "shape": None,
+ "additional_info": "returned when `output_attentions=True` is passed or when `config.output_attentions=True`",
+ }
+
+ encoder_last_hidden_state = {
+ "description": """
+ Sequence of hidden-states at the output of the last layer of the encoder of the model.
+ """,
+ "shape": "of shape `(batch_size, sequence_length, hidden_size)`",
+ }
+
+ encoder_hidden_states = {
+ "description": """
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
+ one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.
+
+ Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.
+ """,
+ "shape": None,
+ "additional_info": "returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`",
+ }
+
+ encoder_attentions = {
+ "description": """
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+ sequence_length)`.
+
+ Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
+ self-attention heads.
+ """,
+ "shape": None,
+ "additional_info": "returned when `output_attentions=True` is passed or when `config.output_attentions=True`",
+ }
+
+ router_logits = {
+ "description": """
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, sequence_length, num_experts)`.
+
+ Router logits of the model, useful to compute the auxiliary loss for Mixture of Experts models.
+ """,
+ "shape": None,
+ "additional_info": "returned when `output_router_logits=True` is passed or when `config.add_router_probs=True`",
+ }
+
+ router_probs = {
+ "description": """
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, sequence_length, num_experts)`.
+
+ Raw router probabilities that are computed by MoE routers, these terms are used to compute the auxiliary
+ loss and the z_loss for Mixture of Experts models.
+ """,
+ "shape": None,
+ "additional_info": "returned when `output_router_probs=True` and `config.add_router_probs=True` is passed or when `config.output_router_probs=True`",
+ }
+
+ z_loss = {
+ "description": """
+ z_loss for the sparse modules.
+ """,
+ "shape": None,
+ "additional_info": "returned when `labels` is provided",
+ }
+
+ aux_loss = {
+ "description": """
+ aux_loss for the sparse modules.
+ """,
+ "shape": None,
+ "additional_info": "returned when `labels` is provided",
+ }
+
+ start_logits = {
+ "description": """
+ Span-start scores (before SoftMax).
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ end_logits = {
+ "description": """
+ Span-end scores (before SoftMax).
+ """,
+ "shape": "of shape `(batch_size, sequence_length)`",
+ }
+
+ feature_maps = {
+ "description": """
+ Feature maps of the stages.
+ """,
+ "shape": "of shape `(batch_size, num_channels, height, width)`",
+ }
+
+ reconstruction = {
+ "description": """
+ Reconstructed / completed images.
+ """,
+ "shape": "of shape `(batch_size, num_channels, height, width)`",
+ }
+
+ spectrogram = {
+ "description": """
+ The predicted spectrogram.
+ """,
+ "shape": "of shape `(batch_size, sequence_length, num_bins)`",
+ }
+
+ predicted_depth = {
+ "description": """
+ Predicted depth for each pixel.
+ """,
+ "shape": "of shape `(batch_size, height, width)`",
+ }
+
+ sequences = {
+ "description": """
+ Sampled values from the chosen distribution.
+ """,
+ "shape": "of shape `(batch_size, num_samples, prediction_length)` or `(batch_size, num_samples, prediction_length, input_size)`",
+ }
+
+ params = {
+ "description": """
+ Parameters of the chosen distribution.
+ """,
+ "shape": "of shape `(batch_size, num_samples, num_params)`",
+ }
+
+ loc = {
+ "description": """
+ Shift values of each time series' context window which is used to give the model inputs of the same
+ magnitude and then used to shift back to the original magnitude.
+ """,
+ "shape": "of shape `(batch_size,)` or `(batch_size, input_size)`",
+ }
+
+ scale = {
+ "description": """
+ Scaling values of each time series' context window which is used to give the model inputs of the same
+ magnitude and then used to rescale back to the original magnitude.
+ """,
+ "shape": "of shape `(batch_size,)` or `(batch_size, input_size)`",
+ }
+
+ static_features = {
+ "description": """
+ Static features of each time series' in a batch which are copied to the covariates at inference time.
+ """,
+ "shape": "of shape `(batch_size, feature size)`",
+ }
+
+ embeddings = {
+ "description": """
+ Utterance embeddings used for vector similarity-based retrieval.
+ """,
+ "shape": "of shape `(batch_size, config.xvector_output_dim)`",
+ }
+
+ extract_features = {
+ "description": """
+ Sequence of extracted feature vectors of the last convolutional layer of the model.
+ """,
+ "shape": "of shape `(batch_size, sequence_length, conv_dim[-1])`",
+ }
+
+ projection_state = {
+ "description": """
+ Text embeddings before the projection layer, used to mimic the last hidden state of the teacher encoder.
+ """,
+ "shape": "of shape `(batch_size,config.project_dim)`",
+ }
+
+ image_hidden_states = {
+ "description": """
+ Image hidden states of the model produced by the vision encoder and after projecting the last hidden state.
+ """,
+ "shape": "of shape `(batch_size, num_images, sequence_length, hidden_size)`",
+ }
+
+ video_hidden_states = {
+ "description": """
+ Video hidden states of the model produced by the vision encoder and after projecting the last hidden state.
+ """,
+ "shape": "of shape `(batch_size * num_frames, num_images, sequence_length, hidden_size)`",
+ }
+
+
+class ClassDocstring:
+ Config = r"""
+ This is the configuration class to store the configuration of a {model_base_class}. It is used to instantiate a {model_name}
+ model according to the specified arguments, defining the model architecture. Instantiating a configuration with the
+ defaults will yield a similar configuration to that of the [{model_checkpoint}](https://huggingface.co/{model_checkpoint})
+
+ Configuration objects inherit from [`PreTrainedConfig`] and can be used to control the model outputs. Read the
+ documentation from [`PreTrainedConfig`] for more information.
+ """
+
+ PreTrainedModel = r"""
+ This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+ library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+ etc.)
+
+ This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+ Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+ and behavior.
+ """
+
+ Model = r"""
+ The bare {model_name} Model outputting raw hidden-states without any specific head on top.
+ """
+
+ ForPreTraining = r"""
+ The {model_name} Model with a specified pretraining head on top.
+ """
+
+ Decoder = r"""
+ The bare {model_name} Decoder outputting raw hidden-states without any specific head on top.
+ """
+
+ TextModel = r"""
+ The bare {model_name} Text Model outputting raw hidden-states without any specific head on to.
+ """
+
+ ForSequenceClassification = r"""
+ The {model_name} Model with a sequence classification/regression head on top e.g. for GLUE tasks.
+ """
+
+ ForQuestionAnswering = r"""
+ The {model_name} transformer with a span classification head on top for extractive question-answering tasks like
+ SQuAD (a linear layer on top of the hidden-states output to compute `span start logits` and `span end logits`).
+ """
+
+ ForMultipleChoice = r"""
+ The {model_name} Model with a multiple choice classification head on top (a linear layer on top of the pooled output and a
+ softmax) e.g. for RocStories/SWAG tasks.
+ """
+
+ ForMaskedLM = r"""
+ The {model_name} Model with a `language modeling` head on top."
+ """
+
+ ForTokenClassification = r"""
+ The {model_name} transformer with a token classification head on top (a linear layer on top of the hidden-states
+ output) e.g. for Named-Entity-Recognition (NER) tasks.
+ """
+
+ ForConditionalGeneration = r"""
+ The {model_name} Model for token generation conditioned on other modalities (e.g. image-text-to-text generation).
+ """
+
+ ForCausalLM = r"""
+ The {model_name} Model for causal language modeling.
+ """
+
+ Backbone = r"""
+ The {model_name} backbone.
+ """
+
+ ForImageClassification = r"""
+ The {model_name} Model with an image classification head on top e.g. for ImageNet.
+ """
+ ForSemanticSegmentation = r"""
+ The {model_name} Model with a semantic segmentation head on top e.g. for ADE20K, CityScapes.
+ """
+ ForAudioClassification = r"""
+ The {model_name} Model with an audio classification head on top (a linear layer on top of the pooled
+ output).
+ """
+
+ ForAudioFrameClassification = r"""
+ The {model_name} Model with a frame classification head on top for tasks like Speaker Diarization.
+ """
+
+ ForPrediction = r"""
+ The {model_name} Model with a distribution head on top for time-series forecasting.
+ """
+
+ WithProjection = r"""
+ The {model_name} Model with a projection layer on top (a linear layer on top of the pooled output).
+ """
+
+
+class ClassAttrs:
+ # fmt: off
+ base_model_prefix = r"""
+ A string indicating the attribute associated to the base model in derived classes of the same architecture adding modules on top of the base model.
+ """
+ supports_gradient_checkpointing = r"""
+ Whether the model supports gradient checkpointing or not. Gradient checkpointing is a memory-saving technique that trades compute for memory, by storing only a subset of activations (checkpoints) and recomputing the activations that are not stored during the backward pass.
+ """
+ _no_split_modules = r"""
+ Layers of modules that should not be split across devices should be added to `_no_split_modules`. This can be useful for modules that contains skip connections or other operations that are not compatible with splitting the module across devices. Setting this attribute will enable the use of `device_map="auto"` in the `from_pretrained` method.
+ """
+ _skip_keys_device_placement = r"""
+ A list of keys to ignore when moving inputs or outputs between devices when using the `accelerate` library.
+ """
+ _supports_flash_attn = r"""
+ Whether the model's attention implementation supports FlashAttention.
+ """
+ _supports_sdpa = r"""
+ Whether the model's attention implementation supports SDPA (Scaled Dot Product Attention).
+ """
+ _supports_flex_attn = r"""
+ Whether the model's attention implementation supports FlexAttention.
+ """
+ _can_compile_fullgraph = r"""
+ Whether the model can `torch.compile` fullgraph without graph breaks. Models will auto-compile if this flag is set to `True`
+ in inference, if a compilable cache is used.
+ """
+ _supports_attention_backend = r"""
+ Whether the model supports attention interface functions. This flag signal that the model can be used as an efficient backend in TGI and vLLM.
+ """
+ _tied_weights_keys = r"""
+ A list of `state_dict` keys that are potentially tied to another key in the state_dict.
+ """
+ # fmt: on
+
+
+ARGS_TO_IGNORE = {"self", "kwargs", "args", "deprecated_arguments"}
+ARGS_TO_RENAME = {"_out_features": "out_features", "_out_indices": "out_indices"}
+
+
+def get_indent_level(func):
+ # Use this instead of `inspect.getsource(func)` as getsource can be very slow
+ return (len(func.__qualname__.split(".")) - 1) * 4
+
+
+def equalize_indent(docstring: str, indent_level: int) -> str:
+ """
+ Adjust the indentation of a docstring to match the specified indent level.
+ """
+ prefix = " " * indent_level
+ # Uses splitlines() (no keepends) to match previous behaviour that dropped
+ # any trailing newline via the old splitlines() + "\n".join() + textwrap.indent path.
+ return "\n".join(prefix + line.lstrip() if line.strip() else "" for line in docstring.splitlines())
+
+
+def set_min_indent(docstring: str, indent_level: int) -> str:
+ """
+ Adjust the indentation of a docstring to match the specified indent level.
+ """
+ # Equivalent to textwrap.dedent + textwrap.indent but avoids the two regex
+ # passes that textwrap uses internally (one per call in dedent, one in indent).
+ lines = docstring.split("\n")
+ min_indent = min(
+ (len(line) - len(line.lstrip()) for line in lines if line.strip()),
+ default=0,
+ )
+ prefix = " " * indent_level
+ return "\n".join(prefix + line[min_indent:] if line.strip() else "" for line in lines)
+
+
+def parse_shape(docstring):
+ match = _re_shape.search(docstring)
+ if match:
+ return " " + match.group(1)
+ return None
+
+
+def parse_default(docstring):
+ match = _re_default.search(docstring)
+ if match:
+ return " " + match.group(1)
+ return None
+
+
+def parse_docstring(docstring, max_indent_level=0, return_intro=False):
+ """
+ Parse the docstring to extract the Args section and return it as a dictionary.
+ The docstring is expected to be in the format:
+ Args:
+ arg1 (type):
+ Description of arg1.
+ arg2 (type):
+ Description of arg2.
+
+ # This function will also return the remaining part of the docstring after the Args section.
+ Returns:/Example:
+ ...
+ """
+ match = _re_example_or_return.search(docstring)
+ if match:
+ remainder_docstring = docstring[match.start() :]
+ docstring = docstring[: match.start()]
+ else:
+ remainder_docstring = ""
+
+ args_match = _re_args_section.search(docstring)
+ # still try to find args description in the docstring, if args are not preceded by "Args:"
+ docstring_intro = None
+ if args_match:
+ docstring_intro = docstring[: args_match.start()]
+ if docstring_intro.split("\n")[-1].strip() == '"""':
+ docstring_intro = "\n".join(docstring_intro.split("\n")[:-1])
+ if docstring_intro.split("\n")[0].strip() == 'r"""' or docstring_intro.split("\n")[0].strip() == '"""':
+ docstring_intro = "\n".join(docstring_intro.split("\n")[1:])
+ if docstring_intro.strip() == "":
+ docstring_intro = None
+ args_section = args_match.group(1).lstrip("\n") if args_match else docstring
+ if args_section.split("\n")[-1].strip() == '"""':
+ args_section = "\n".join(args_section.split("\n")[:-1])
+ if args_section.split("\n")[0].strip() == 'r"""' or args_section.split("\n")[0].strip() == '"""':
+ args_section = "\n".join(args_section.split("\n")[1:])
+ args_section = set_min_indent(args_section, 0)
+ params = {}
+ if args_section:
+ # Use the pre-compiled pattern (max_indent_level is always 0 at all call
+ # sites; if a non-zero value is ever needed, compile a fresh pattern).
+ if max_indent_level == 0:
+ param_pattern = _re_param
+ else:
+ param_pattern = re.compile(
+ # |--- Group 1 ---|| Group 2 ||- Group 3 -||---------- Group 4 ----------|
+ rf"^\s{{0,{max_indent_level}}}(\w+)\s*\(\s*([^, \)]*)(\s*.*?)\s*\)\s*:\s*((?:(?!\n^\s{{0,{max_indent_level}}}\w+\s*\().)*)",
+ re.DOTALL | re.MULTILINE,
+ )
+ for match in param_pattern.finditer(args_section):
+ param_name = match.group(1)
+ param_type = match.group(2)
+ additional_info = match.group(3)
+ optional = "optional" in additional_info
+ shape = parse_shape(additional_info)
+ default = parse_default(additional_info)
+ param_description = match.group(4).strip()
+ # indent the first line of param_description to 4 spaces:
+ param_description = " " * 4 + param_description
+ param_description = f"\n{param_description}"
+ params[param_name] = {
+ "type": param_type,
+ "description": param_description,
+ "optional": optional,
+ "shape": shape,
+ "default": default,
+ "additional_info": additional_info,
+ }
+
+ if params and remainder_docstring:
+ remainder_docstring = "\n" + remainder_docstring
+
+ remainder_docstring = set_min_indent(remainder_docstring, 0)
+
+ if return_intro:
+ return params, remainder_docstring, docstring_intro
+ return params, remainder_docstring
+
+
+def contains_type(type_hint, target_type) -> tuple[bool, object | None]:
+ """
+ Check if a "nested" type hint contains a specific target type,
+ return the first-level type containing the target_type if found.
+ """
+ args = get_args(type_hint)
+ if args == ():
+ try:
+ return issubclass(type_hint, target_type), type_hint
+ except Exception:
+ return issubclass(type(type_hint), target_type), type_hint
+ found_type_tuple = [contains_type(arg, target_type)[0] for arg in args]
+ found_type = any(found_type_tuple)
+ if found_type:
+ type_hint = args[found_type_tuple.index(True)]
+ return found_type, type_hint
+
+
+def get_model_name(obj):
+ """
+ Get the model name from the file path of the object.
+ """
+
+ path = inspect.getsourcefile(obj)
+ if path is None:
+ return None
+ if path.split(os.path.sep)[-3] != "models":
+ return None
+ file_name = path.split(os.path.sep)[-1]
+ model_name_lowercase_from_folder = path.split(os.path.sep)[-2]
+ model_name_lowercase_from_file = None
+ for file_type in AUTODOC_FILES:
+ start = file_type.split("*")[0]
+ end = file_type.split("*")[-1] if "*" in file_type else ""
+ if file_name.startswith(start) and file_name.endswith(end):
+ model_name_lowercase_from_file = file_name[len(start) : -len(end)]
+ break
+ if model_name_lowercase_from_file and model_name_lowercase_from_folder != model_name_lowercase_from_file:
+ from transformers.models.auto.configuration_auto import SPECIAL_MODEL_TYPE_TO_MODULE_NAME
+
+ if (
+ model_name_lowercase_from_file in SPECIAL_MODEL_TYPE_TO_MODULE_NAME
+ or model_name_lowercase_from_file.replace("_", "-") in SPECIAL_MODEL_TYPE_TO_MODULE_NAME
+ ):
+ return model_name_lowercase_from_file
+ return model_name_lowercase_from_folder
+ return model_name_lowercase_from_folder
+
+
+def generate_processor_intro(cls) -> str:
+ """
+ Generate the intro docstring for a processor class based on its attributes.
+
+ Args:
+ cls: Processor class to generate intro for
+
+ Returns:
+ str: Generated intro text
+ """
+ class_name = cls.__name__
+
+ # Get attributes and their corresponding class names
+ attributes = cls.get_attributes()
+ if not attributes:
+ return ""
+
+ # Build list of component names and their classes
+ components = []
+ component_classes = []
+
+ for attr in attributes:
+ # Get the class name for this attribute
+ class_attr = f"{attr}_class"
+ # Format attribute name for display
+ attr_display = attr.replace("_", " ")
+ components.append(attr_display)
+ component_classes.append(f"[`{{{class_attr}}}`]")
+ if not components:
+ return ""
+
+ # Generate the intro text
+ if len(components) == 1:
+ components_text = f"a {components[0]}"
+ classes_text = component_classes[0]
+ classes_text_short = component_classes[0].replace("[`", "[`~")
+ elif len(components) == 2:
+ components_text = f"a {components[0]} and a {components[1]}"
+ classes_text = f"{component_classes[0]} and {component_classes[1]}"
+ classes_text_short = (
+ f"{component_classes[0].replace('[`', '[`~')} and {component_classes[1].replace('[`', '[`~')}"
+ )
+ else:
+ components_text = ", ".join(f"a {c}" for c in components[:-1]) + f", and a {components[-1]}"
+ classes_text = ", ".join(component_classes[:-1]) + f", and {component_classes[-1]}"
+ classes_short = [c.replace("[`", "[`~") for c in component_classes]
+ classes_text_short = ", ".join(classes_short[:-1]) + f", and {classes_short[-1]}"
+
+ intro = f"""Constructs a {class_name} which wraps {components_text} into a single processor.
+
+[`{class_name}`] offers all the functionalities of {classes_text}. See the
+{classes_text_short} for more information.
+"""
+
+ return intro
+
+
+def get_placeholders_dict(placeholders: set[str], model_name: str) -> Mapping[str, str | None]:
+ """
+ Get the dictionary of placeholders for the given model name.
+ """
+ # import here to avoid circular import
+ from transformers.models import auto as auto_module
+
+ placeholders_dict = {}
+ for placeholder in placeholders:
+ # Infer placeholders from the model name and the auto modules
+ if placeholder in PLACEHOLDER_TO_AUTO_MODULE:
+ try:
+ place_holder_value = getattr(
+ getattr(auto_module, PLACEHOLDER_TO_AUTO_MODULE[placeholder][0]),
+ PLACEHOLDER_TO_AUTO_MODULE[placeholder][1],
+ ).get(model_name, None)
+ except ImportError:
+ # In case a library is not installed, we don't want to fail the docstring generation
+ place_holder_value = None
+ if place_holder_value is not None:
+ if isinstance(place_holder_value, list | tuple):
+ place_holder_value = (
+ place_holder_value[-1] if place_holder_value[-1] is not None else place_holder_value[0]
+ )
+ placeholders_dict[placeholder] = place_holder_value if place_holder_value is not None else placeholder
+ else:
+ placeholders_dict[placeholder] = placeholder
+
+ return placeholders_dict
+
+
+def format_args_docstring(docstring: str, model_name: str) -> str:
+ """
+ Replaces placeholders such as {image_processor_class} in the docstring with the actual values,
+ deducted from the model name and the auto modules.
+ """
+ # first check if there are any placeholders in the docstring, if not return it as is
+ placeholders = set(_re_placeholders.findall(docstring))
+ if not placeholders:
+ return docstring
+
+ # get the placeholders dictionary for the given model name
+ placeholders_dict = get_placeholders_dict(placeholders, model_name)
+ # replace the placeholders in the docstring with the values from the placeholders_dict
+ for placeholder, value in placeholders_dict.items():
+ if isinstance(value, dict) and placeholder == "image_processor_class":
+ value = value.get("torchvision", value.get("pil", None))
+ if placeholder is not None:
+ docstring = docstring.replace(f"{{{placeholder}}}", value)
+ return docstring
+
+
+def get_args_doc_from_source(args_classes: object | list[object]) -> dict:
+ if isinstance(args_classes, list | tuple):
+ return _merge_args_dicts(tuple(args_classes))
+ return args_classes.__dict__
+
+
+@lru_cache(maxsize=16)
+def _merge_args_dicts(args_classes_tuple: tuple) -> dict:
+ """Cached merger of args-doc dicts. The input classes are static so caching is safe."""
+ result = {}
+ for cls in args_classes_tuple:
+ result.update(cls.__dict__)
+ return result
+
+
+def get_checkpoint_from_config_class(config_class):
+ checkpoint = None
+
+ # source code of `config_class`
+ # config_source = inspect.getsource(config_class)
+ config_source = config_class.__doc__
+ if not config_source:
+ return None
+
+ checkpoints = _re_checkpoint.findall(config_source)
+ # Each `checkpoint` is a tuple of a checkpoint name and a checkpoint link.
+ # For example, `('google-bert/bert-base-uncased', 'https://huggingface.co/google-bert/bert-base-uncased')`
+ for ckpt_name, ckpt_link in checkpoints:
+ # allow the link to end with `/`
+ ckpt_link = ckpt_link.removesuffix("/")
+
+ # verify the checkpoint name corresponds to the checkpoint link
+ ckpt_link_from_name = f"https://huggingface.co/{ckpt_name}"
+ if ckpt_link == ckpt_link_from_name:
+ checkpoint = ckpt_name
+ break
+
+ return checkpoint
+
+
+def add_intro_docstring(func, class_name, indent_level=0):
+ intro_docstring = ""
+ if func.__name__ == "forward":
+ intro_docstring = rf"""The [`{class_name}`] forward method, overrides the `__call__` special method.
+
+ <Tip>
+
+ Although the recipe for forward pass needs to be defined within this function, one should call the [`Module`]
+ instance afterwards instead of this since the former takes care of running the pre and post processing steps while
+ the latter silently ignores them.
+
+ </Tip>
+
+ """
+ intro_docstring = equalize_indent(intro_docstring, indent_level + 4)
+
+ return intro_docstring
+
+
+def _get_model_info(func, parent_class):
+ """
+ Extract model information from a function or its parent class.
+
+ Args:
+ func (`function`): The function to extract information from
+ parent_class (`class`): Optional parent class of the function
+ """
+ # import here to avoid circular import
+ from transformers.models import auto as auto_module
+
+ # Get model name from either parent class or function
+ if parent_class is not None:
+ model_name_lowercase = get_model_name(parent_class)
+ else:
+ model_name_lowercase = get_model_name(func)
+
+ # Normalize model name if needed
+ if model_name_lowercase and model_name_lowercase not in getattr(
+ getattr(auto_module, PLACEHOLDER_TO_AUTO_MODULE["config_class"][0]),
+ PLACEHOLDER_TO_AUTO_MODULE["config_class"][1],
+ ):
+ model_name_lowercase = model_name_lowercase.replace("_", "-")
+
+ # Get class name from function's qualified name
+ class_name = func.__qualname__.split(".")[0]
+
+ # Get config class for the model
+ if model_name_lowercase is None:
+ config_class = None
+ else:
+ try:
+ config_class = getattr(
+ getattr(auto_module, PLACEHOLDER_TO_AUTO_MODULE["config_class"][0]),
+ PLACEHOLDER_TO_AUTO_MODULE["config_class"][1],
+ )[model_name_lowercase]
+ except KeyError:
+ if model_name_lowercase in HARDCODED_CONFIG_FOR_MODELS:
+ config_class = HARDCODED_CONFIG_FOR_MODELS[model_name_lowercase]
+ else:
+ config_class = "ModelConfig"
+ print(
+ f"[ERROR] Config not found for {model_name_lowercase}. You can manually add it to HARDCODED_CONFIG_FOR_MODELS in utils/auto_docstring.py"
+ )
+ return model_name_lowercase, class_name, config_class
+
+
+def _format_type_annotation_recursive(type_hint):
+ """
+ Recursively format a type annotation object as a string, preserving generic type arguments.
+
+ This is an internal helper used by process_type_annotation for the type object path.
+
+ Args:
+ type_hint: A type annotation object
+
+ Returns:
+ str: Formatted type string
+ """
+ # Handle special cases
+ if type_hint is type(...) or type_hint is Ellipsis:
+ return "..."
+ # Note: NoneType handling is done later to preserve "NoneType" in Union[] but "None" in | syntax
+
+ # Check if this is a generic type (e.g., list[str], dict[str, int])
+ origin = get_origin(type_hint)
+ args = get_args(type_hint)
+
+ if origin is not None and args:
+ # This is a generic type - format it with its arguments
+ # Get the origin type name
+ if hasattr(origin, "__module__") and hasattr(origin, "__name__"):
+ # Clean up module name - need to handle both 'typing.' prefix and just 'typing'
+ module_name = origin.__module__
+ if module_name in ("typing", "types", "builtins"):
+ module_name = ""
+ else:
+ module_name = (
+ module_name.replace("transformers.", "~")
+ .replace("typing.", "")
+ .replace("types.", "")
+ .replace("builtins.", "")
+ )
+
+ if module_name:
+ origin_str = f"{module_name}.{origin.__name__}"
+ else:
+ origin_str = origin.__name__
+ else:
+ origin_str = str(origin)
+
+ # Handle special origin types
+ if origin_str == "UnionType":
+ # Python 3.13's X | Y syntax - format it nicely
+ arg_strs = [_format_type_annotation_recursive(arg) for arg in args]
+ return " | ".join(arg_strs)
+
+ # Special handling for Annotated[Union[...], ...] and Annotated[UnionType[...], ...]
+ # Check if first arg is a Union/UnionType and format it specially
+ if origin_str == "Annotated" and args:
+ first_arg_origin = get_origin(args[0])
+ # Check if it's a UnionType (modern | syntax) or Union (old Union[] syntax)
+ if first_arg_origin is UnionType:
+ # Modern union type - format as X | Y | Z (with None not NoneType)
+ union_args = get_args(args[0])
+ union_strs = []
+ for arg in union_args:
+ if arg is type(None):
+ union_strs.append("None") # Modern syntax uses "None"
+ else:
+ union_strs.append(_format_type_annotation_recursive(arg))
+ formatted_union = " | ".join(union_strs)
+ # Include the rest of the Annotated metadata
+ remaining_args = [_format_type_annotation_recursive(arg) for arg in args[1:]]
+ all_args = [formatted_union] + remaining_args
+ return f"{origin_str}[{', '.join(all_args)}]"
+ elif first_arg_origin is Union:
+ # Old-style Union - format as Union[X, Y, Z]
+ union_args = get_args(args[0])
+ union_strs = [_format_type_annotation_recursive(arg) for arg in union_args]
+ formatted_union = f"Union[{', '.join(union_strs)}]"
+ # Include the rest of the Annotated metadata
+ remaining_args = [_format_type_annotation_recursive(arg) for arg in args[1:]]
+ all_args = [formatted_union] + remaining_args
+ return f"{origin_str}[{', '.join(all_args)}]"
+
+ # Recursively format the generic arguments
+ arg_strs = [_format_type_annotation_recursive(arg) for arg in args]
+ return f"{origin_str}[{', '.join(arg_strs)}]"
+ elif hasattr(type_hint, "__module__") and hasattr(type_hint, "__name__"):
+ # Simple type with module and name
+ # Clean up module name - need to handle both 'typing.' prefix and just 'typing'
+ module_name = type_hint.__module__
+ if module_name in ("typing", "types", "builtins"):
+ module_name = ""
+ else:
+ module_name = (
+ module_name.replace("transformers.", "~")
+ .replace("typing.", "")
+ .replace("types.", "")
+ .replace("builtins.", "")
+ )
+
+ if module_name:
+ type_name = f"{module_name}.{type_hint.__name__}"
+ else:
+ type_name = type_hint.__name__
+
+ return type_name
+ else:
+ # Fallback to string representation
+ type_str = str(type_hint)
+ # Clean up ForwardRef
+ if "ForwardRef" in type_str:
+ type_str = _re_forward_ref.sub(r"\1", type_str)
+ # Clean up module prefixes
+ type_str = type_str.replace("typing.", "").replace("types.", "")
+ return type_str
+
+
+def process_type_annotation(type_input, param_name: str | None = None) -> tuple[str, bool]:
+ """
+ Unified function to process and format a parameter's type annotation.
+
+ This function intelligently handles both type objects (from inspect.Parameter.annotation)
+ and string representations of types. It will:
+ - Use type introspection when given a type object (preserves generic arguments)
+ - Parse string representations when that's all that's available
+ - Always return a formatted type string and optional flag
+
+ Handles various type representations including:
+ - Type objects with generics (e.g., list[str], Optional[int])
+ - Union types (both Union[X, Y] and X | Y syntax)
+ - Modern union syntax with | (e.g., "bool | None")
+ - Complex typing constructs (Union, Optional, Annotated, etc.)
+ - Generic types with brackets
+ - Class type strings
+ - Simple types and module paths
+
+ Args:
+ type_input: Either a type annotation object or a string representation of a type
+ param_name (`str | None`): The parameter name (used for legacy module path handling)
+
+ Returns:
+ tuple[str, bool]: (formatted_type_string, is_optional)
+ """
+ optional = False
+
+ # Path 1: Type object (best approach - preserves generic type information)
+ if not isinstance(type_input, str):
+ # Handle None type
+ if type_input is None or type_input is type(None):
+ return "None", True
+
+ # Handle Union types and modern UnionType (X | Y)
+ if get_origin(type_input) is Union or get_origin(type_input) is UnionType:
+ subtypes = get_args(type_input)
+ out_str = []
+ for subtype in subtypes:
+ if subtype is type(None):
+ optional = True
+ continue
+ formatted_type = _format_type_annotation_recursive(subtype)
+ out_str.append(formatted_type)
+
+ if not out_str:
+ return "", optional
+ elif len(out_str) == 1:
+ return out_str[0], optional
+ else:
+ return f"Union[{', '.join(out_str)}]", optional
+
+ # Single type (not a Union)
+ formatted_type = _format_type_annotation_recursive(type_input)
+ return formatted_type, optional
+
+ # Path 2: String representation (fallback when we only have strings)
+ param_type = type_input
+
+ # Handle Union types with | syntax
+ if " | " in param_type:
+ # Modern union syntax (e.g., "bool | None")
+ parts = [p.strip() for p in param_type.split(" | ")]
+ if "None" in parts:
+ optional = True
+ parts = [p for p in parts if p != "None"]
+ param_type = " | ".join(parts) if parts else ""
+ # Clean up module prefixes including typing
+ param_type = "".join(param_type.split("typing.")).replace("transformers.", "~").replace("builtins.", "")
+
+ elif "typing" in param_type or "Union[" in param_type or "Optional[" in param_type or "[" in param_type:
+ # Complex typing construct or generic type - clean up typing module references
+ param_type = "".join(param_type.split("typing.")).replace("transformers.", "~")
+
+ elif "<class '" in param_type:
+ # This is a class type like "<class 'module.ClassName'>" - should NOT append param_name
+ param_type = (
+ param_type.replace("transformers.", "~").replace("builtins.", "").replace("<class '", "").replace("'>", "")
+ )
+
+ else:
+ # Simple type or module path - only append param_name if it looks like a module path
+ # This is legacy behavior for backwards compatibility
+ if param_name and "." in param_type and not param_type.split(".")[-1][0].isupper():
+ # Looks like a module path ending with an attribute
+ param_type = f"{param_type.replace('transformers.', '~').replace('builtins', '')}.{param_name}"
+ else:
+ # Simple type name, don't append param_name
+ param_type = param_type.replace("transformers.", "~").replace("builtins.", "")
+
+ # Clean up ForwardRef
+ if "ForwardRef" in param_type:
+ param_type = _re_forward_ref.sub(r"\1", param_type)
+
+ # Handle Optional wrapper
+ if "Optional" in param_type:
+ param_type = _re_optional.sub(r"\1", param_type)
+ optional = True
+
+ return param_type, optional
+
+
+def _process_parameter_type(param):
+ """
+ Process and format a parameter's type annotation from an inspect.Parameter object.
+
+ Args:
+ param (`inspect.Parameter`): The parameter from the function signature
+
+ Returns:
+ tuple[str, bool]: (formatted_type_string, is_optional)
+ """
+ if param.annotation == inspect.Parameter.empty:
+ return "", False
+
+ # Use the unified function to process the type annotation
+ formatted_type, optional = process_type_annotation(param.annotation)
+
+ # Check if parameter has a default value (makes it optional)
+ if param.default is not inspect.Parameter.empty:
+ optional = True
+
+ return formatted_type, optional
+
+
+def _get_parameter_info(param_name, documented_params, source_args_dict, param_type, optional):
+ """
+ Get parameter documentation details from the appropriate source.
+ Tensor shape, optional status and description are taken from the custom docstring in priority if available.
+ Type is taken from the function signature first, then from the custom docstring if missing from the signature
+
+ Args:
+ param_name (`str`): Name of the parameter
+ documented_params (`dict`): Dictionary of documented parameters (manually specified in the docstring)
+ source_args_dict (`dict`): Default source args dictionary to use if not in documented_params
+ param_type (`str`): Current parameter type (may be updated)
+ optional (`bool`): Whether the parameter is optional (may be updated)
+ """
+ description = None
+ shape = None
+ shape_string = ""
+ is_documented = True
+ additional_info = None
+ optional_string = r", *optional*" if optional else ""
+
+ if param_name in documented_params:
+ # Parameter is documented in the function's docstring
+ if (
+ param_type == ""
+ and documented_params[param_name].get("type", None) is not None
+ or documented_params[param_name]["additional_info"]
+ ):
+ param_type = documented_params[param_name]["type"]
+ optional = documented_params[param_name]["optional"]
+ shape = documented_params[param_name].get("shape", None)
+ shape_string = shape if shape else ""
+ additional_info = documented_params[param_name]["additional_info"] or ""
+ description = f"{documented_params[param_name]['description']}\n"
+ elif param_name in source_args_dict:
+ # Parameter is documented in ModelArgs or ImageProcessorArgs
+ param_type = source_args_dict[param_name].get("type", param_type)
+ shape = source_args_dict[param_name].get("shape", None)
+ shape_string = " " + shape if shape else ""
+ description = source_args_dict[param_name]["description"]
+ additional_info = source_args_dict[param_name].get("additional_info", None)
+ if additional_info:
+ additional_info = shape_string + optional_string + ", " + additional_info
+ else:
+ # Parameter is not documented
+ is_documented = False
+
+ return param_type, optional_string, shape_string, additional_info, description, is_documented
+
+
+def _process_regular_parameters(
+ sig,
+ func,
+ class_name,
+ documented_params,
+ indent_level,
+ undocumented_parameters,
+ source_args_dict,
+ parent_class,
+ allowed_params=None,
+):
+ """
+ Process all regular parameters (not kwargs parameters) from the function signature.
+
+ Args:
+ sig (`inspect.Signature`): Function signature
+ func (`function`): Function the parameters belong to
+ class_name (`str`): Name of the class
+ documented_params (`dict`): Dictionary of parameters that are already documented
+ indent_level (`int`): Indentation level
+ undocumented_parameters (`list`): List to append undocumented parameters to
+ """
+ docstring = ""
+ # Check if this is a processor by inspecting class hierarchy
+ is_processor = _is_processor_class(func, parent_class)
+
+ # Use appropriate args source based on whether it's a processor or not
+ if source_args_dict is None:
+ if is_processor:
+ source_args_dict = get_args_doc_from_source([ModelArgs, ImageProcessorArgs, ProcessorArgs])
+ else:
+ source_args_dict = get_args_doc_from_source([ModelArgs, ImageProcessorArgs])
+
+ missing_args = {}
+
+ for param_name, param in sig.parameters.items():
+ # Skip parameters that should be ignored
+ if (
+ param_name in ARGS_TO_IGNORE
+ or param_name.startswith("_") # Private/internal params (e.g. ClassVar-backed fields in configs)
+ or param.kind == inspect.Parameter.VAR_POSITIONAL
+ or param.kind == inspect.Parameter.VAR_KEYWORD
+ ):
+ continue
+ # When a filter is active (e.g. config classes: only own annotations), skip inherited params
+ if allowed_params is not None and param_name not in allowed_params:
+ continue
+
+ # When a filter is active (e.g. config classes: only own annotations), skip inherited params
+ if allowed_params is not None and param_name not in allowed_params:
+ continue
+
+ param_name = ARGS_TO_RENAME.get(param_name, param_name)
+
+ # Process parameter type and optional status
+ param_type, optional = _process_parameter_type(param)
+
+ # Check for default value
+ param_default = ""
+ if param.default != inspect._empty and param.default is not None:
+ param_default = f", defaults to `{str(param.default)}`"
+
+ param_type, optional_string, shape_string, additional_info, description, is_documented = _get_parameter_info(
+ param_name, documented_params, source_args_dict, param_type, optional
+ )
+
+ if is_documented:
+ if param_name == "config":
+ if param_type == "":
+ param_type = f"[`{class_name}`]"
+ else:
+ param_type = f"[`{param_type.split('.')[-1]}`]"
+ # elif param_type == "" and False: # TODO: Enforce typing for all parameters
+ # print(f"[ERROR] {param_name} for {func.__qualname__} in file {func.__code__.co_filename} has no type")
+ param_type = param_type if "`" in param_type else f"`{param_type}`"
+ # Format the parameter docstring
+ if additional_info:
+ param_docstring = f"{param_name} ({param_type}{additional_info}):{description}"
+ else:
+ param_docstring = (
+ f"{param_name} ({param_type}{shape_string}{optional_string}{param_default}):{description}"
+ )
+ docstring += set_min_indent(
+ param_docstring,
+ indent_level + 8,
+ )
+ else:
+ missing_args[param_name] = {
+ "type": param_type if param_type else "<fill_type>",
+ "optional": optional,
+ "shape": shape_string,
+ "description": description if description else "\n <fill_description>",
+ "default": param_default,
+ }
+ # Try to get the correct source file; for classes decorated with @strict (huggingface_hub),
+ # func.__code__.co_filename points to the wrapper in huggingface_hub, not the config file.
+ try:
+ if parent_class is not None:
+ _source_file = inspect.getsourcefile(parent_class) or func.__code__.co_filename
+ else:
+ _source_file = inspect.getsourcefile(inspect.unwrap(func)) or func.__code__.co_filename
+ except (TypeError, OSError):
+ _source_file = func.__code__.co_filename
+ undocumented_parameters.append(
+ f"[ERROR] `{param_name}` is part of {func.__qualname__}'s signature, but not documented. Make sure to add it to the docstring of the function in {_source_file}."
+ )
+
+ return docstring, missing_args
+
+
+def find_sig_line(lines, line_end):
+ parenthesis_count = 0
+ sig_line_end = line_end
+ found_sig = False
+ while not found_sig:
+ for char in lines[sig_line_end]:
+ if char == "(":
+ parenthesis_count += 1
+ elif char == ")":
+ parenthesis_count -= 1
+ if parenthesis_count == 0:
+ found_sig = True
+ break
+ sig_line_end += 1
+ return sig_line_end
+
+
+def _is_image_processor_class(func, parent_class):
+ """
+ Check if a function belongs to a ProcessorMixin class.
+
+ Uses two methods:
+ 1. Check parent_class inheritance (if provided)
+ 2. Check if the source file is named processing_*.py (multimodal processors)
+ vs image_processing_*.py, video_processing_*.py, etc. (single-modality processors)
+
+ Args:
+ func: The function to check
+ parent_class: Optional parent class (if available)
+
+ Returns:
+ bool: True if this is a multimodal processor (inherits from ProcessorMixin), False otherwise
+ """
+ # First, check if parent_class is provided and use it
+ if parent_class is not None:
+ return "BaseImageProcessor" in parent_class.__name__ or any(
+ "BaseImageProcessor" in base.__name__ for base in parent_class.__mro__
+ )
+
+ # If parent_class is None, check the filename
+ # Multimodal processors are in files named "processing_*.py"
+ # Single-modality processors are in "image_processing_*.py", "video_processing_*.py", etc.
+ try:
+ source_file = inspect.getsourcefile(func)
+ except TypeError:
+ return False
+ if not source_file:
+ return False
+
+ # Exception for DummyProcessorForTest
+ if func.__qualname__.split(".")[0] == "DummyForTestImageProcessorFast":
+ return True
+
+ filename = os.path.basename(source_file)
+
+ # Multimodal processors are implemented in processing_*.py modules
+ # (single-modality processors use image_processing_*, video_processing_*, etc.)self.
+ return filename.startswith("image_processing_") and filename.endswith(".py")
+
+
+def _is_processor_class(func, parent_class):
+ """
+ Check if a function belongs to a ProcessorMixin class.
+
+ Uses two methods:
+ 1. Check parent_class inheritance (if provided)
+ 2. Check if the source file is named processing_*.py (multimodal processors)
+ vs image_processing_*.py, video_processing_*.py, etc. (single-modality processors)
+
+ Args:
+ func: The function to check
+ parent_class: Optional parent class (if available)
+
+ Returns:
+ bool: True if this is a multimodal processor (inherits from ProcessorMixin), False otherwise
+ """
+ # First, check if parent_class is provided and use it
+ if parent_class is not None:
+ return "ProcessorMixin" in parent_class.__name__ or any(
+ "ProcessorMixin" in base.__name__ for base in parent_class.__mro__
+ )
+
+ # If parent_class is None, check the filename
+ # Multimodal processors are in files named "processing_*.py"
+ # Single-modality processors are in "image_processing_*.py", "video_processing_*.py", etc.
+ try:
+ source_file = inspect.getsourcefile(func)
+ except TypeError:
+ return False
+ if not source_file:
+ return False
+
+ # Exception for DummyProcessorForTest
+ if func.__qualname__.split(".")[0] == "DummyProcessorForTest":
+ return True
+
+ filename = os.path.basename(source_file)
+
+ # Multimodal processors are implemented in processing_*.py modules
+ # (single-modality processors use image_processing_*, video_processing_*, etc.)self.
+ return filename.startswith("processing_") and filename.endswith(".py")
+
+
+# Python < 3.12 fallback: naming heuristics when __orig_bases__ is not set (cpython#103699).
+# Order matters: check ImageProcessorKwargs before ProcessorKwargs.
+_BASIC_KWARGS_NAMES = frozenset({"ImagesKwargs", "ProcessingKwargs", "TextKwargs", "VideosKwargs", "AudioKwargs"})
+_BASIC_KWARGS_CLASSES = None # Lazy-loaded name -> class mapping
+
+
+def _get_base_kwargs_class_from_name(cls_name: str) -> str | None:
+ """Map kwargs class name to base using naming conventions. Returns base class name or None."""
+ if cls_name in _BASIC_KWARGS_NAMES:
+ return cls_name
+ if "ImageProcessorKwargs" in cls_name or cls_name.endswith("ImagesKwargs"):
+ return "ImagesKwargs"
+ if "ProcessorKwargs" in cls_name:
+ return "ProcessingKwargs"
+ if "VideoProcessorKwargs" in cls_name or cls_name.endswith("VideosKwargs"):
+ return "VideosKwargs"
+ if "AudioProcessorKwargs" in cls_name or cls_name.endswith("AudioKwargs"):
+ return "AudioKwargs"
+ if "TextKwargs" in cls_name:
+ return "TextKwargs"
+ return None
+
+
+def _get_base_kwargs_class(cls):
+ """
+ Get the root/base TypedDict class by walking the inheritance chain.
+ For model-specific kwargs like ComplexProcessingKwargs(ProcessingKwargs), returns ProcessingKwargs.
+ For model-specific kwargs like DummyImageProcessorKwargs(ImagesKwargs), returns ImagesKwargs.
+
+ Compatibility: On Python < 3.12, non-generic TypedDict subclasses do not have __orig_bases__ set
+ (cpython#103699). We fall back to naming heuristics (e.g. *ImageProcessorKwargs -> ImagesKwargs).
+ """
+ current = cls
+ while True:
+ bases = typing_extensions.get_original_bases(current)
+ parent = None
+ for base in bases:
+ if isinstance(base, type) and base not in (dict, object):
+ if getattr(base, "__name__", "") == "TypedDict" and getattr(base, "__module__", "") == "typing":
+ continue
+ parent = base
+ break
+ if parent is None:
+ # Python < 3.12 fallback: use naming heuristics
+ base_name = _get_base_kwargs_class_from_name(current.__name__)
+ if base_name is not None:
+ global _BASIC_KWARGS_CLASSES
+ if _BASIC_KWARGS_CLASSES is None:
+ from transformers.processing_utils import (
+ AudioKwargs,
+ ImagesKwargs,
+ ProcessingKwargs,
+ TextKwargs,
+ VideosKwargs,
+ )
+
+ _BASIC_KWARGS_CLASSES = {
+ "ImagesKwargs": ImagesKwargs,
+ "ProcessingKwargs": ProcessingKwargs,
+ "TextKwargs": TextKwargs,
+ "VideosKwargs": VideosKwargs,
+ "AudioKwargs": AudioKwargs,
+ }
+ parent = _BASIC_KWARGS_CLASSES[base_name]
+ if parent is None or parent == current:
+ return current
+ current = parent
+
+
+def _process_kwargs_parameters(sig, func, parent_class, documented_kwargs, indent_level, undocumented_parameters):
+ """
+ Process **kwargs parameters if needed.
+
+ Args:
+ sig (`inspect.Signature`): Function signature
+ func (`function`): Function the parameters belong to
+ parent_class (`class`): Parent class of the function
+ documented_kwargs (`dict`): Dictionary of kwargs that are already documented
+ indent_level (`int`): Indentation level
+ undocumented_parameters (`list`): List to append undocumented parameters to
+
+ Returns:
+ tuple[str, str]: (kwargs docstring, kwargs summary line to add after return_tensors)
+ """
+ docstring = ""
+ kwargs_summary = ""
+ # Check if we need to add typed kwargs description to the docstring
+ unroll_kwargs = func.__name__ in UNROLL_KWARGS_METHODS
+ if not unroll_kwargs and parent_class is not None:
+ # Check if the function has a parent class with unroll kwargs
+ unroll_kwargs = any(
+ any(unroll_kwargs_class in base.__name__ for base in parent_class.__mro__)
+ for unroll_kwargs_class in UNROLL_KWARGS_CLASSES
+ )
+ if not unroll_kwargs:
+ return docstring, kwargs_summary
+
+ # Check if this is a processor by inspecting class hierarchy
+ is_processor = _is_processor_class(func, parent_class)
+ is_image_processor = _is_image_processor_class(func, parent_class)
+
+ # Use appropriate args source based on whether it's a processor or not
+ if is_processor:
+ source_args_dict = get_args_doc_from_source([ImageProcessorArgs, ProcessorArgs])
+ elif is_image_processor:
+ source_args_dict = get_args_doc_from_source(ImageProcessorArgs)
+ else:
+ raise ValueError(
+ f"Unrolling kwargs is not supported for {func.__name__} of {parent_class.__name__ if parent_class else 'None'} class"
+ )
+
+ # get all unpackable "kwargs" parameters
+ kwargs_parameters = [
+ kwargs_param
+ for _, kwargs_param in sig.parameters.items()
+ if kwargs_param.kind == inspect.Parameter.VAR_KEYWORD
+ ]
+ for kwarg_param in kwargs_parameters:
+ # If kwargs not typed, skip
+ if kwarg_param.annotation == inspect.Parameter.empty:
+ continue
+
+ if not hasattr(kwarg_param.annotation, "__args__") or not hasattr(
+ kwarg_param.annotation.__args__[0], "__name__"
+ ):
+ continue
+
+ if kwarg_param.annotation.__args__[0].__name__ not in BASIC_KWARGS_TYPES:
+ # Extract documentation for kwargs
+ kwargs_documentation = kwarg_param.annotation.__args__[0].__doc__
+ if kwargs_documentation is not None:
+ documented_kwargs = parse_docstring(kwargs_documentation)[0]
+ # Process each kwarg parameter
+ for param_name, param_type_annotation in kwarg_param.annotation.__args__[0].__annotations__.items():
+ # Handle nested kwargs structures for processors
+
+ if is_processor and param_name.endswith("_kwargs"):
+ # Check if this is a basic kwargs type that should be skipped
+ # Basic kwargs types are generic containers that shouldn't be documented as individual params
+
+ # Get the actual type (unwrap Optional if needed)
+ actual_type = param_type_annotation
+ type_name = getattr(param_type_annotation, "__name__", None)
+ if type_name is None and hasattr(param_type_annotation, "__origin__"):
+ # Handle Optional[Type] or Union cases
+ args = getattr(param_type_annotation, "__args__", ())
+ for arg in args:
+ if arg is not type(None):
+ actual_type = arg
+ type_name = getattr(arg, "__name__", None)
+ break
+
+ # Skip only if it's one of the basic kwargs types
+ if type_name in BASIC_KWARGS_TYPES:
+ continue
+
+ # Otherwise, unroll the custom typed kwargs
+ # Get the nested TypedDict's annotations
+ if hasattr(actual_type, "__annotations__"):
+ nested_kwargs_doc = getattr(actual_type, "__doc__", None)
+ documented_nested_kwargs = {}
+ if nested_kwargs_doc:
+ documented_nested_kwargs = parse_docstring(nested_kwargs_doc)[0]
+
+ # Only process fields that are documented in the custom kwargs class's own docstring
+ # This prevents showing too many inherited parameters
+ if not documented_nested_kwargs:
+ # No documentation in the custom kwargs class, skip unrolling
+ continue
+
+ # Process each field in the custom typed kwargs
+ for nested_param_name, nested_param_type in actual_type.__annotations__.items():
+ # Only document parameters that are explicitly documented in the TypedDict's docstring
+ if nested_param_name not in documented_nested_kwargs:
+ continue
+ nested_param_type_str, nested_optional = process_type_annotation(
+ nested_param_type, nested_param_name
+ )
+
+ # Check for default value
+ nested_param_default = ""
+ if parent_class is not None:
+ nested_param_default = str(getattr(parent_class, nested_param_name, ""))
+ nested_param_default = (
+ f", defaults to `{nested_param_default}`" if nested_param_default != "" else ""
+ )
+
+ # Only use the TypedDict's own docstring, not source_args_dict
+ # This prevents pulling in too many inherited parameters
+ (
+ nested_param_type_str,
+ nested_optional_string,
+ nested_shape_string,
+ nested_additional_info,
+ nested_description,
+ nested_is_documented,
+ ) = _get_parameter_info(
+ nested_param_name,
+ documented_nested_kwargs,
+ {}, # Empty dict - only use TypedDict's own docstring
+ nested_param_type_str,
+ nested_optional,
+ )
+
+ # nested_is_documented should always be True here since we filter for it above
+ # Check if type is missing
+ if nested_param_type_str == "":
+ print(
+ f"🚨 {nested_param_name} for {type_name} in file {func.__code__.co_filename} has no type"
+ )
+ nested_param_type_str = (
+ nested_param_type_str if "`" in nested_param_type_str else f"`{nested_param_type_str}`"
+ )
+ # Format the parameter docstring (KWARGS_INDICATOR distinguishes from regular args)
+ if nested_additional_info:
+ docstring += set_min_indent(
+ f"{nested_param_name} ({nested_param_type_str}{KWARGS_INDICATOR}{nested_additional_info}):{nested_description}",
+ indent_level + 8,
+ )
+ else:
+ docstring += set_min_indent(
+ f"{nested_param_name} ({nested_param_type_str}{KWARGS_INDICATOR}{nested_shape_string}{nested_optional_string}{nested_param_default}):{nested_description}",
+ indent_level + 8,
+ )
+
+ # Skip processing the _kwargs parameter itself since we've processed its contents
+ continue
+ else:
+ # If we can't get annotations, skip this parameter
+ continue
+
+ if documented_kwargs and param_name not in documented_kwargs:
+ continue
+ param_type, optional = process_type_annotation(param_type_annotation, param_name)
+
+ # Check for default value
+ param_default = ""
+ if parent_class is not None:
+ param_default = str(getattr(parent_class, param_name, ""))
+ param_default = f", defaults to `{param_default}`" if param_default != "" else ""
+
+ param_type, optional_string, shape_string, additional_info, description, is_documented = (
+ _get_parameter_info(param_name, documented_kwargs, source_args_dict, param_type, optional)
+ )
+
+ if is_documented:
+ # Check if type is missing
+ if param_type == "":
+ print(
+ f"[ERROR] {param_name} for {kwarg_param.annotation.__args__[0].__qualname__} in file {func.__code__.co_filename} has no type"
+ )
+ param_type = param_type if "`" in param_type else f"`{param_type}`"
+ # Format the parameter docstring (KWARGS_INDICATOR distinguishes from regular args)
+ if additional_info:
+ docstring += set_min_indent(
+ f"{param_name} ({param_type}{KWARGS_INDICATOR}{additional_info}):{description}",
+ indent_level + 8,
+ )
+ else:
+ docstring += set_min_indent(
+ f"{param_name} ({param_type}{KWARGS_INDICATOR}{shape_string}{optional_string}{param_default}):{description}",
+ indent_level + 8,
+ )
+ else:
+ undocumented_parameters.append(
+ f"[ERROR] `{param_name}` is part of {kwarg_param.annotation.__args__[0].__qualname__}, but not documented. Make sure to add it to the docstring of the function in {func.__code__.co_filename}."
+ )
+
+ # Build **kwargs summary line (added after return_tensors in _process_parameters_section)
+ kwargs_annot_cls = kwarg_param.annotation.__args__[0]
+ kwargs_type_name = _get_base_kwargs_class(kwargs_annot_cls).__name__
+ kwargs_info = source_args_dict.get("__kwargs__", {})
+ kwargs_description = kwargs_info.get(
+ "description",
+ "Additional keyword arguments. Model-specific parameters are listed above.",
+ )
+ kwargs_summary = set_min_indent(
+ f"**kwargs ([`{kwargs_type_name}`], *optional*):{kwargs_description}",
+ indent_level + 8,
+ )
+
+ return docstring, kwargs_summary
+
+
+def _add_return_tensors_to_docstring(func, parent_class, docstring, indent_level):
+ """
+ Add return_tensors parameter documentation for processor __call__ methods if not already present.
+
+ Args:
+ func (`function`): Function being processed
+ parent_class (`class`): Parent class of the function
+ docstring (`str`): Current docstring being built
+ indent_level (`int`): Indentation level
+
+ Returns:
+ str: Updated docstring with return_tensors if applicable
+ """
+ # Check if this is a processor __call__ method or an image processor preprocess method
+ is_processor_call = False
+ is_image_processor_preprocess = False
+ if func.__name__ == "__call__":
+ # Check if this is a processor by inspecting class hierarchy
+ is_processor_call = _is_processor_class(func, parent_class)
+
+ if func.__name__ == "preprocess":
+ is_image_processor_preprocess = _is_image_processor_class(func, parent_class)
+
+ # If it's a processor __call__ method or an image processor preprocess method and return_tensors is not already documented
+ if (is_processor_call or is_image_processor_preprocess) and "return_tensors" not in docstring:
+ # Get the return_tensors documentation from ImageProcessorArgs
+ source_args_dict = (
+ get_args_doc_from_source(ProcessorArgs)
+ if is_processor_call
+ else get_args_doc_from_source(ImageProcessorArgs)
+ )
+ return_tensors_info = source_args_dict["return_tensors"]
+ param_type = return_tensors_info.get("type", "`str` or [`~utils.TensorType`]")
+ description = return_tensors_info["description"]
+
+ # Format the parameter type
+ param_type = param_type if "`" in param_type else f"`{param_type}`"
+
+ # Format the parameter docstring
+ param_docstring = f"return_tensors ({param_type}, *optional*):{description}"
+ docstring += set_min_indent(param_docstring, indent_level + 8)
+
+ return docstring
+
+
+def _process_parameters_section(
+ func_documentation,
+ sig,
+ func,
+ class_name,
+ model_name_lowercase,
+ parent_class,
+ indent_level,
+ source_args_dict,
+ allowed_params,
+):
+ """
+ Process the parameters section of the docstring.
+
+ Args:
+ func_documentation (`str`): Existing function documentation (manually specified in the docstring)
+ sig (`inspect.Signature`): Function signature
+ func (`function`): Function the parameters belong to
+ class_name (`str`): Name of the class the function belongs to
+ model_name_lowercase (`str`): Lowercase model name
+ parent_class (`class`): Parent class of the function (if any)
+ indent_level (`int`): Indentation level
+ """
+ # Start Args section — constant string, min_indent is always 0, so skip set_min_indent
+ docstring = " " * (indent_level + 4) + "Args:\n"
+ undocumented_parameters = []
+ documented_params = {}
+ documented_kwargs = {}
+
+ # Parse existing docstring if available
+ if func_documentation is not None:
+ documented_params, func_documentation = parse_docstring(func_documentation)
+
+ # Process regular parameters
+ param_docstring, missing_args = _process_regular_parameters(
+ sig,
+ func,
+ class_name,
+ documented_params,
+ indent_level,
+ undocumented_parameters,
+ source_args_dict,
+ parent_class,
+ allowed_params,
+ )
+ docstring += param_docstring
+
+ # Process **kwargs parameters if needed
+ kwargs_docstring, kwargs_summary = _process_kwargs_parameters(
+ sig, func, parent_class, documented_kwargs, indent_level, undocumented_parameters
+ )
+ docstring += kwargs_docstring
+
+ # Add return_tensors for processor __call__ methods if not already present
+ docstring = _add_return_tensors_to_docstring(func, parent_class, docstring, indent_level)
+
+ # Add **kwargs summary line after return_tensors
+ docstring += kwargs_summary
+
+ # Report undocumented parameters
+ if len(undocumented_parameters) > 0:
+ print("\n".join(undocumented_parameters))
+
+ return docstring
+
+
+def _prepare_return_docstring(output_type, config_class, add_intro=True):
+ """
+ Prepare the return docstring from a ModelOutput class.
+
+ This is a robust replacement for the old _prepare_output_docstrings from doc.py,
+ using the same parsing and formatting methods as the rest of auto_docstring.
+
+ Args:
+ output_type: The ModelOutput class to generate documentation for
+ config_class (`str`): Config class for the model
+ add_intro (`bool`): Whether to add the introduction text
+
+ Returns:
+ str: Formatted return docstring
+ """
+ output_docstring = output_type.__doc__
+
+ # If the class has no docstring, try to use the parent class's docstring
+ if output_docstring is None and hasattr(output_type, "__mro__"):
+ for base in output_type.__mro__[1:]: # Skip the class itself
+ if base.__doc__ is not None:
+ output_docstring = base.__doc__
+ break
+
+ if output_docstring is None:
+ if add_intro:
+ raise ValueError(
+ f"No docstring found for `{output_type.__name__}` or its parent classes. "
+ "Make sure the ModelOutput class or one of its parents has a docstring."
+ )
+ return ""
+
+ # Parse the output class docstring to extract parameters
+ documented_params, _ = parse_docstring(output_docstring)
+
+ if not documented_params and add_intro:
+ raise ValueError(
+ f"No `Args` or `Parameters` section is found in the docstring of `{output_type.__name__}`. "
+ "Make sure it has a docstring and contains either `Args` or `Parameters`."
+ )
+
+ # Build the return section
+ full_output_type, _ = process_type_annotation(output_type)
+ if add_intro:
+ # Import here to avoid circular import
+ from .doc import PT_RETURN_INTRODUCTION
+
+ intro = PT_RETURN_INTRODUCTION.format(full_output_type=full_output_type, config_class=config_class)
+ else:
+ intro = f"Returns:\n `{full_output_type}`"
+ if documented_params:
+ intro += ":\n"
+ else:
+ intro += "\n"
+
+ # Build the parameters section
+ params_text = ""
+ if documented_params:
+ for param_name, param_info in documented_params.items():
+ param_type = param_info.get("type", "")
+ param_description = param_info.get("description", "").strip()
+ additional_info = param_info.get("additional_info", "")
+
+ # Handle types with unbalanced backticks due to nested parentheses
+ # The parse_docstring function splits types like `tuple(torch.FloatTensor)` incorrectly
+ # so we need to reconstruct the complete type by grabbing the closing part from additional_info
+ if param_type.startswith("`") and not param_type.endswith("`"):
+ # Find the closing backtick in additional_info
+ closing_backtick_idx = additional_info.find("`")
+ if closing_backtick_idx != -1:
+ # Grab everything up to and including the closing backtick
+ param_type += additional_info[: closing_backtick_idx + 1]
+ # Remove that part from additional_info
+ additional_info = additional_info[closing_backtick_idx + 1 :]
+
+ # Strip backticks from type to add them back consistently
+ param_type = param_type.strip("`")
+
+ # Use process_type_annotation to ensure consistent type formatting
+ # This applies the same formatting rules as the rest of auto_docstring
+ if param_type:
+ param_type, _ = process_type_annotation(param_type)
+
+ # Build the parameter line
+ if additional_info:
+ # additional_info contains shape and optional status
+ param_line = f"- **{param_name}** (`{param_type}`{additional_info}) -- {param_description}"
+ else:
+ param_line = f"- **{param_name}** (`{param_type}`) -- {param_description}"
+
+ # Handle multi-line descriptions:
+ # Split the description to handle continuations with proper indentation
+ lines = param_line.split("\n")
+ formatted_lines = []
+ for i, line in enumerate(lines):
+ if i == 0:
+ # First line gets no extra indent (just the bullet point)
+ formatted_lines.append(line)
+ else:
+ # Continuation lines: strip existing indentation and add 2 spaces (relative to the bullet)
+ formatted_lines.append(" " + line.lstrip())
+
+ param_text = "\n".join(formatted_lines)
+
+ # Indent everything to 4 spaces and append with newline
+ param_text_indented = set_min_indent(param_text, 4)
+ params_text += param_text_indented + "\n"
+
+ result = intro + params_text
+
+ return result
+
+
+def _process_returns_section(func_documentation, sig, config_class, indent_level):
+ """
+ Process the returns section of the docstring.
+
+ Args:
+ func_documentation (`str`): Existing function documentation (manually specified in the docstring)
+ sig (`inspect.Signature`): Function signature
+ config_class (`str`): Config class for the model
+ indent_level (`int`): Indentation level
+ """
+ return_docstring = ""
+
+ # Extract returns section from existing docstring if available
+ if func_documentation is not None and (match_start := _re_return.search(func_documentation)) is not None:
+ match_end = _re_example.search(func_documentation)
+ if match_end:
+ return_docstring = func_documentation[match_start.start() : match_end.start()]
+ func_documentation = func_documentation[match_end.start() :]
+ else:
+ return_docstring = func_documentation[match_start.start() :]
+ func_documentation = ""
+ return_docstring = set_min_indent(return_docstring, indent_level + 4)
+ # Otherwise, generate return docstring from return annotation if available
+ elif sig.return_annotation is not None and sig.return_annotation != inspect._empty:
+ add_intro, return_annotation = contains_type(sig.return_annotation, ModelOutput)
+ return_docstring = _prepare_return_docstring(return_annotation, config_class, add_intro=add_intro)
+ # PT_RETURN_INTRODUCTION already starts with \n, so only add blank line if it doesn't start with one
+ if not return_docstring.startswith("\n"):
+ return_docstring = "\n" + return_docstring
+ return_docstring = set_min_indent(return_docstring, indent_level + 4)
+
+ return return_docstring, func_documentation
+
+
+def _process_example_section(
+ func_documentation, func, parent_class, class_name, model_name_lowercase, config_class, checkpoint, indent_level
+):
+ """
+ Process the example section of the docstring.
+
+ Args:
+ func_documentation (`str`): Existing function documentation (manually specified in the docstring)
+ func (`function`): Function being processed
+ parent_class (`class`): Parent class of the function
+ class_name (`str`): Name of the class
+ model_name_lowercase (`str`): Lowercase model name
+ config_class (`str`): Config class for the model
+ checkpoint: Checkpoint to use in examples
+ indent_level (`int`): Indentation level
+ """
+ # Import here to avoid circular import
+ from transformers.models import auto as auto_module
+
+ example_docstring = ""
+
+ # Use existing example section if available (with or without an "Example:" header)
+ if func_documentation is not None and (match := _re_example.search(func_documentation)):
+ example_docstring = func_documentation[match.start() :]
+ example_docstring = "\n" + set_min_indent(example_docstring, indent_level + 4)
+ # Skip examples for processors
+ elif _is_processor_class(func, parent_class):
+ # Processors don't get auto-generated examples
+ return example_docstring
+ # No examples for __init__ methods or if the class is not a model
+ elif parent_class is None and model_name_lowercase is not None:
+ global _re_model_task
+ if _re_model_task is None:
+ _re_model_task = re.compile(rf"({'|'.join(PT_SAMPLE_DOCSTRINGS.keys())})")
+ model_task = _re_model_task.search(class_name)
+ CONFIG_MAPPING = auto_module.configuration_auto.CONFIG_MAPPING
+
+ # Get checkpoint example
+ if (checkpoint_example := checkpoint) is None:
+ try:
+ checkpoint_example = get_checkpoint_from_config_class(CONFIG_MAPPING[model_name_lowercase])
+ except KeyError:
+ # For models with inconsistent lowercase model name
+ if model_name_lowercase in HARDCODED_CONFIG_FOR_MODELS:
+ CONFIG_MAPPING_NAMES = auto_module.configuration_auto.CONFIG_MAPPING_NAMES
+ config_class_name = HARDCODED_CONFIG_FOR_MODELS[model_name_lowercase]
+ if config_class_name in CONFIG_MAPPING_NAMES.values():
+ model_name_for_auto_config = [
+ k for k, v in CONFIG_MAPPING_NAMES.items() if v == config_class_name
+ ][0]
+ if model_name_for_auto_config in CONFIG_MAPPING:
+ checkpoint_example = get_checkpoint_from_config_class(
+ CONFIG_MAPPING[model_name_for_auto_config]
+ )
+
+ # Add example based on model task
+ if model_task is not None:
+ if checkpoint_example is not None:
+ example_annotation = ""
+ task = model_task.group()
+ example_annotation = PT_SAMPLE_DOCSTRINGS[task].format(
+ model_class=class_name,
+ checkpoint=checkpoint_example,
+ expected_output="...",
+ expected_loss="...",
+ qa_target_start_index=14,
+ qa_target_end_index=15,
+ mask="<mask>",
+ )
+ example_docstring = set_min_indent(example_annotation, indent_level + 4)
+ else:
+ print(
+ f"[ERROR] No checkpoint found for {class_name}.{func.__name__}. Please add a `checkpoint` arg to `auto_docstring` or add one in {config_class}'s docstring"
+ )
+ else:
+ # Check if the model is in a pipeline to get an example
+ for name_model_list_for_task in MODELS_TO_PIPELINE:
+ try:
+ model_list_for_task = getattr(auto_module.modeling_auto, name_model_list_for_task)
+ except (ImportError, AttributeError):
+ continue
+ if class_name in model_list_for_task.values():
+ pipeline_name = MODELS_TO_PIPELINE[name_model_list_for_task]
+ example_annotation = PIPELINE_TASKS_TO_SAMPLE_DOCSTRINGS[pipeline_name].format(
+ model_class=class_name,
+ checkpoint=checkpoint_example,
+ expected_output="...",
+ expected_loss="...",
+ qa_target_start_index=14,
+ qa_target_end_index=15,
+ )
+ example_docstring = set_min_indent(example_annotation, indent_level + 4)
+ break
+
+ return example_docstring
+
+
+def auto_method_docstring(
+ func,
+ parent_class=None,
+ custom_intro=None,
+ custom_args=None,
+ checkpoint=None,
+ source_args_dict=None,
+ allowed_params=None,
+):
+ """
+ Wrapper that automatically generates docstring.
+ """
+
+ # Use inspect to retrieve the method's signature
+ sig = inspect.signature(func)
+ indent_level = get_indent_level(func) if not parent_class else get_indent_level(parent_class)
+
+ # Get model information
+ model_name_lowercase, class_name, config_class = _get_model_info(func, parent_class)
+ func_documentation = func.__doc__
+
+ if custom_args is not None and func_documentation is not None:
+ func_documentation = "\n" + set_min_indent(custom_args.strip("\n"), 0) + "\n" + func_documentation
+ elif custom_args is not None:
+ func_documentation = "\n" + set_min_indent(custom_args.strip("\n"), 0)
+
+ # Add intro to the docstring before args description if needed
+ if custom_intro is not None:
+ docstring = set_min_indent(custom_intro, indent_level + 4)
+ if not docstring.strip().endswith("\n"):
+ docstring += "\n"
+ else:
+ docstring = add_intro_docstring(func, class_name=class_name, indent_level=indent_level)
+
+ # Process Parameters section
+ docstring += _process_parameters_section(
+ func_documentation,
+ sig,
+ func,
+ class_name,
+ model_name_lowercase,
+ parent_class,
+ indent_level,
+ source_args_dict,
+ allowed_params,
+ )
+
+ # Process Returns section
+ return_docstring, func_documentation = _process_returns_section(
+ func_documentation, sig, config_class, indent_level
+ )
+ docstring += return_docstring
+
+ # Process Example section
+ example_docstring = _process_example_section(
+ func_documentation,
+ func,
+ parent_class,
+ class_name,
+ model_name_lowercase,
+ config_class,
+ checkpoint,
+ indent_level,
+ )
+ docstring += example_docstring
+
+ # Format the docstring with the placeholders
+ docstring = format_args_docstring(docstring, model_name_lowercase)
+
+ # Assign the dynamically generated docstring to the wrapper function
+ func.__doc__ = docstring
+ return func
+
+
+def auto_class_docstring(cls, custom_intro=None, custom_args=None, checkpoint=None):
+ """
+ Wrapper that automatically generates a docstring for classes based on their attributes and methods.
+ """
+ # import here to avoid circular import
+ from transformers.models import auto as auto_module
+
+ is_dataclass = False
+ is_processor = False
+ is_config = False
+ is_image_processor = False
+ docstring_init = ""
+ docstring_args = ""
+ if "PreTrainedModel" in (x.__name__ for x in cls.__mro__):
+ docstring_init = auto_method_docstring(
+ cls.__init__, parent_class=cls, custom_args=custom_args, checkpoint=checkpoint
+ ).__doc__.replace("Args:", "Parameters:")
+ elif "ProcessorMixin" in (x.__name__ for x in cls.__mro__):
+ is_processor = True
+ docstring_init = auto_method_docstring(
+ cls.__init__,
+ parent_class=cls,
+ custom_args=custom_args,
+ checkpoint=checkpoint,
+ source_args_dict=get_args_doc_from_source([ModelArgs, ImageProcessorArgs, ProcessorArgs]),
+ ).__doc__.replace("Args:", "Parameters:")
+ elif "ModelOutput" in (x.__name__ for x in cls.__mro__):
+ # We have a data class
+ is_dataclass = True
+ doc_class = cls.__doc__
+ if custom_args is None and doc_class:
+ custom_args = doc_class
+ docstring_args = auto_method_docstring(
+ cls.__init__,
+ parent_class=cls,
+ custom_args=custom_args,
+ checkpoint=checkpoint,
+ source_args_dict=get_args_doc_from_source(ModelOutputArgs),
+ ).__doc__
+ elif any("BaseImageProcessor" in x.__name__ for x in cls.__mro__):
+ is_image_processor = True
+ docstring_init = auto_method_docstring(
+ cls.__init__,
+ parent_class=cls,
+ custom_args=custom_args,
+ checkpoint=checkpoint,
+ source_args_dict=get_args_doc_from_source(ImageProcessorArgs),
+ ).__doc__
+ elif "PreTrainedConfig" in (x.__name__ for x in cls.__mro__):
+ is_config = True
+ doc_class = cls.__doc__
+ if custom_args is None and doc_class:
+ custom_args = doc_class
+
+ # Collect all non-ClassVar annotations from the class and its ancestors up to
+ # (but not including) PreTrainedConfig. This allows inherited params from intermediate
+ # config base classes to be documented, while naturally excluding PreTrainedConfig-specific
+ # quasi-ClassVar params (e.g. `transformers_version`, `architectures`).
+ own_config_params = set()
+ for ancestor in cls.__mro__:
+ if ancestor.__name__ == "PreTrainedConfig":
+ break
+ own_config_params |= {
+ k for k, v in getattr(ancestor, "__annotations__", {}).items() if get_origin(v) is not ClassVar
+ }
+ allowed_params = own_config_params if own_config_params else None
+ docstring_init = auto_method_docstring(
+ cls.__init__,
+ parent_class=cls,
+ custom_args=custom_args,
+ checkpoint=checkpoint,
+ source_args_dict=get_args_doc_from_source([ConfigArgs]),
+ allowed_params=allowed_params,
+ ).__doc__
+
+ indent_level = get_indent_level(cls)
+ model_name_lowercase = get_model_name(cls)
+ model_name_title = " ".join([k.title() for k in model_name_lowercase.split("_")]) if model_name_lowercase else None
+ model_base_class = f"{model_name_title.title()}Model" if model_name_title is not None else None
+ if model_name_lowercase is not None:
+ try:
+ model_base_class = getattr(
+ getattr(auto_module, PLACEHOLDER_TO_AUTO_MODULE["model_class"][0]),
+ PLACEHOLDER_TO_AUTO_MODULE["model_class"][1],
+ )[model_name_lowercase]
+ except KeyError:
+ pass
+ except ImportError:
+ # In some environments, certain model classes might not be available. In that case, we can skip this part.
+ pass
+
+ if model_name_lowercase and model_name_lowercase not in getattr(
+ getattr(auto_module, PLACEHOLDER_TO_AUTO_MODULE["config_class"][0]),
+ PLACEHOLDER_TO_AUTO_MODULE["config_class"][1],
+ ):
+ model_name_lowercase = model_name_lowercase.replace("_", "-")
+
+ name = re.findall(rf"({'|'.join(ClassDocstring.__dict__.keys())})$", cls.__name__)
+
+ if name == [] and custom_intro is None and not is_dataclass and not is_processor and not is_image_processor:
+ raise ValueError(
+ f"`{cls.__name__}` is not registered in the auto doc. Here are the available classes: {ClassDocstring.__dict__.keys()}.\n"
+ "Add a `custom_intro` to the decorator if you want to use `auto_docstring` on a class not registered in the auto doc."
+ )
+ if name != [] or custom_intro is not None or is_config or is_dataclass or is_processor or is_image_processor:
+ name = name[0] if name else None
+ formatting_kwargs = {"model_name": model_name_title}
+ if name == "Config":
+ formatting_kwargs.update({"model_base_class": model_base_class, "model_checkpoint": checkpoint})
+ if custom_intro is not None:
+ pre_block = equalize_indent(custom_intro, indent_level)
+ if not pre_block.endswith("\n"):
+ pre_block += "\n"
+ elif is_processor:
+ # Generate processor intro dynamically
+ pre_block = generate_processor_intro(cls)
+ if pre_block:
+ pre_block = equalize_indent(pre_block, indent_level)
+ pre_block = format_args_docstring(pre_block, model_name_lowercase)
+ elif is_image_processor:
+ pre_block = r"Constructs a {image_processor_class} image processor."
+ if pre_block:
+ pre_block = equalize_indent(pre_block, indent_level)
+ pre_block = format_args_docstring(pre_block, model_name_lowercase)
+ elif model_name_title is None or name is None:
+ pre_block = ""
+ else:
+ pre_block = getattr(ClassDocstring, name).format(**formatting_kwargs)
+ # Start building the docstring
+ docstring = set_min_indent(f"{pre_block}", indent_level) if len(pre_block) else ""
+ if name != "PreTrainedModel" and "PreTrainedModel" in (x.__name__ for x in cls.__mro__):
+ docstring += set_min_indent(f"{ClassDocstring.PreTrainedModel}", indent_level)
+ # Add the __init__ docstring
+ if docstring_init:
+ docstring += set_min_indent(f"\n{docstring_init}", indent_level)
+ elif is_dataclass or is_config:
+ # No init function, we have a data class
+ docstring += docstring_args if docstring_args else "\nArgs:\n"
+ source_args_dict = get_args_doc_from_source(ModelOutputArgs)
+ doc_class = cls.__doc__ if cls.__doc__ else ""
+ documented_kwargs = parse_docstring(doc_class)[0]
+ for param_name, param_type_annotation in cls.__annotations__.items():
+ param_type, optional = process_type_annotation(param_type_annotation, param_name)
+
+ # Check for default value
+ param_default = ""
+ param_default = str(getattr(cls, param_name, ""))
+ param_default = f", defaults to `{param_default}`" if param_default != "" else ""
+
+ param_type, optional_string, shape_string, additional_info, description, is_documented = (
+ _get_parameter_info(param_name, documented_kwargs, source_args_dict, param_type, optional)
+ )
+
+ if is_documented:
+ # Check if type is missing
+ if param_type == "":
+ print(
+ f"[ERROR] {param_name} for {cls.__qualname__} in file {cls.__code__.co_filename} has no type"
+ )
+ param_type = param_type if "`" in param_type else f"`{param_type}`"
+ # Format the parameter docstring
+ if additional_info:
+ docstring += set_min_indent(
+ f"{param_name} ({param_type}{additional_info}):{description}",
+ indent_level + 8,
+ )
+ else:
+ docstring += set_min_indent(
+ f"{param_name} ({param_type}{shape_string}{optional_string}{param_default}):{description}",
+ indent_level + 8,
+ )
+ # TODO (Yoni): Add support for Attributes section in docs
+
+ else:
+ print(
+ f"You used `@auto_class_docstring` decorator on `{cls.__name__}` but this class is not part of the AutoMappings. Remove the decorator"
+ )
+ # Assign the dynamically generated docstring to the wrapper class
+ cls.__doc__ = docstring
+
+ return cls
+
+
+def auto_docstring(obj=None, *, custom_intro=None, custom_args=None, checkpoint=None):
+ r"""
+ Automatically generates comprehensive docstrings for model classes and methods in the Transformers library.
+
+ This decorator reduces boilerplate by automatically including standard argument descriptions while allowing
+ overrides to add new or custom arguments. It inspects function signatures, retrieves predefined docstrings
+ for common arguments (like `input_ids`, `attention_mask`, etc.), and generates complete documentation
+ including examples and return value descriptions.
+
+ For complete documentation and examples, read this [guide](https://huggingface.co/docs/transformers/auto_docstring).
+
+ Examples of usage:
+
+ Basic usage (no parameters):
+ ```python
+ @auto_docstring
+ class MyAwesomeModel(PreTrainedModel):
+ def __init__(self, config, custom_parameter: int = 10):
+ r'''
+ custom_parameter (`int`, *optional*, defaults to 10):
+ Description of the custom parameter for MyAwesomeModel.
+ '''
+ super().__init__(config)
+ self.custom_parameter = custom_parameter
+ ```
+
+ Using `custom_intro` with a class:
+ ```python
+ @auto_docstring(
+ custom_intro="This model implements a novel attention mechanism for improved performance."
+ )
+ class MySpecialModel(PreTrainedModel):
+ def __init__(self, config, attention_type: str = "standard"):
+ r'''
+ attention_type (`str`, *optional*, defaults to "standard"):
+ Type of attention mechanism to use.
+ '''
+ super().__init__(config)
+ ```
+
+ Using `custom_intro` with a method, and specify custom arguments and example directly in the docstring:
+ ```python
+ @auto_docstring(
+ custom_intro="Performs forward pass with enhanced attention computation."
+ )
+ def forward(
+ self,
+ input_ids: Optional[torch.Tensor] = None,
+ attention_mask: Optional[torch.Tensor] = None,
+ ):
+ r'''
+ custom_parameter (`int`, *optional*, defaults to 10):
+ Description of the custom parameter for MyAwesomeModel.
+
+ Example:
+
+ ```python
+ >>> model = MyAwesomeModel(config)
+ >>> model.forward(input_ids=torch.tensor([1, 2, 3]), attention_mask=torch.tensor([1, 1, 1]))
+ ```
+ '''
+ ```
+
+ Using `custom_args` to define reusable arguments:
+ ```python
+ VISION_ARGS = r'''
+ pixel_values (`torch.FloatTensor`, *optional*):
+ Pixel values of the input images.
+ image_features (`torch.FloatTensor`, *optional*):
+ Pre-computed image features for efficient processing.
+ '''
+
+ @auto_docstring(custom_args=VISION_ARGS)
+ def encode_images(self, pixel_values=None, image_features=None):
+ # ... method implementation
+ ```
+
+ Combining `custom_intro` and `custom_args`:
+ ```python
+ MULTIMODAL_ARGS = r'''
+ vision_features (`torch.FloatTensor`, *optional*):
+ Pre-extracted vision features from the vision encoder.
+ fusion_strategy (`str`, *optional*, defaults to "concat"):
+ Strategy for fusing text and vision modalities.
+ '''
+
+ @auto_docstring(
+ custom_intro="Processes multimodal inputs combining text and vision.",
+ custom_args=MULTIMODAL_ARGS
+ )
+ def forward(
+ self,
+ input_ids,
+ attention_mask=None,
+ vision_features=None,
+ fusion_strategy="concat"
+ ):
+ # ... multimodal processing
+ ```
+
+ Using with ModelOutput classes:
+ ```python
+ @dataclass
+ @auto_docstring(
+ custom_intro="Custom model outputs with additional fields."
+ )
+ class MyModelOutput(ImageClassifierOutput):
+ r'''
+ loss (`torch.FloatTensor`, *optional*):
+ The loss of the model.
+ custom_field (`torch.FloatTensor` of shape `(batch_size, hidden_size)`, *optional*):
+ A custom output field specific to this model.
+ '''
+
+ # Standard fields like hidden_states, logits, attentions etc. can be automatically documented
+ # However, given that the loss docstring is often different per model, you should document it above
+ loss: Optional[torch.FloatTensor] = None
+ logits: Optional[torch.FloatTensor] = None
+ hidden_states: Optional[tuple[torch.FloatTensor, ...]] = None
+ attentions: Optional[tuple[torch.FloatTensor, ...]] = None
+ custom_field: Optional[torch.FloatTensor] = None
+ ```
+
+ Args:
+ custom_intro (`str`, *optional*):
+ Custom introduction text to add to the docstring. This replaces the default
+ introduction text generated by the decorator before the Args section. Use this to describe what
+ makes your model or method special.
+ custom_args (`str`, *optional*):
+ Custom argument documentation in docstring format. This allows you to define
+ argument descriptions once and reuse them across multiple methods. The format should follow the
+ standard docstring convention: `arg_name (`type`, *optional*, defaults to `value`): Description.`
+ checkpoint (`str`, *optional*):
+ Checkpoint name to use in examples within the docstring. This is typically
+ automatically inferred from the model configuration class, but can be overridden if needed for
+ custom examples.
+
+ Note:
+ - Standard arguments (`input_ids`, `attention_mask`, `pixel_values`, etc.) are automatically documented
+ from predefined descriptions and should not be redefined unless their behavior differs in your model.
+ - New or custom arguments should be documented in the method's docstring using the `r''' '''` block
+ or passed via the `custom_args` parameter.
+ - For model classes, the decorator derives parameter descriptions from the `__init__` method's signature
+ and docstring.
+ - Return value documentation is automatically generated for methods that return ModelOutput subclasses.
+ """
+
+ def auto_docstring_decorator(obj):
+ if len(obj.__qualname__.split(".")) > 1:
+ return auto_method_docstring(
+ obj, custom_args=custom_args, custom_intro=custom_intro, checkpoint=checkpoint
+ )
+ else:
+ return auto_class_docstring(obj, custom_args=custom_args, custom_intro=custom_intro, checkpoint=checkpoint)
+
+ if obj:
+ return auto_docstring_decorator(obj)
+
+ return auto_docstring_decorator
diff --git a/lib/python3.11/site-packages/transformers/utils/backbone_utils.py b/lib/python3.11/site-packages/transformers/utils/backbone_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..2947b9a5a953228549e52e7b53af0588d3d4fb7b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/backbone_utils.py
@@ -0,0 +1,19 @@
+import warnings
+
+from ..backbone_utils import BackboneConfigMixin, BackboneMixin
+
+
+class BackboneConfigMixin(BackboneConfigMixin):
+ warnings.warn(
+ "Importing `BackboneConfigMixin` from `utils/backbone_utils.py` is deprecated and will be removed in "
+ "Transformers v5.10. Import as `from transformers.backbone_utils import BackboneConfigMixin` instead.",
+ FutureWarning,
+ )
+
+
+class BackboneMixin(BackboneMixin):
+ warnings.warn(
+ "Importing `BackboneMixin` from `utils/backbone_utils.py` is deprecated and will be removed in "
+ "Transformers v5.10. Import as `from transformers.backbone_utils import BackboneMixin` instead.",
+ FutureWarning,
+ )
diff --git a/lib/python3.11/site-packages/transformers/utils/chat_parsing_utils.py b/lib/python3.11/site-packages/transformers/utils/chat_parsing_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..44983cb33a25e613c1c40476b8b7f5251d0c947f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/chat_parsing_utils.py
@@ -0,0 +1,305 @@
+# Copyright 2026 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 __future__ import annotations
+
+import json
+import re
+
+from transformers.utils import is_jmespath_available
+
+
+if is_jmespath_available():
+ import jmespath
+else:
+ jmespath = None
+
+
+def _gemma4_json_to_json(text: str) -> str:
+ """Convert Gemma4 tool call format (unquoted keys, ``<|"|>`` string delimiters) to valid JSON."""
+ strings = []
+
+ def _capture(m):
+ strings.append(m.group(1))
+ return f"\x00{len(strings) - 1}\x00"
+
+ # Grab the inside of gemma-quotes and store them for later
+ text = re.sub(r'<\|"\|>(.*?)<\|"\|>', _capture, text, flags=re.DOTALL)
+ # Add quotes to the bare keys elsewhere
+ text = re.sub(r"(?<=[{,])(\w+):", r'"\1":', text)
+
+ # Put the inside of the quotes back afterwards
+ for i, s in enumerate(strings):
+ text = text.replace(f"\x00{i}\x00", json.dumps(s))
+
+ return text
+
+
+def _parse_re_match(node_match: re.Match) -> dict | str:
+ # If the regex has named groups, return a dict of those groups
+ if node_match.groupdict():
+ return {key: val for key, val in node_match.groupdict().items() if val is not None}
+ # Otherwise the regex must have exactly one unnamed group, and we return that
+ else:
+ groups = list(node_match.groups())
+ if len(groups) > 1:
+ raise ValueError(f"Regex has multiple unnamed groups!\nGroups: {groups}\n")
+ elif len(groups) == 0:
+ raise ValueError(f"Regex has no capture groups:\n\n{node_match.group(0)}")
+ return groups[0]
+
+
+def recursive_parse(
+ node_content: str | list | dict,
+ node_schema: dict,
+):
+ """
+ This function takes content and a JSON schema which includes
+ regex extractors, and recursively parses the content. The output
+ should be a data structure matching the schema.
+
+ Args:
+ node_content: The content corresponding to this node. Usually a string, but can be something else
+ if the parent node has multiple capture groups or named groups. In that case,
+ we generally pass the capture groups straight through to the children of this node
+ and don't do any parsing at this level.
+ node_schema: The schema node controlling the parsing.
+
+ Returns:
+ The parsed data structure for the current node.
+ """
+
+ # If the schema has a const, we just return that value and do absolutely nothing else
+ if "const" in node_schema:
+ return node_schema["const"]
+
+ # If the node content is None, we return None. EZ.
+ if node_content is None:
+ return None
+
+ # If not, we have to do a little parsing. First, set some vars and do basic validation
+ node_type = node_schema.get("type")
+ has_regex = (
+ "x-regex" in node_schema
+ or "x-regex-iterator" in node_schema
+ or "x-regex-key-value" in node_schema
+ or "x-regex-substitutions" in node_schema
+ )
+ if has_regex and not isinstance(node_content, str):
+ raise TypeError(
+ "Schema node got a non-string input, but has a regex for parsing or substitution.\n"
+ f"Input: {node_content}\n"
+ f"Schema: {node_schema}"
+ )
+
+ node_subs = node_schema.get("x-regex-substitutions", [])
+ for node_sub in node_subs:
+ node_content = re.sub(node_sub[0], node_sub[1], node_content, flags=re.DOTALL)
+ node_regex = node_schema.get("x-regex")
+ node_regex_iterator = node_schema.get("x-regex-iterator")
+ node_regex_to_dict = node_schema.get("x-regex-key-value")
+ if node_regex is not None:
+ node_match = re.search(node_regex, node_content, flags=re.DOTALL)
+ if not node_match:
+ return None
+ node_content = _parse_re_match(node_match)
+ if node_regex_iterator is not None:
+ if node_type != "array":
+ raise TypeError(f"Schema node with type {node_type} cannot use x-regex-iterator.\nSchema: {node_schema}")
+ # Note that this can be applied after a standard node-regex search
+ node_content = [
+ _parse_re_match(node_match)
+ for node_match in re.finditer(node_regex_iterator, node_content, flags=re.DOTALL)
+ ]
+ if not node_content:
+ return None
+ if node_regex_to_dict is not None:
+ if node_type != "object":
+ raise TypeError(f"Schema node with type {node_type} cannot use x-regex-key-value.\nSchema: {node_schema}")
+ # Note that this can be applied after a standard node-regex search
+ output_content = {}
+ for node_match in re.finditer(node_regex_to_dict, node_content, flags=re.DOTALL):
+ match_groups = _parse_re_match(node_match)
+ if not isinstance(match_groups, dict) or "key" not in match_groups or "value" not in match_groups:
+ raise ValueError(
+ f"Regex for x-regex-key-value must have named groups 'key' and 'value'.\n"
+ f"Match groups: {match_groups}\n"
+ f"Schema: {node_schema}"
+ )
+ output_content[match_groups["key"]] = match_groups["value"]
+ node_content = output_content
+ if not node_content:
+ return None
+
+ # Next, if the node has a parser, apply it. We do this after regexes so that the regex can extract
+ # a substring to parse, if needed.
+ if "x-parser" in node_schema:
+ parser = node_schema["x-parser"]
+ if parser == "gemma4-tool-call":
+ if not isinstance(node_content, str):
+ raise TypeError(
+ f"Node has Gemma4 tool call parser but got non-string input: {node_content}\nSchema: {node_schema}"
+ )
+ node_content = _gemma4_json_to_json(node_content)
+ parser = "json" # fall through to the JSON parser below - don't add an elif!
+ if parser == "json":
+ if not isinstance(node_content, str):
+ raise TypeError(
+ f"Node has JSON parser but got non-string input: {node_content}\nSchema: {node_schema}"
+ )
+ parser_args = node_schema.get("x-parser-args", {})
+ transform = parser_args.get("transform")
+ allow_non_json = parser_args.get("allow_non_json", False)
+ try:
+ parsed_json = json.loads(node_content)
+ except json.JSONDecodeError as e:
+ if allow_non_json:
+ parsed_json = node_content
+ else:
+ raise ValueError(
+ f"Node has JSON parser but could not parse its contents as JSON. You can use the `allow_non_json` parser arg for nodes which may contain JSON or string content.\n\nContent: {node_content}\n\nError: {e}"
+ )
+ if transform is not None:
+ if jmespath is None:
+ raise ImportError(
+ "Chat response schema includes a jmespath transformation, but jmespath is not installed. You can install it with `pip install jmespath`."
+ )
+ parsed_json = jmespath.search(parser_args["transform"], parsed_json)
+ node_content = parsed_json
+ else:
+ raise ValueError(f"Unknown parser {parser} for schema node: {node_schema}")
+
+ # Finally, handle parsed content based on schema type and recurse if required
+ if node_type == "object":
+ parsed_schema = {}
+ if isinstance(node_content, str):
+ # This means we don't have a regex at this level, so all of our child nodes need to parse the whole
+ # string themselves to extract their value.
+ if "properties" not in node_schema:
+ raise ValueError(
+ f"Object node received string content but has no regex or parser to handle it.\n"
+ f"Content: {node_content}\n"
+ f"Schema: {node_schema}"
+ )
+ for key, child_node in node_schema["properties"].items():
+ child_node_content = recursive_parse(node_content, node_schema["properties"][key])
+ if child_node_content is not None:
+ parsed_schema[key] = child_node_content
+ elif isinstance(node_content, dict):
+ for key, child_node in node_schema.get("properties", {}).items():
+ if "const" in child_node:
+ parsed_schema[key] = child_node["const"]
+ elif key in node_content:
+ parsed_schema[key] = recursive_parse(node_content[key], child_node)
+ elif "default" in child_node:
+ parsed_schema[key] = child_node["default"]
+ additional_schema = node_schema.get("additionalProperties", True)
+ # We want to check only for False values; {} is "falsy" but should pass through
+ if additional_schema is not False:
+ additional_schema = additional_schema if isinstance(additional_schema, dict) else {}
+ for key, value in node_content.items():
+ if key not in node_schema.get("properties", {}):
+ parsed_schema[key] = recursive_parse(value, additional_schema)
+ else:
+ raise TypeError(f"Expected a dict or str for schema node with type object, got {node_content}")
+ required = node_schema.get("required", [])
+ missing = [key for key in required if key not in parsed_schema]
+ if missing:
+ input_preview = repr(node_content[:500]) if isinstance(node_content, str) else repr(node_content)
+ raise ValueError(
+ f"Required fields {missing} are missing from parsed output.\n"
+ f"Parsed: {parsed_schema}\n"
+ f"Input: {input_preview}"
+ )
+ return parsed_schema
+ elif node_type == "array":
+ if not node_content:
+ return []
+ parsed_schema = []
+ if "items" in node_schema:
+ if not isinstance(node_content, list):
+ raise TypeError(f"Expected a list or regex for schema node with type array, got {node_content}")
+ for item in node_content:
+ parsed_schema.append(recursive_parse(item, node_schema["items"]))
+ return parsed_schema
+ elif "prefixItems" in node_schema:
+ if not isinstance(node_content, list):
+ if len(node_schema["prefixItems"]) == 1:
+ # If there's only one prefix item, this is a single item array, we can just wrap the string
+ node_content = [node_content]
+ else:
+ raise TypeError(f"Expected a list or regex for schema node with type array, got {node_content}")
+ if len(node_content) != len(node_schema["prefixItems"]):
+ raise ValueError(
+ f"Array node has {len(node_content)} items, but schema only has "
+ f"{len(node_schema['prefixItems'])} prefixItems defined.\n"
+ f"Content: {node_content}\n"
+ f"Schema: {node_schema}"
+ )
+ for item, item_schema in zip(node_content, node_schema["prefixItems"]):
+ parsed_schema.append(recursive_parse(item, item_schema))
+ return parsed_schema
+ else:
+ raise ValueError(f"Array node has no items or prefixItems schema defined.\nSchema: {node_schema}")
+ elif node_type in ("string", "integer", "number", "boolean"):
+ if node_type == "integer":
+ if isinstance(node_content, int):
+ return node_content
+ if not isinstance(node_content, str):
+ raise TypeError(
+ f"Expected a string or int for schema node with type integer, got {type(node_content).__name__}: {node_content}"
+ )
+ try:
+ return int(node_content)
+ except ValueError:
+ raise ValueError(
+ f"Schema node has type 'integer', but the parsed string content is not a valid integer: {node_content!r}"
+ )
+ elif node_type == "number":
+ if isinstance(node_content, (int, float)):
+ return float(node_content)
+ if not isinstance(node_content, str):
+ raise TypeError(
+ f"Expected a string or number for schema node with type number, got {type(node_content).__name__}: {node_content}"
+ )
+ try:
+ return float(node_content)
+ except ValueError:
+ raise ValueError(
+ f"Schema node has type 'number', but the parsed string content is not a valid number: {node_content!r}"
+ )
+ elif node_type == "boolean":
+ if isinstance(node_content, bool):
+ return node_content
+ if not isinstance(node_content, str):
+ raise TypeError(
+ f"Expected a string or bool for schema node with type boolean, got {type(node_content).__name__}: {node_content}"
+ )
+ if node_content.lower() in ("true", "1"):
+ return True
+ elif node_content.lower() in ("false", "0"):
+ return False
+ else:
+ raise ValueError(f"Invalid boolean value: {node_content}")
+ else:
+ # String type
+ if not isinstance(node_content, str):
+ raise TypeError(
+ f"Expected a string for schema node with type string, got {type(node_content).__name__}: {node_content}"
+ )
+ return node_content
+ elif node_type is None or node_type == "any":
+ return node_content # Don't touch it
+ else:
+ raise TypeError(f"Unsupported schema type {node_type} for node: {node_content}")
diff --git a/lib/python3.11/site-packages/transformers/utils/chat_template_utils.py b/lib/python3.11/site-packages/transformers/utils/chat_template_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..0510273538673d67d0405e4fc628c149d9073d51
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/chat_template_utils.py
@@ -0,0 +1,631 @@
+# Copyright 2024 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 inspect
+import json
+import re
+import types
+from collections.abc import Callable
+from contextlib import contextmanager
+from copy import deepcopy
+from datetime import datetime
+from functools import lru_cache
+from inspect import isfunction
+from typing import Any, Literal, Union, get_args, get_origin, get_type_hints, no_type_check
+
+from packaging import version
+
+from . import logging
+from .import_utils import is_jinja_available, is_torch_available, is_vision_available
+
+
+logger = logging.get_logger(__name__)
+
+if is_jinja_available():
+ import jinja2
+ import jinja2.exceptions
+ import jinja2.ext
+ import jinja2.meta
+ import jinja2.nodes
+ import jinja2.runtime
+ from jinja2.ext import Extension
+ from jinja2.sandbox import ImmutableSandboxedEnvironment
+else:
+ jinja2 = None
+
+if is_vision_available():
+ from PIL.Image import Image
+
+ChatType = list[dict[str, Any]]
+
+
+BASIC_TYPES = (int, float, str, bool, Any, type(None), ...)
+# Extracts the initial segment of the docstring, containing the function description
+description_re = re.compile(r"^(.*?)[\n\s]*(Args:|Returns:|Raises:|\Z)", re.DOTALL)
+# Extracts the Args: block from the docstring
+args_re = re.compile(r"\n\s*Args:\n\s*(.*?)[\n\s]*(Returns:|Raises:|\Z)", re.DOTALL)
+# Splits the Args: block into individual arguments
+args_split_re = re.compile(
+ r"""
+(?:^|\n) # Match the start of the args block, or a newline
+\s*(\w+):\s* # Capture the argument name and strip spacing
+(.*?)\s* # Capture the argument description, which can span multiple lines, and strip trailing spacing
+(?=\n\s*\w+:|\Z) # Stop when you hit the next argument or the end of the block
+""",
+ re.DOTALL | re.VERBOSE,
+)
+# Extracts the Returns: block from the docstring, if present. Note that most chat templates ignore the return type/doc!
+returns_re = re.compile(r"\n\s*Returns:\n\s*(.*?)[\n\s]*(Raises:|\Z)", re.DOTALL)
+
+
+class TypeHintParsingException(Exception):
+ """Exception raised for errors in parsing type hints to generate JSON schemas"""
+
+
+class DocstringParsingException(Exception):
+ """Exception raised for errors in parsing docstrings to generate JSON schemas"""
+
+
+def _get_json_schema_type(param_type: type) -> dict[str, str]:
+ type_mapping = {
+ int: {"type": "integer"},
+ float: {"type": "number"},
+ str: {"type": "string"},
+ bool: {"type": "boolean"},
+ type(None): {"type": "null"},
+ Any: {},
+ }
+ if is_vision_available():
+ type_mapping[Image] = {"type": "image"}
+ if is_torch_available():
+ import torch
+
+ type_mapping[torch.Tensor] = {"type": "audio"}
+ return type_mapping.get(param_type, {"type": "object"})
+
+
+def _parse_type_hint(hint: str) -> dict:
+ origin = get_origin(hint)
+ args = get_args(hint)
+
+ if origin is None:
+ try:
+ return _get_json_schema_type(hint)
+ except KeyError:
+ raise TypeHintParsingException(
+ "Couldn't parse this type hint, likely due to a custom class or object: ", hint
+ )
+
+ elif origin is Union or (hasattr(types, "UnionType") and origin is types.UnionType):
+ # Recurse into each of the subtypes in the Union, except None, which is handled separately at the end
+ subtypes = [_parse_type_hint(t) for t in args if t is not type(None)]
+ if len(subtypes) == 1:
+ # A single non-null type can be expressed directly
+ return_dict = subtypes[0]
+ elif all("type" in subtype and isinstance(subtype["type"], str) for subtype in subtypes):
+ # A union of basic types can be expressed as a list in the schema
+ return_dict = {"type": sorted([subtype["type"] for subtype in subtypes])}
+ else:
+ # A union of more complex types requires "anyOf"
+ return_dict = {"anyOf": subtypes}
+ if type(None) in args:
+ return_dict["nullable"] = True
+ return return_dict
+
+ elif origin is Literal and len(args) > 0:
+ LITERAL_TYPES = (int, float, str, bool, type(None))
+ args_types = []
+ for arg in args:
+ if type(arg) not in LITERAL_TYPES:
+ raise TypeHintParsingException("Only the valid python literals can be listed in typing.Literal.")
+ arg_type = _get_json_schema_type(type(arg)).get("type")
+ if arg_type is not None and arg_type not in args_types:
+ args_types.append(arg_type)
+ return {
+ "type": args_types.pop() if len(args_types) == 1 else list(args_types),
+ "enum": list(args),
+ }
+
+ elif origin is list:
+ if not args:
+ return {"type": "array"}
+ else:
+ # Lists can only have a single type argument, so recurse into it
+ return {"type": "array", "items": _parse_type_hint(args[0])}
+
+ elif origin is tuple:
+ if not args:
+ return {"type": "array"}
+ if len(args) == 1:
+ raise TypeHintParsingException(
+ f"The type hint {str(hint).replace('typing.', '')} is a Tuple with a single element, which "
+ "we do not automatically convert to JSON schema as it is rarely necessary. If this input can contain "
+ "more than one element, we recommend "
+ "using a list[] type instead, or if it really is a single element, remove the tuple[] wrapper and just "
+ "pass the element directly."
+ )
+ if ... in args:
+ raise TypeHintParsingException(
+ "Conversion of '...' is not supported in Tuple type hints. "
+ "Use list[] types for variable-length"
+ " inputs instead."
+ )
+ return {"type": "array", "prefixItems": [_parse_type_hint(t) for t in args]}
+
+ elif origin is dict:
+ # The JSON equivalent to a dict is 'object', which mandates that all keys are strings
+ # However, we can specify the type of the dict values with "additionalProperties"
+ out = {"type": "object"}
+ if len(args) == 2:
+ out["additionalProperties"] = _parse_type_hint(args[1])
+ return out
+
+ raise TypeHintParsingException("Couldn't parse this type hint, likely due to a custom class or object: ", hint)
+
+
+def _convert_type_hints_to_json_schema(func: Callable) -> dict:
+ type_hints = get_type_hints(func)
+ signature = inspect.signature(func)
+ func_name = getattr(func, "__name__", "operation")
+ # For methods, we need to ignore the first "self" or "cls" parameter. Here we assume that if the first parameter
+ # is named "self" or "cls" and has no type hint, it is an implicit receiver argument.
+ first_param_name = next(iter(signature.parameters), None)
+ if (
+ first_param_name in {"self", "cls"}
+ and signature.parameters[first_param_name].annotation == inspect.Parameter.empty
+ ):
+ implicit_arg_name = first_param_name
+ else:
+ implicit_arg_name = None
+ required = []
+ for param_name, param in signature.parameters.items():
+ if param_name == implicit_arg_name:
+ continue
+ if param.annotation == inspect.Parameter.empty:
+ raise TypeHintParsingException(f"Argument {param.name} is missing a type hint in function {func_name}")
+ if param.default == inspect.Parameter.empty:
+ required.append(param_name)
+
+ properties = {}
+ for param_name, param_type in type_hints.items():
+ if param_name == implicit_arg_name:
+ continue
+ properties[param_name] = _parse_type_hint(param_type)
+
+ schema = {"type": "object", "properties": properties}
+ if required:
+ schema["required"] = required
+
+ return schema
+
+
+def parse_google_format_docstring(docstring: str) -> tuple[str | None, dict | None, str | None]:
+ """
+ Parses a Google-style docstring to extract the function description,
+ argument descriptions, and return description.
+
+ Args:
+ docstring (str): The docstring to parse.
+
+ Returns:
+ The function description, arguments, and return description.
+ """
+
+ # Extract the sections
+ description_match = description_re.search(docstring)
+ args_match = args_re.search(docstring)
+ returns_match = returns_re.search(docstring)
+
+ # Clean and store the sections
+ description = description_match.group(1).strip() if description_match else None
+ docstring_args = args_match.group(1).strip() if args_match else None
+ returns = returns_match.group(1).strip() if returns_match else None
+
+ # Parsing the arguments into a dictionary
+ if docstring_args is not None:
+ docstring_args = "\n".join([line for line in docstring_args.split("\n") if line.strip()]) # Remove blank lines
+ matches = args_split_re.findall(docstring_args)
+ args_dict = {match[0]: re.sub(r"\s*\n+\s*", " ", match[1].strip()) for match in matches}
+ else:
+ args_dict = {}
+
+ return description, args_dict, returns
+
+
+def get_json_schema(func: Callable) -> dict:
+ """
+ This function generates a JSON schema for a given function, based on its docstring and type hints. This is
+ mostly used for passing lists of tools to a chat template. The JSON schema contains the name and description of
+ the function, as well as the names, types and descriptions for each of its arguments. `get_json_schema()` requires
+ that the function has a docstring, and that each argument has a description in the docstring, in the standard
+ Google docstring format shown below. It also requires that all user-facing arguments have valid Python type hints.
+ When passing methods, implicit receiver arguments (`self` or `cls`) are ignored.
+
+ Although it is not required, a `Returns` block can also be added, which will be included in the schema. This is
+ optional because most chat templates ignore the return value of the function.
+
+ Args:
+ func: The function to generate a JSON schema for.
+
+ Returns:
+ A dictionary containing the JSON schema for the function.
+
+ Examples:
+ ```python
+ >>> def multiply(x: float, y: float):
+ >>> '''
+ >>> A function that multiplies two numbers
+ >>>
+ >>> Args:
+ >>> x: The first number to multiply
+ >>> y: The second number to multiply
+ >>> '''
+ >>> return x * y
+ >>>
+ >>> print(get_json_schema(multiply))
+ {
+ "name": "multiply",
+ "description": "A function that multiplies two numbers",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "x": {"type": "number", "description": "The first number to multiply"},
+ "y": {"type": "number", "description": "The second number to multiply"}
+ },
+ "required": ["x", "y"]
+ }
+ }
+ ```
+
+ The general use for these schemas is that they are used to generate tool descriptions for chat templates that
+ support them, like so:
+
+ ```python
+ >>> from transformers import AutoTokenizer
+ >>> from transformers.utils import get_json_schema
+ >>>
+ >>> def multiply(x: float, y: float):
+ >>> '''
+ >>> A function that multiplies two numbers
+ >>>
+ >>> Args:
+ >>> x: The first number to multiply
+ >>> y: The second number to multiply
+ >>> return x * y
+ >>> '''
+ >>>
+ >>> multiply_schema = get_json_schema(multiply)
+ >>> tokenizer = AutoTokenizer.from_pretrained("CohereForAI/c4ai-command-r-v01")
+ >>> messages = [{"role": "user", "content": "What is 179 x 4571?"}]
+ >>> formatted_chat = tokenizer.apply_chat_template(
+ >>> messages,
+ >>> tools=[multiply_schema],
+ >>> chat_template="tool_use",
+ >>> return_dict=True,
+ >>> return_tensors="pt",
+ >>> add_generation_prompt=True
+ >>> )
+ >>> # The formatted chat can now be passed to model.generate()
+ ```
+
+ Each argument description can also have an optional `(choices: ...)` block at the end, such as
+ `(choices: ["tea", "coffee"])`, which will be parsed into an `enum` field in the schema. Note that this will
+ only be parsed correctly if it is at the end of the line:
+
+ ```python
+ >>> def drink_beverage(beverage: str):
+ >>> '''
+ >>> A function that drinks a beverage
+ >>>
+ >>> Args:
+ >>> beverage: The beverage to drink (choices: ["tea", "coffee"])
+ >>> '''
+ >>> pass
+ >>>
+ >>> print(get_json_schema(drink_beverage))
+ ```
+ {
+ 'name': 'drink_beverage',
+ 'description': 'A function that drinks a beverage',
+ 'parameters': {
+ 'type': 'object',
+ 'properties': {
+ 'beverage': {
+ 'type': 'string',
+ 'enum': ['tea', 'coffee'],
+ 'description': 'The beverage to drink'
+ }
+ },
+ 'required': ['beverage']
+ }
+ }
+ """
+ doc = inspect.getdoc(func)
+ func_name = getattr(func, "__name__", "operation")
+
+ if not doc:
+ raise DocstringParsingException(f"Cannot generate JSON schema for {func_name} because it has no docstring!")
+ doc = doc.strip()
+ main_doc, param_descriptions, return_doc = parse_google_format_docstring(doc)
+
+ json_schema = _convert_type_hints_to_json_schema(func)
+ if (return_dict := json_schema["properties"].pop("return", None)) is not None:
+ if return_doc is not None: # We allow a missing return docstring since most templates ignore it
+ return_dict["description"] = return_doc
+ for arg, schema in json_schema["properties"].items():
+ if arg not in param_descriptions:
+ raise DocstringParsingException(
+ f"Cannot generate JSON schema for {func_name} because the docstring has no description for the argument '{arg}'"
+ )
+ desc = param_descriptions[arg]
+ enum_choices = re.search(r"\(choices:\s*(.*?)\)\s*$", desc, flags=re.IGNORECASE)
+ if enum_choices:
+ schema["enum"] = [c.strip() for c in json.loads(enum_choices.group(1))]
+ desc = enum_choices.string[: enum_choices.start()].strip()
+ schema["description"] = desc
+
+ output = {"name": func_name, "description": main_doc, "parameters": json_schema}
+ if return_dict is not None:
+ output["return"] = return_dict
+ return {"type": "function", "function": output}
+
+
+@lru_cache
+@no_type_check
+def _get_template_variables(chat_template: str | None) -> frozenset[str]:
+ """Return the set of undeclared variables referenced by a chat template.
+
+ Uses ``jinja2.meta.find_undeclared_variables`` so that callers can
+ automatically distinguish template-level kwargs from processor kwargs
+ without maintaining a manual allowlist. Needed only to support BC as we
+ allowed all `kwargs` to be merged into one in the past
+ """
+ if chat_template is None:
+ return frozenset()
+ compiled = _compile_jinja_template(chat_template)
+ ast = compiled.environment.parse(chat_template)
+ return frozenset(jinja2.meta.find_undeclared_variables(ast))
+
+
+def _render_with_assistant_indices(
+ compiled_template, messages, tools, documents, add_generation_prompt, **template_kwargs
+):
+ rendered_blocks = []
+ generation_indices = []
+ with compiled_template.environment.activate_tracker(rendered_blocks, generation_indices):
+ for block in compiled_template.generate(
+ messages=messages,
+ tools=tools,
+ documents=documents,
+ add_generation_prompt=add_generation_prompt,
+ **template_kwargs,
+ ):
+ rendered_blocks.append(block)
+ rendered_chat = "".join(rendered_blocks)
+ return rendered_chat, generation_indices
+
+
+@lru_cache
+def _compile_jinja_template(chat_template):
+ return _cached_compile_jinja_template(chat_template)
+
+
+@no_type_check
+def _cached_compile_jinja_template(chat_template):
+ if not is_jinja_available():
+ raise ImportError(
+ "apply_chat_template requires jinja2 to be installed. Please install it using `pip install jinja2`."
+ )
+
+ class AssistantTracker(Extension):
+ # This extension is used to track the indices of assistant-generated tokens in the rendered chat
+ tags = {"generation"}
+
+ def __init__(self, environment: ImmutableSandboxedEnvironment):
+ # The class is only initiated by jinja.
+ super().__init__(environment)
+ environment.extend(activate_tracker=self.activate_tracker)
+ self._rendered_blocks = None
+ self._generation_indices = None
+
+ def parse(self, parser: jinja2.parser.Parser) -> jinja2.nodes.CallBlock:
+ lineno = next(parser.stream).lineno
+ body = parser.parse_statements(["name:endgeneration"], drop_needle=True)
+ return jinja2.nodes.CallBlock(self.call_method("_generation_support"), [], [], body).set_lineno(lineno)
+
+ @jinja2.pass_eval_context
+ def _generation_support(self, context: jinja2.nodes.EvalContext, caller: jinja2.runtime.Macro) -> str:
+ rv = caller()
+ if self.is_active():
+ # Only track generation indices if the tracker is active
+ start_index = len("".join(self._rendered_blocks))
+ end_index = start_index + len(rv)
+ self._generation_indices.append((start_index, end_index))
+ return rv
+
+ def is_active(self) -> bool:
+ return self._rendered_blocks is not None or self._generation_indices is not None
+
+ @contextmanager
+ def activate_tracker(self, rendered_blocks: list[int], generation_indices: list[int]):
+ try:
+ if self.is_active():
+ raise ValueError("AssistantTracker should not be reused before closed")
+ self._rendered_blocks = rendered_blocks
+ self._generation_indices = generation_indices
+
+ yield
+ finally:
+ self._rendered_blocks = None
+ self._generation_indices = None
+
+ if version.parse(jinja2.__version__) < version.parse("3.1.0"):
+ raise ImportError(
+ f"apply_chat_template requires jinja2>=3.1.0 to be installed. Your version is {jinja2.__version__}."
+ )
+
+ def raise_exception(message):
+ raise jinja2.exceptions.TemplateError(message)
+
+ def tojson(x, ensure_ascii=False, indent=None, separators=None, sort_keys=False):
+ # We override the built-in tojson filter because Jinja's default filter escapes HTML characters
+ # We also expose some options like custom indents and separators
+ return json.dumps(x, ensure_ascii=ensure_ascii, indent=indent, separators=separators, sort_keys=sort_keys)
+
+ def strftime_now(format):
+ return datetime.now().strftime(format)
+
+ jinja_env = ImmutableSandboxedEnvironment(
+ trim_blocks=True, lstrip_blocks=True, extensions=[AssistantTracker, jinja2.ext.loopcontrols]
+ )
+ jinja_env.filters["tojson"] = tojson
+ jinja_env.globals["raise_exception"] = raise_exception
+ jinja_env.globals["strftime_now"] = strftime_now
+ return jinja_env.from_string(chat_template)
+
+
+def render_jinja_template(
+ conversations: list[ChatType],
+ tools: list[dict | Callable] | None = None,
+ documents: ChatType | None = None,
+ chat_template: str | None = None,
+ return_assistant_tokens_mask: bool = False,
+ continue_final_message: bool | str = False,
+ add_generation_prompt: bool = False,
+ **kwargs,
+) -> str:
+ if return_assistant_tokens_mask and not re.search(r"\{\%-?\s*generation\s*-?\%\}", chat_template):
+ logger.warning_once(
+ "return_assistant_tokens_mask==True but chat template does not contain `{% generation %}` keyword."
+ )
+
+ # Compilation function uses a cache to avoid recompiling the same template
+ compiled_template = _compile_jinja_template(chat_template)
+
+ # We accept either JSON schemas or functions for tools. If we get functions, we convert them to schemas
+ if tools is not None:
+ tool_schemas = []
+ for tool in tools:
+ if isinstance(tool, dict):
+ tool_schemas.append(tool)
+ elif isfunction(tool) or inspect.ismethod(tool):
+ tool_schemas.append(get_json_schema(tool))
+ else:
+ raise ValueError(
+ "Tools should either be a JSON schema, or a callable function with type hints "
+ "and a docstring suitable for auto-conversion to a schema."
+ )
+ else:
+ tool_schemas = None
+
+ if documents is not None:
+ for document in documents:
+ if not isinstance(document, dict):
+ raise TypeError("Documents should be a list of dicts with 'title' and 'text' keys!")
+
+ rendered = []
+ all_generation_indices = []
+ continue_final_message_tag = "CONTINUE_FINAL_MESSAGE_TAG "
+ for chat in conversations:
+ if hasattr(chat, "messages"):
+ # Indicates it's a Conversation object
+ chat = chat.messages
+ if continue_final_message:
+ chat = deepcopy(chat)
+ continue_final_message = continue_final_message if isinstance(continue_final_message, str) else "content"
+
+ if (final_message := chat[-1].get(continue_final_message)) is None:
+ raise ValueError(
+ f'continue_final_message is set but the final message has no "{continue_final_message}" to continue!'
+ )
+ if continue_final_message not in chat_template:
+ raise ValueError(
+ f'continue_final_message is set to "{continue_final_message}" but this is not an accepted field in the chat_template'
+ )
+
+ elif isinstance(final_message, (list, tuple)):
+ for content_block in reversed(final_message):
+ if "text" in content_block:
+ # Pick the last text block in the message (the first one we hit while iterating in reverse)
+ final_message = content_block["text"]
+ content_block["text"] = content_block["text"] + continue_final_message_tag
+ break
+ else:
+ raise ValueError(
+ "continue_final_message is set but we could not find any text to continue in the final message!"
+ )
+ else:
+ chat[-1][continue_final_message] = chat[-1][continue_final_message] + continue_final_message_tag
+ if return_assistant_tokens_mask:
+ rendered_chat, generation_indices = _render_with_assistant_indices(
+ compiled_template=compiled_template,
+ messages=chat,
+ tools=tool_schemas,
+ documents=documents,
+ add_generation_prompt=add_generation_prompt,
+ **kwargs,
+ )
+ all_generation_indices.append(generation_indices)
+ else:
+ rendered_chat = compiled_template.render(
+ messages=chat,
+ tools=tool_schemas,
+ documents=documents,
+ add_generation_prompt=add_generation_prompt,
+ **kwargs,
+ )
+ if continue_final_message:
+ if (final_message.strip() not in rendered_chat) or (
+ continue_final_message_tag.strip() not in rendered_chat
+ ):
+ raise ValueError(
+ "continue_final_message is set but the final message does not appear in the chat after "
+ "applying the chat template! This can happen if the chat template deletes portions of "
+ "the final message. Please verify the chat template and final message in your chat to "
+ "ensure they are compatible."
+ f"Final message to continue: {final_message.strip()}\nRendered chat:\n{rendered_chat}"
+ )
+ tag_loc = rendered_chat.rindex(continue_final_message_tag.strip())
+ if rendered_chat[tag_loc : tag_loc + len(continue_final_message_tag)] == continue_final_message_tag:
+ # The template preserves spacing, so things are simple
+ rendered_chat = rendered_chat[:tag_loc]
+ else:
+ # The message has trailing spacing that was trimmed, so we must be more cautious
+ rendered_chat = rendered_chat[:tag_loc].rstrip()
+ rendered.append(rendered_chat)
+
+ return rendered, all_generation_indices
+
+
+def is_valid_message(message):
+ """
+ Check that input is a valid message in a chat, namely a dict with "role" and "content" keys.
+ """
+ if not isinstance(message, dict):
+ return False
+ if not ("role" in message and "content" in message):
+ return False
+ return True
+
+
+class Chat:
+ """This class is intended to just be used internally for pipelines and not exposed to users. We convert chats
+ to this format because the rest of the pipeline code tends to assume that lists of messages are
+ actually a batch of samples rather than messages in the same conversation."""
+
+ def __init__(self, messages: dict):
+ for message in messages:
+ if not is_valid_message(message):
+ raise ValueError("When passing chat dicts as input, each dict must have a 'role' and 'content' key.")
+ self.messages = messages
diff --git a/lib/python3.11/site-packages/transformers/utils/constants.py b/lib/python3.11/site-packages/transformers/utils/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..fefd1b4601da04e073ff2880099ccaf87d0b1666
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/constants.py
@@ -0,0 +1,6 @@
+IMAGENET_DEFAULT_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_DEFAULT_STD = [0.229, 0.224, 0.225]
+IMAGENET_STANDARD_MEAN = [0.5, 0.5, 0.5]
+IMAGENET_STANDARD_STD = [0.5, 0.5, 0.5]
+OPENAI_CLIP_MEAN = [0.48145466, 0.4578275, 0.40821073]
+OPENAI_CLIP_STD = [0.26862954, 0.26130258, 0.27577711]
diff --git a/lib/python3.11/site-packages/transformers/utils/deprecation.py b/lib/python3.11/site-packages/transformers/utils/deprecation.py
new file mode 100644
index 0000000000000000000000000000000000000000..db0e67325d7811d41d1ca90f49813ed0fb803f0f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/deprecation.py
@@ -0,0 +1,175 @@
+# Copyright 2024 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 inspect
+import warnings
+from functools import wraps
+
+import packaging.version
+
+from .. import __version__
+from . import ExplicitEnum, is_torch_available, is_torchdynamo_compiling
+
+
+# This is needed in case we deprecate a kwarg of a function/method being compiled
+if is_torch_available():
+ import torch # noqa: F401
+
+
+class Action(ExplicitEnum):
+ NONE = "none"
+ NOTIFY = "notify"
+ NOTIFY_ALWAYS = "notify_always"
+ RAISE = "raise"
+
+
+def deprecate_kwarg(
+ old_name: str,
+ version: str,
+ new_name: str | None = None,
+ warn_if_greater_or_equal_version: bool = False,
+ raise_if_greater_or_equal_version: bool = False,
+ raise_if_both_names: bool = False,
+ additional_message: str | None = None,
+):
+ """
+ Function or method decorator to notify users about deprecated keyword arguments, replacing them with a new name if specified.
+ Note that is decorator is `torch.compile`-safe, i.e. it will not cause graph breaks (but no warning will be displayed if compiling).
+
+ This decorator allows you to:
+ - Notify users when a keyword argument is deprecated.
+ - Automatically replace deprecated keyword arguments with new ones.
+ - Raise an error if deprecated arguments are used, depending on the specified conditions.
+
+ By default, the decorator notifies the user about the deprecated argument while the `transformers.__version__` < specified `version`
+ in the decorator. To keep notifications with any version `warn_if_greater_or_equal_version=True` can be set.
+
+ Parameters:
+ old_name (`str`):
+ Name of the deprecated keyword argument.
+ version (`str`):
+ The version in which the keyword argument was (or will be) deprecated.
+ new_name (`Optional[str]`, *optional*):
+ The new name for the deprecated keyword argument. If specified, the deprecated keyword argument will be replaced with this new name.
+ warn_if_greater_or_equal_version (`bool`, *optional*, defaults to `False`):
+ Whether to show warning if current `transformers` version is greater or equal to the deprecated version.
+ raise_if_greater_or_equal_version (`bool`, *optional*, defaults to `False`):
+ Whether to raise `ValueError` if current `transformers` version is greater or equal to the deprecated version.
+ raise_if_both_names (`bool`, *optional*, defaults to `False`):
+ Whether to raise `ValueError` if both deprecated and new keyword arguments are set.
+ additional_message (`Optional[str]`, *optional*):
+ An additional message to append to the default deprecation message.
+
+ Raises:
+ ValueError:
+ If raise_if_greater_or_equal_version is True and the current version is greater than or equal to the deprecated version, or if raise_if_both_names is True and both old and new keyword arguments are provided.
+
+ Returns:
+ Callable:
+ A wrapped function that handles the deprecated keyword arguments according to the specified parameters.
+
+ Example usage with renaming argument:
+
+ ```python
+ @deprecate_kwarg("reduce_labels", new_name="do_reduce_labels", version="6.0.0")
+ def my_function(do_reduce_labels):
+ print(do_reduce_labels)
+
+ my_function(reduce_labels=True) # Will show a deprecation warning and use do_reduce_labels=True
+ ```
+
+ Example usage without renaming argument:
+
+ ```python
+ @deprecate_kwarg("max_size", version="6.0.0")
+ def my_function(max_size):
+ print(max_size)
+
+ my_function(max_size=1333) # Will show a deprecation warning
+ ```
+
+ """
+
+ deprecated_version = packaging.version.parse(version)
+ current_version = packaging.version.parse(__version__)
+ is_greater_or_equal_version = current_version >= deprecated_version
+
+ if is_greater_or_equal_version:
+ version_message = f"and removed starting from version {version}"
+ else:
+ version_message = f"and will be removed in version {version}"
+
+ def wrapper(func):
+ # Required for better warning message
+ sig = inspect.signature(func)
+ function_named_args = set(sig.parameters.keys())
+ is_instance_method = "self" in function_named_args
+ is_class_method = "cls" in function_named_args
+
+ @wraps(func)
+ def wrapped_func(*args, **kwargs):
+ # Get class + function name (just for better warning message)
+ func_name = func.__name__
+ if is_instance_method:
+ func_name = f"{args[0].__class__.__name__}.{func_name}"
+ elif is_class_method:
+ func_name = f"{args[0].__name__}.{func_name}"
+
+ minimum_action = Action.NONE
+ message = None
+
+ # deprecated kwarg and its new version are set for function call -> replace it with new name
+ if old_name in kwargs and new_name in kwargs:
+ minimum_action = Action.RAISE if raise_if_both_names else Action.NOTIFY_ALWAYS
+ message = f"Both `{old_name}` and `{new_name}` are set for `{func_name}`. Using `{new_name}={kwargs[new_name]}` and ignoring deprecated `{old_name}={kwargs[old_name]}`."
+ kwargs.pop(old_name)
+
+ # only deprecated kwarg is set for function call -> replace it with new name
+ elif old_name in kwargs and new_name is not None and new_name not in kwargs:
+ minimum_action = Action.NOTIFY
+ message = f"`{old_name}` is deprecated {version_message} for `{func_name}`. Use `{new_name}` instead."
+ kwargs[new_name] = kwargs.pop(old_name)
+
+ # deprecated kwarg is not set for function call and new name is not specified -> just notify
+ elif old_name in kwargs:
+ minimum_action = Action.NOTIFY
+ message = f"`{old_name}` is deprecated {version_message} for `{func_name}`."
+
+ if message is not None and additional_message is not None:
+ message = f"{message} {additional_message}"
+
+ # update minimum_action if argument is ALREADY deprecated (current version >= deprecated version)
+ if is_greater_or_equal_version:
+ # change to (NOTIFY, NOTIFY_ALWAYS) -> RAISE if specified
+ # in case we want to raise error for already deprecated arguments
+ if raise_if_greater_or_equal_version and minimum_action != Action.NONE:
+ minimum_action = Action.RAISE
+
+ # change to NOTIFY -> NONE if specified (NOTIFY_ALWAYS can't be changed to NONE)
+ # in case we want to ignore notifications for already deprecated arguments
+ elif not warn_if_greater_or_equal_version and minimum_action == Action.NOTIFY:
+ minimum_action = Action.NONE
+
+ # raise error or notify user
+ if minimum_action == Action.RAISE:
+ raise ValueError(message)
+ # If we are compiling, we do not raise the warning as it would break compilation
+ elif minimum_action in (Action.NOTIFY, Action.NOTIFY_ALWAYS) and not is_torchdynamo_compiling():
+ # DeprecationWarning is ignored by default, so we use FutureWarning instead
+ warnings.warn(message, FutureWarning, stacklevel=2)
+
+ return func(*args, **kwargs)
+
+ return wrapped_func
+
+ return wrapper
diff --git a/lib/python3.11/site-packages/transformers/utils/doc.py b/lib/python3.11/site-packages/transformers/utils/doc.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae111f11d19cc020544aab7dcb2fed875d6c04ab
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/doc.py
@@ -0,0 +1,1091 @@
+# 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.
+"""
+Doc utilities: Utilities related to documentation
+"""
+
+import functools
+import inspect
+import re
+import textwrap
+import types
+from collections import OrderedDict
+from typing import cast
+
+
+def get_docstring_indentation_level(func):
+ """Return the indentation level of the start of the docstring of a class or function (or method)."""
+ # We assume classes are always defined in the global scope
+ if inspect.isclass(func):
+ return 4
+ source = inspect.getsource(func)
+ first_line = source.splitlines()[0]
+ function_def_level = len(first_line) - len(first_line.lstrip())
+ return 4 + function_def_level
+
+
+def add_start_docstrings(*docstr):
+ def docstring_decorator(fn):
+ fn.__doc__ = "".join(docstr) + (fn.__doc__ if fn.__doc__ is not None else "")
+ return fn
+
+ return docstring_decorator
+
+
+def add_start_docstrings_to_model_forward(*docstr):
+ def docstring_decorator(fn):
+ class_name = f"[`{fn.__qualname__.split('.')[0]}`]"
+ intro = rf""" The {class_name} forward method, overrides the `__call__` special method.
+
+ <Tip>
+
+ Although the recipe for forward pass needs to be defined within this function, one should call the [`Module`]
+ instance afterwards instead of this since the former takes care of running the pre and post processing steps while
+ the latter silently ignores them.
+
+ </Tip>
+"""
+
+ correct_indentation = get_docstring_indentation_level(fn)
+ current_doc = fn.__doc__ if fn.__doc__ is not None else ""
+ try:
+ first_non_empty = next(line for line in current_doc.splitlines() if line.strip() != "")
+ doc_indentation = len(first_non_empty) - len(first_non_empty.lstrip())
+ except StopIteration:
+ doc_indentation = correct_indentation
+
+ docs = docstr
+ # In this case, the correct indentation level (class method, 2 Python levels) was respected, and we should
+ # correctly reindent everything. Otherwise, the doc uses a single indentation level
+ if doc_indentation == 4 + correct_indentation:
+ docs = [textwrap.indent(textwrap.dedent(doc), " " * correct_indentation) for doc in docstr]
+ intro = textwrap.indent(textwrap.dedent(intro), " " * correct_indentation)
+
+ docstring = "".join(docs) + current_doc
+ fn.__doc__ = intro + docstring
+ return fn
+
+ return docstring_decorator
+
+
+def add_end_docstrings(*docstr):
+ def docstring_decorator(fn):
+ fn.__doc__ = (fn.__doc__ if fn.__doc__ is not None else "") + "".join(docstr)
+ return fn
+
+ return docstring_decorator
+
+
+PT_RETURN_INTRODUCTION = r"""
+ Returns:
+ [`{full_output_type}`] or `tuple(torch.FloatTensor)`: A [`{full_output_type}`] or a tuple of
+ `torch.FloatTensor` (if `return_dict=False` is passed or when `config.return_dict=False`) comprising various
+ elements depending on the configuration ([`{config_class}`]) and inputs.
+
+"""
+
+
+def _get_indent(t):
+ """Returns the indentation in the first line of t"""
+ search = re.search(r"^(\s*)\S", t)
+ return "" if search is None else search.groups()[0]
+
+
+def _convert_output_args_doc(output_args_doc):
+ """Convert output_args_doc to display properly."""
+ # Split output_arg_doc in blocks argument/description
+ indent = _get_indent(output_args_doc)
+ blocks = []
+ current_block = ""
+ for line in output_args_doc.split("\n"):
+ # If the indent is the same as the beginning, the line is the name of new arg.
+ if _get_indent(line) == indent:
+ if len(current_block) > 0:
+ blocks.append(current_block[:-1])
+ current_block = f"{line}\n"
+ else:
+ # Otherwise it's part of the description of the current arg.
+ # We need to remove 2 spaces to the indentation.
+ current_block += f"{line[2:]}\n"
+ blocks.append(current_block[:-1])
+
+ # Format each block for proper rendering
+ for i in range(len(blocks)):
+ blocks[i] = re.sub(r"^(\s+)(\S+)(\s+)", r"\1- **\2**\3", blocks[i])
+ blocks[i] = re.sub(r":\s*\n\s*(\S)", r" -- \1", blocks[i])
+
+ return "\n".join(blocks)
+
+
+def _prepare_output_docstrings(output_type, config_class, min_indent=None, add_intro=True):
+ """
+ Prepares the return part of the docstring using `output_type`.
+ """
+ output_docstring = output_type.__doc__
+ params_docstring = None
+ if output_docstring is not None:
+ # Remove the head of the docstring to keep the list of args only
+ lines = output_docstring.split("\n")
+ i = 0
+ while i < len(lines) and re.search(r"^\s*(Args|Parameters):\s*$", lines[i]) is None:
+ i += 1
+ if i < len(lines):
+ params_docstring = "\n".join(lines[(i + 1) :])
+ params_docstring = _convert_output_args_doc(params_docstring)
+ elif add_intro:
+ raise ValueError(
+ f"No `Args` or `Parameters` section is found in the docstring of `{output_type.__name__}`. Make sure it has "
+ "docstring and contain either `Args` or `Parameters`."
+ )
+
+ # Add the return introduction
+ if add_intro:
+ full_output_type = f"{output_type.__module__}.{output_type.__name__}"
+ intro = PT_RETURN_INTRODUCTION.format(full_output_type=full_output_type, config_class=config_class)
+ else:
+ full_output_type = str(output_type)
+ intro = f"\nReturns:\n `{full_output_type}`"
+ if params_docstring is not None:
+ intro += ":\n"
+
+ result = intro
+ if params_docstring is not None:
+ result += params_docstring
+
+ # Apply minimum indent if necessary
+ if min_indent is not None:
+ lines = result.split("\n")
+ # Find the indent of the first nonempty line
+ i = 0
+ while len(lines[i]) == 0:
+ i += 1
+ indent = len(_get_indent(lines[i]))
+ # If too small, add indentation to all nonempty lines
+ if indent < min_indent:
+ to_add = " " * (min_indent - indent)
+ lines = [(f"{to_add}{line}" if len(line) > 0 else line) for line in lines]
+ result = "\n".join(lines)
+
+ return result
+
+
+FAKE_MODEL_DISCLAIMER = """
+ <Tip warning={true}>
+
+ This example uses a random model as the real ones are all very big. To get proper results, you should use
+ {real_checkpoint} instead of {fake_checkpoint}. If you get out-of-memory when loading that checkpoint, you can try
+ adding `device_map="auto"` in the `from_pretrained` call.
+
+ </Tip>
+"""
+
+
+PT_TOKEN_CLASSIFICATION_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, {model_class}
+ >>> import torch
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> inputs = tokenizer(
+ ... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
+ ... )
+
+ >>> with torch.no_grad():
+ ... logits = model(**inputs).logits
+
+ >>> predicted_token_class_ids = logits.argmax(-1)
+
+ >>> # Note that tokens are classified rather then input words which means that
+ >>> # there might be more predicted token classes than words.
+ >>> # Multiple token classes might account for the same word
+ >>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
+ >>> predicted_tokens_classes
+ {expected_output}
+
+ >>> labels = predicted_token_class_ids
+ >>> loss = model(**inputs, labels=labels).loss
+ >>> round(loss.item(), 2)
+ {expected_loss}
+ ```
+"""
+
+PT_QUESTION_ANSWERING_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, {model_class}
+ >>> import torch
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
+
+ >>> inputs = tokenizer(question, text, return_tensors="pt")
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> answer_start_index = outputs.start_logits.argmax()
+ >>> answer_end_index = outputs.end_logits.argmax()
+
+ >>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
+ >>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
+ {expected_output}
+
+ >>> # target is "nice puppet"
+ >>> target_start_index = torch.tensor([{qa_target_start_index}])
+ >>> target_end_index = torch.tensor([{qa_target_end_index}])
+
+ >>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
+ >>> loss = outputs.loss
+ >>> round(loss.item(), 2)
+ {expected_loss}
+ ```
+"""
+
+PT_SEQUENCE_CLASSIFICATION_SAMPLE = r"""
+ Example of single-label classification:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoTokenizer, {model_class}
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... logits = model(**inputs).logits
+
+ >>> predicted_class_id = logits.argmax().item()
+ >>> model.config.id2label[predicted_class_id]
+ {expected_output}
+
+ >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
+ >>> num_labels = len(model.config.id2label)
+ >>> model = {model_class}.from_pretrained("{checkpoint}", num_labels=num_labels)
+
+ >>> labels = torch.tensor([1])
+ >>> loss = model(**inputs, labels=labels).loss
+ >>> round(loss.item(), 2)
+ {expected_loss}
+ ```
+
+ Example of multi-label classification:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoTokenizer, {model_class}
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}", problem_type="multi_label_classification")
+
+ >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... logits = model(**inputs).logits
+
+ >>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
+
+ >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
+ >>> num_labels = len(model.config.id2label)
+ >>> model = {model_class}.from_pretrained(
+ ... "{checkpoint}", num_labels=num_labels, problem_type="multi_label_classification"
+ ... )
+
+ >>> labels = torch.sum(
+ ... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
+ ... ).to(torch.float)
+ >>> loss = model(**inputs, labels=labels).loss
+ ```
+"""
+
+PT_MASKED_LM_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, {model_class}
+ >>> import torch
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> inputs = tokenizer("The capital of France is {mask}.", return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... logits = model(**inputs).logits
+
+ >>> # retrieve index of {mask}
+ >>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
+
+ >>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
+ >>> tokenizer.decode(predicted_token_id)
+ {expected_output}
+
+ >>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
+ >>> # mask labels of non-{mask} tokens
+ >>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
+
+ >>> outputs = model(**inputs, labels=labels)
+ >>> round(outputs.loss.item(), 2)
+ {expected_loss}
+ ```
+"""
+
+PT_BASE_MODEL_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, {model_class}
+ >>> import torch
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
+ >>> outputs = model(**inputs)
+
+ >>> last_hidden_states = outputs.last_hidden_state
+ ```
+"""
+
+PT_MULTIPLE_CHOICE_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoTokenizer, {model_class}
+ >>> import torch
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
+ >>> choice0 = "It is eaten with a fork and a knife."
+ >>> choice1 = "It is eaten while held in the hand."
+ >>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
+
+ >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
+ >>> outputs = model(**{{k: v.unsqueeze(0) for k, v in encoding.items()}}, labels=labels) # batch size is 1
+
+ >>> # the linear classifier still needs to be trained
+ >>> loss = outputs.loss
+ >>> logits = outputs.logits
+ ```
+"""
+
+PT_CAUSAL_LM_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> import torch
+ >>> from transformers import AutoTokenizer, {model_class}
+
+ >>> tokenizer = AutoTokenizer.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
+ >>> outputs = model(**inputs, labels=inputs["input_ids"])
+ >>> loss = outputs.loss
+ >>> logits = outputs.logits
+ ```
+"""
+
+PT_SPEECH_BASE_MODEL_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoProcessor, {model_class}
+ >>> import torch
+ >>> from datasets import load_dataset
+
+ >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
+ >>> dataset = dataset.sort("id")
+ >>> sampling_rate = dataset.features["audio"].sampling_rate
+
+ >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> # audio file is decoded on the fly
+ >>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> last_hidden_states = outputs.last_hidden_state
+ >>> list(last_hidden_states.shape)
+ {expected_output}
+ ```
+"""
+
+PT_SPEECH_CTC_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoProcessor, {model_class}
+ >>> from datasets import load_dataset
+ >>> import torch
+
+ >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
+ >>> dataset = dataset.sort("id")
+ >>> sampling_rate = dataset.features["audio"].sampling_rate
+
+ >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> # audio file is decoded on the fly
+ >>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
+ >>> with torch.no_grad():
+ ... logits = model(**inputs).logits
+ >>> predicted_ids = torch.argmax(logits, dim=-1)
+
+ >>> # transcribe speech
+ >>> transcription = processor.batch_decode(predicted_ids)
+ >>> transcription[0]
+ {expected_output}
+
+ >>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids
+
+ >>> # compute loss
+ >>> loss = model(**inputs).loss
+ >>> round(loss.item(), 2)
+ {expected_loss}
+ ```
+"""
+
+PT_SPEECH_SEQ_CLASS_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoFeatureExtractor, {model_class}
+ >>> from datasets import load_dataset
+ >>> import torch
+
+ >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
+ >>> dataset = dataset.sort("id")
+ >>> sampling_rate = dataset.features["audio"].sampling_rate
+
+ >>> feature_extractor = AutoFeatureExtractor.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> # audio file is decoded on the fly
+ >>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... logits = model(**inputs).logits
+
+ >>> predicted_class_ids = torch.argmax(logits, dim=-1).item()
+ >>> predicted_label = model.config.id2label[predicted_class_ids]
+ >>> predicted_label
+ {expected_output}
+
+ >>> # compute loss - target_label is e.g. "down"
+ >>> target_label = model.config.id2label[0]
+ >>> inputs["labels"] = torch.tensor([model.config.label2id[target_label]])
+ >>> loss = model(**inputs).loss
+ >>> round(loss.item(), 2)
+ {expected_loss}
+ ```
+"""
+
+
+PT_SPEECH_FRAME_CLASS_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoFeatureExtractor, {model_class}
+ >>> from datasets import load_dataset
+ >>> import torch
+
+ >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
+ >>> dataset = dataset.sort("id")
+ >>> sampling_rate = dataset.features["audio"].sampling_rate
+
+ >>> feature_extractor = AutoFeatureExtractor.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> # audio file is decoded on the fly
+ >>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
+ >>> with torch.no_grad():
+ ... logits = model(**inputs).logits
+
+ >>> probabilities = torch.sigmoid(logits[0])
+ >>> # labels is a one-hot array of shape (num_frames, num_speakers)
+ >>> labels = (probabilities > 0.5).long()
+ >>> labels[0].tolist()
+ {expected_output}
+ ```
+"""
+
+
+PT_SPEECH_XVECTOR_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoFeatureExtractor, {model_class}
+ >>> from datasets import load_dataset
+ >>> import torch
+
+ >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
+ >>> dataset = dataset.sort("id")
+ >>> sampling_rate = dataset.features["audio"].sampling_rate
+
+ >>> feature_extractor = AutoFeatureExtractor.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> # audio file is decoded on the fly
+ >>> inputs = feature_extractor(
+ ... [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
+ ... )
+ >>> with torch.no_grad():
+ ... embeddings = model(**inputs).embeddings
+
+ >>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()
+
+ >>> # the resulting embeddings can be used for cosine similarity-based retrieval
+ >>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
+ >>> similarity = cosine_sim(embeddings[0], embeddings[1])
+ >>> threshold = 0.7 # the optimal threshold is dataset-dependent
+ >>> if similarity < threshold:
+ ... print("Speakers are not the same!")
+ >>> round(similarity.item(), 2)
+ {expected_output}
+ ```
+"""
+
+PT_VISION_BASE_MODEL_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, {model_class}
+ >>> import torch
+ >>> from datasets import load_dataset
+
+ >>> dataset = load_dataset("huggingface/cats-image")
+ >>> image = dataset["test"]["image"][0]
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> inputs = image_processor(image, return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> last_hidden_states = outputs.last_hidden_state
+ >>> list(last_hidden_states.shape)
+ {expected_output}
+ ```
+"""
+
+PT_VISION_SEQ_CLASS_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, {model_class}
+ >>> import torch
+ >>> from datasets import load_dataset
+
+ >>> dataset = load_dataset("huggingface/cats-image")
+ >>> image = dataset["test"]["image"][0]
+
+ >>> image_processor = AutoImageProcessor.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> inputs = image_processor(image, return_tensors="pt")
+
+ >>> with torch.no_grad():
+ ... logits = model(**inputs).logits
+
+ >>> # model predicts one of the 1000 ImageNet classes
+ >>> predicted_label = logits.argmax(-1).item()
+ >>> print(model.config.id2label[predicted_label])
+ {expected_output}
+ ```
+"""
+
+
+PT_SAMPLE_DOCSTRINGS = {
+ "SequenceClassification": PT_SEQUENCE_CLASSIFICATION_SAMPLE,
+ "QuestionAnswering": PT_QUESTION_ANSWERING_SAMPLE,
+ "TokenClassification": PT_TOKEN_CLASSIFICATION_SAMPLE,
+ "MultipleChoice": PT_MULTIPLE_CHOICE_SAMPLE,
+ "MaskedLM": PT_MASKED_LM_SAMPLE,
+ "LMHead": PT_CAUSAL_LM_SAMPLE,
+ "BaseModel": PT_BASE_MODEL_SAMPLE,
+ "SpeechBaseModel": PT_SPEECH_BASE_MODEL_SAMPLE,
+ "CTC": PT_SPEECH_CTC_SAMPLE,
+ "AudioClassification": PT_SPEECH_SEQ_CLASS_SAMPLE,
+ "AudioFrameClassification": PT_SPEECH_FRAME_CLASS_SAMPLE,
+ "AudioXVector": PT_SPEECH_XVECTOR_SAMPLE,
+ "VisionBaseModel": PT_VISION_BASE_MODEL_SAMPLE,
+ "ImageClassification": PT_VISION_SEQ_CLASS_SAMPLE,
+}
+
+
+TEXT_TO_AUDIO_SPECTROGRAM_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoProcessor, {model_class}, SpeechT5HifiGan
+
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
+ >>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
+ >>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
+
+ >>> # generate speech
+ >>> speech = model.generate(inputs["input_ids"], speaker_embeddings=speaker_embeddings, vocoder=vocoder)
+ ```
+"""
+
+
+TEXT_TO_AUDIO_WAVEFORM_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoProcessor, {model_class}
+
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
+ >>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
+
+ >>> # generate speech
+ >>> speech = model(inputs["input_ids"])
+ ```
+"""
+
+
+AUDIO_FRAME_CLASSIFICATION_SAMPLE = PT_SPEECH_FRAME_CLASS_SAMPLE
+
+
+AUDIO_XVECTOR_SAMPLE = PT_SPEECH_XVECTOR_SAMPLE
+
+
+DEPTH_ESTIMATION_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from transformers import AutoImageProcessor, {model_class}
+ >>> import torch
+ >>> from PIL import Image
+ >>> import httpx
+ >>> from io import BytesIO
+
+ >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+ >>> with httpx.stream("GET", url) as response:
+ ... image = Image.open(BytesIO(response.read())).convert("RGB")
+
+ >>> processor = AutoImageProcessor.from_pretrained("{checkpoint}")
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+
+ >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+ >>> model.to(device)
+
+ >>> # prepare image for the model
+ >>> inputs = processor(images=image, return_tensors="pt").to(device)
+
+ >>> with torch.no_grad():
+ ... outputs = model(**inputs)
+
+ >>> # interpolate to original size
+ >>> post_processed_output = processor.post_process_depth_estimation(
+ ... outputs, [(image.height, image.width)],
+ ... )
+ >>> predicted_depth = post_processed_output[0]["predicted_depth"]
+ ```
+"""
+
+
+VIDEO_CLASSIFICATION_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+ZERO_SHOT_OBJECT_DETECTION_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+IMAGE_TO_IMAGE_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+IMAGE_FEATURE_EXTRACTION_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+DOCUMENT_QUESTION_ANSWERING_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+NEXT_SENTENCE_PREDICTION_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+MULTIPLE_CHOICE_SAMPLE = PT_MULTIPLE_CHOICE_SAMPLE
+
+
+PRETRAINING_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+MASK_GENERATION_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+VISUAL_QUESTION_ANSWERING_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+TEXT_GENERATION_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+IMAGE_CLASSIFICATION_SAMPLE = PT_VISION_SEQ_CLASS_SAMPLE
+
+
+IMAGE_SEGMENTATION_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+FILL_MASK_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+OBJECT_DETECTION_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+QUESTION_ANSWERING_SAMPLE = PT_QUESTION_ANSWERING_SAMPLE
+
+
+TEXT_CLASSIFICATION_SAMPLE = PT_SEQUENCE_CLASSIFICATION_SAMPLE
+
+
+TABLE_QUESTION_ANSWERING_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+TOKEN_CLASSIFICATION_SAMPLE = PT_TOKEN_CLASSIFICATION_SAMPLE
+
+
+AUDIO_CLASSIFICATION_SAMPLE = PT_SPEECH_SEQ_CLASS_SAMPLE
+
+
+AUTOMATIC_SPEECH_RECOGNITION_SAMPLE = PT_SPEECH_CTC_SAMPLE
+
+
+ZERO_SHOT_IMAGE_CLASSIFICATION_SAMPLE = r"""
+ Example:
+
+ ```python
+ ```
+"""
+
+
+IMAGE_TEXT_TO_TEXT_GENERATION_SAMPLE = r"""
+ Example:
+
+ ```python
+ >>> from PIL import Image
+ >>> from transformers import AutoProcessor, {model_class}
+
+ >>> model = {model_class}.from_pretrained("{checkpoint}")
+ >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
+
+ >>> messages = [
+ ... {{
+ ... "role": "user", "content": [
+ ... {{"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}},
+ ... {{"type": "text", "text": "Where is the cat standing?"}},
+ ... ]
+ ... }},
+ ... ]
+
+ >>> inputs = processor.apply_chat_template(
+ ... messages,
+ ... tokenize=True,
+ ... return_dict=True,
+ ... return_tensors="pt",
+ ... add_generation_prompt=True
+ ... )
+ >>> # Generate
+ >>> generate_ids = model.generate(**inputs)
+ >>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
+ ```
+"""
+
+
+PIPELINE_TASKS_TO_SAMPLE_DOCSTRINGS = OrderedDict(
+ [
+ ("text-to-audio-spectrogram", TEXT_TO_AUDIO_SPECTROGRAM_SAMPLE),
+ ("text-to-audio-waveform", TEXT_TO_AUDIO_WAVEFORM_SAMPLE),
+ ("automatic-speech-recognition", AUTOMATIC_SPEECH_RECOGNITION_SAMPLE),
+ ("audio-frame-classification", AUDIO_FRAME_CLASSIFICATION_SAMPLE),
+ ("audio-classification", AUDIO_CLASSIFICATION_SAMPLE),
+ ("audio-xvector", AUDIO_XVECTOR_SAMPLE),
+ ("image-text-to-text", IMAGE_TEXT_TO_TEXT_GENERATION_SAMPLE),
+ ("depth-estimation", DEPTH_ESTIMATION_SAMPLE),
+ ("video-classification", VIDEO_CLASSIFICATION_SAMPLE),
+ ("zero-shot-image-classification", ZERO_SHOT_IMAGE_CLASSIFICATION_SAMPLE),
+ ("image-classification", IMAGE_CLASSIFICATION_SAMPLE),
+ ("zero-shot-object-detection", ZERO_SHOT_OBJECT_DETECTION_SAMPLE),
+ ("object-detection", OBJECT_DETECTION_SAMPLE),
+ ("image-segmentation", IMAGE_SEGMENTATION_SAMPLE),
+ ("image-feature-extraction", IMAGE_FEATURE_EXTRACTION_SAMPLE),
+ ("text-generation", TEXT_GENERATION_SAMPLE),
+ ("table-question-answering", TABLE_QUESTION_ANSWERING_SAMPLE),
+ ("document-question-answering", DOCUMENT_QUESTION_ANSWERING_SAMPLE),
+ ("next-sentence-prediction", NEXT_SENTENCE_PREDICTION_SAMPLE),
+ ("multiple-choice", MULTIPLE_CHOICE_SAMPLE),
+ ("text-classification", TEXT_CLASSIFICATION_SAMPLE),
+ ("token-classification", TOKEN_CLASSIFICATION_SAMPLE),
+ ("fill-mask", FILL_MASK_SAMPLE),
+ ("mask-generation", MASK_GENERATION_SAMPLE),
+ ("pretraining", PRETRAINING_SAMPLE),
+ ]
+)
+
+# Ordered dict to look for more specialized model mappings first
+# before falling back to the more generic ones.
+MODELS_TO_PIPELINE = OrderedDict(
+ [
+ # Audio
+ ("MODEL_FOR_TEXT_TO_SPECTROGRAM_MAPPING_NAMES", "text-to-audio-spectrogram"),
+ ("MODEL_FOR_TEXT_TO_WAVEFORM_MAPPING_NAMES", "text-to-audio-waveform"),
+ ("MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES", "automatic-speech-recognition"),
+ ("MODEL_FOR_CTC_MAPPING_NAMES", "automatic-speech-recognition"),
+ ("MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING_NAMES", "audio-frame-classification"),
+ ("MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES", "audio-classification"),
+ ("MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMES", "audio-xvector"),
+ # Vision
+ ("MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES", "image-text-to-text"),
+ ("MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES", "depth-estimation"),
+ ("MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES", "video-classification"),
+ ("MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING_NAMES", "zero-shot-image-classification"),
+ ("MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES", "image-classification"),
+ ("MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING_NAMES", "zero-shot-object-detection"),
+ ("MODEL_FOR_OBJECT_DETECTION_MAPPING_NAMES", "object-detection"),
+ ("MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES", "image-segmentation"),
+ ("MODEL_FOR_IMAGE_MAPPING_NAMES", "image-feature-extraction"),
+ # Text/tokens
+ ("MODEL_FOR_CAUSAL_LM_MAPPING_NAMES", "text-generation"),
+ ("MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING_NAMES", "table-question-answering"),
+ ("MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES", "document-question-answering"),
+ ("MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES", "next-sentence-prediction"),
+ ("MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES", "multiple-choice"),
+ ("MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES", "text-classification"),
+ ("MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES", "token-classification"),
+ ("MODEL_FOR_MASKED_LM_MAPPING_NAMES", "fill-mask"),
+ ("MODEL_FOR_MASK_GENERATION_MAPPING_NAMES", "mask-generation"),
+ ("MODEL_FOR_PRETRAINING_MAPPING_NAMES", "pretraining"),
+ ]
+)
+
+
+def filter_outputs_from_example(docstring, **kwargs):
+ """
+ Removes the lines testing an output with the doctest syntax in a code sample when it's set to `None`.
+ """
+ for key, value in kwargs.items():
+ if value is not None:
+ continue
+
+ doc_key = "{" + key + "}"
+ docstring = re.sub(rf"\n([^\n]+)\n\s+{doc_key}\n", "\n", docstring)
+
+ return docstring
+
+
+def add_code_sample_docstrings(
+ *docstr,
+ processor_class=None,
+ checkpoint=None,
+ output_type=None,
+ config_class=None,
+ mask="[MASK]",
+ qa_target_start_index=14,
+ qa_target_end_index=15,
+ model_cls=None,
+ modality=None,
+ expected_output=None,
+ expected_loss=None,
+ real_checkpoint=None,
+ revision=None,
+):
+ def docstring_decorator(fn):
+ # model_class defaults to function's class if not specified otherwise
+ model_class = fn.__qualname__.split(".")[0] if model_cls is None else model_cls
+
+ sample_docstrings = PT_SAMPLE_DOCSTRINGS
+
+ # putting all kwargs for docstrings in a dict to be used
+ # with the `.format(**doc_kwargs)`. Note that string might
+ # be formatted with non-existing keys, which is fine.
+ doc_kwargs = {
+ "model_class": model_class,
+ "processor_class": processor_class,
+ "checkpoint": checkpoint,
+ "mask": mask,
+ "qa_target_start_index": qa_target_start_index,
+ "qa_target_end_index": qa_target_end_index,
+ "expected_output": expected_output,
+ "expected_loss": expected_loss,
+ "real_checkpoint": real_checkpoint,
+ "fake_checkpoint": checkpoint,
+ "true": "{true}", # For <Tip warning={true}> syntax that conflicts with formatting.
+ }
+
+ if ("SequenceClassification" in model_class or "AudioClassification" in model_class) and modality == "audio":
+ code_sample = sample_docstrings["AudioClassification"]
+ elif "SequenceClassification" in model_class:
+ code_sample = sample_docstrings["SequenceClassification"]
+ elif "QuestionAnswering" in model_class:
+ code_sample = sample_docstrings["QuestionAnswering"]
+ elif "TokenClassification" in model_class:
+ code_sample = sample_docstrings["TokenClassification"]
+ elif "MultipleChoice" in model_class:
+ code_sample = sample_docstrings["MultipleChoice"]
+ elif "MaskedLM" in model_class or model_class in ["FlaubertWithLMHeadModel", "XLMWithLMHeadModel"]:
+ code_sample = sample_docstrings["MaskedLM"]
+ elif "LMHead" in model_class or "CausalLM" in model_class:
+ code_sample = sample_docstrings["LMHead"]
+ elif "CTC" in model_class:
+ code_sample = sample_docstrings["CTC"]
+ elif "AudioFrameClassification" in model_class:
+ code_sample = sample_docstrings["AudioFrameClassification"]
+ elif "XVector" in model_class and modality == "audio":
+ code_sample = sample_docstrings["AudioXVector"]
+ elif "Model" in model_class and modality == "audio":
+ code_sample = sample_docstrings["SpeechBaseModel"]
+ elif "Model" in model_class and modality == "vision":
+ code_sample = sample_docstrings["VisionBaseModel"]
+ elif "Model" in model_class or "Encoder" in model_class:
+ code_sample = sample_docstrings["BaseModel"]
+ elif "ImageClassification" in model_class:
+ code_sample = sample_docstrings["ImageClassification"]
+ else:
+ raise ValueError(f"Docstring can't be built for model {model_class}")
+
+ code_sample = filter_outputs_from_example(
+ code_sample, expected_output=expected_output, expected_loss=expected_loss
+ )
+ if real_checkpoint is not None:
+ code_sample = FAKE_MODEL_DISCLAIMER + code_sample
+ func_doc = (fn.__doc__ or "") + "".join(docstr)
+ output_doc = "" if output_type is None else _prepare_output_docstrings(output_type, config_class)
+ built_doc = code_sample.format(**doc_kwargs)
+ if revision is not None:
+ if re.match(r"^refs/pr/\\d+", revision):
+ raise ValueError(
+ f"The provided revision '{revision}' is incorrect. It should point to"
+ " a pull request reference on the hub like 'refs/pr/6'"
+ )
+ built_doc = built_doc.replace(
+ f'from_pretrained("{checkpoint}")', f'from_pretrained("{checkpoint}", revision="{revision}")'
+ )
+
+ fn.__doc__ = func_doc + output_doc + built_doc
+ return fn
+
+ return docstring_decorator
+
+
+def replace_return_docstrings(output_type=None, config_class=None):
+ def docstring_decorator(fn):
+ func_doc = fn.__doc__
+ lines = func_doc.split("\n")
+ i = 0
+ while i < len(lines) and re.search(r"^\s*Returns?:\s*$", lines[i]) is None:
+ i += 1
+ if i < len(lines):
+ indent = len(_get_indent(lines[i]))
+ lines[i] = _prepare_output_docstrings(output_type, config_class, min_indent=indent)
+ func_doc = "\n".join(lines)
+ else:
+ raise ValueError(
+ f"The function {fn} should have an empty 'Return:' or 'Returns:' in its docstring as placeholder, "
+ f"current docstring is:\n{func_doc}"
+ )
+ fn.__doc__ = func_doc
+ return fn
+
+ return docstring_decorator
+
+
+def copy_func(f):
+ """Returns a copy of a function f."""
+ # Based on http://stackoverflow.com/a/6528148/190597 (Glenn Maynard)
+ g = types.FunctionType(f.__code__, f.__globals__, name=f.__name__, argdefs=f.__defaults__, closure=f.__closure__)
+ g = cast(types.FunctionType, functools.update_wrapper(g, f))
+ g.__kwdefaults__ = f.__kwdefaults__
+ return g
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_detectron2_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_detectron2_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..22ec32fe30a1b9abbc5d810510d97d5c81082561
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_detectron2_objects.py
@@ -0,0 +1,11 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import requires_backends
+
+
+class LayoutLMv2Model:
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["detectron2"])
+
+ @classmethod
+ def from_pretrained(cls, *args, **kwargs):
+ requires_backends(cls, ["detectron2"])
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_essentia_and_librosa_and_pretty_midi_and_scipy_and_torch_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_essentia_and_librosa_and_pretty_midi_and_scipy_and_torch_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6d75a6ec22e90427c972a753a24afd1a780758f
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_essentia_and_librosa_and_pretty_midi_and_scipy_and_torch_objects.py
@@ -0,0 +1,23 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import DummyObject, requires_backends
+
+
+class Pop2PianoFeatureExtractor(metaclass=DummyObject):
+ _backends = ["essentia", "librosa", "pretty_midi", "scipy", "torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["essentia", "librosa", "pretty_midi", "scipy", "torch"])
+
+
+class Pop2PianoTokenizer(metaclass=DummyObject):
+ _backends = ["essentia", "librosa", "pretty_midi", "scipy", "torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["essentia", "librosa", "pretty_midi", "scipy", "torch"])
+
+
+class Pop2PianoProcessor(metaclass=DummyObject):
+ _backends = ["essentia", "librosa", "pretty_midi", "scipy", "torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["essentia", "librosa", "pretty_midi", "scipy", "torch"])
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_mistral_common_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_mistral_common_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..36cdb01cea4534203b879b8c7f30778cc34fe5ad
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_mistral_common_objects.py
@@ -0,0 +1,9 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import DummyObject, requires_backends
+
+
+class MistralCommonBackend(metaclass=DummyObject):
+ _backends = ["mistral-common"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["mistral-common"])
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_music_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_music_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..89052be47c1d32bac5cbd6fceab183fc1d75d3bf
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_music_objects.py
@@ -0,0 +1,16 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import DummyObject, requires_backends
+
+
+class Pop2PianoFeatureExtractor(metaclass=DummyObject):
+ _backends = ["music"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["music"])
+
+
+class Pop2PianoTokenizer(metaclass=DummyObject):
+ _backends = ["music"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["music"])
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_pt_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_pt_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..191783b25df3cc8e9d9bed4a8101bf025c6df2a3
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_pt_objects.py
@@ -0,0 +1,488 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import DummyObject, requires_backends
+
+
+class Cache(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class DynamicCache(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class EncoderDecoderCache(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class QuantizedCache(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class StaticCache(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class GlueDataset(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class GlueDataTrainingArguments(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class SquadDataset(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class SquadDataTrainingArguments(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class AlternatingCodebooksLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class BayesianDetectorConfig(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class BayesianDetectorModel(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class ClassifierFreeGuidanceLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class EncoderNoRepeatNGramLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class EncoderRepetitionPenaltyLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class EosTokenCriteria(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class EpsilonLogitsWarper(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class EtaLogitsWarper(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class ExponentialDecayLengthPenalty(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class ForcedBOSTokenLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class ForcedEOSTokenLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class GenerationMixin(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class InfNanRemoveLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class LogitNormalization(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class LogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class LogitsProcessorList(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class MaxLengthCriteria(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class MaxTimeCriteria(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class MinLengthLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class MinNewTokensLengthLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class MinPLogitsWarper(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class NoBadWordsLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class NoRepeatNGramLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class PrefixConstrainedLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class RepetitionPenaltyLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class SequenceBiasLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class StoppingCriteria(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class StoppingCriteriaList(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class StopStringCriteria(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class SuppressTokensAtBeginLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class SuppressTokensLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class SynthIDTextWatermarkDetector(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class SynthIDTextWatermarkingConfig(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class SynthIDTextWatermarkLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class TemperatureLogitsWarper(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class TopKLogitsWarper(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class TopPLogitsWarper(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class TypicalLogitsWarper(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class UnbatchedClassifierFreeGuidanceLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class WatermarkDetector(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class WatermarkLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class WhisperTimeStampLogitsProcessor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class TorchExportableModuleWithStaticCache(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+def convert_and_export_with_cache(*args, **kwargs):
+ requires_backends(convert_and_export_with_cache, ["torch"])
+
+
+class AttentionMaskInterface(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+def model_addition_debugger_context(*args, **kwargs):
+ requires_backends(model_addition_debugger_context, ["torch"])
+
+
+class GradientCheckpointingLayer(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+ROPE_INIT_FUNCTIONS = None
+
+
+def dynamic_rope_update(*args, **kwargs):
+ requires_backends(dynamic_rope_update, ["torch"])
+
+
+class AttentionInterface(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class PreTrainedModel(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+class Adafactor(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+def get_constant_schedule(*args, **kwargs):
+ requires_backends(get_constant_schedule, ["torch"])
+
+
+def get_constant_schedule_with_warmup(*args, **kwargs):
+ requires_backends(get_constant_schedule_with_warmup, ["torch"])
+
+
+def get_cosine_schedule_with_warmup(*args, **kwargs):
+ requires_backends(get_cosine_schedule_with_warmup, ["torch"])
+
+
+def get_cosine_with_hard_restarts_schedule_with_warmup(*args, **kwargs):
+ requires_backends(get_cosine_with_hard_restarts_schedule_with_warmup, ["torch"])
+
+
+def get_inverse_sqrt_schedule(*args, **kwargs):
+ requires_backends(get_inverse_sqrt_schedule, ["torch"])
+
+
+def get_linear_schedule_with_warmup(*args, **kwargs):
+ requires_backends(get_linear_schedule_with_warmup, ["torch"])
+
+
+def get_polynomial_decay_schedule_with_warmup(*args, **kwargs):
+ requires_backends(get_polynomial_decay_schedule_with_warmup, ["torch"])
+
+
+def get_scheduler(*args, **kwargs):
+ requires_backends(get_scheduler, ["torch"])
+
+
+def get_wsd_schedule(*args, **kwargs):
+ requires_backends(get_wsd_schedule, ["torch"])
+
+
+class Conv1D(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+def apply_chunking_to_forward(*args, **kwargs):
+ requires_backends(apply_chunking_to_forward, ["torch"])
+
+
+class Trainer(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
+
+
+def torch_distributed_zero_first(*args, **kwargs):
+ requires_backends(torch_distributed_zero_first, ["torch"])
+
+
+class Seq2SeqTrainer(metaclass=DummyObject):
+ _backends = ["torch"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torch"])
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_sentencepiece_and_tokenizers_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_sentencepiece_and_tokenizers_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..38775330a81d91030f000e58c0e6035bba1c0f31
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_sentencepiece_and_tokenizers_objects.py
@@ -0,0 +1,9 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import DummyObject, requires_backends
+
+
+SLOW_TO_FAST_CONVERTERS = None
+
+
+def convert_slow_tokenizer(*args, **kwargs):
+ requires_backends(convert_slow_tokenizer, ["sentencepiece", "tokenizers"])
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_speech_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_speech_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bf08ebea42b4595ae1f8bbc2afcddf0630dcf4b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_speech_objects.py
@@ -0,0 +1,16 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import DummyObject, requires_backends
+
+
+class ASTFeatureExtractor(metaclass=DummyObject):
+ _backends = ["speech"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["speech"])
+
+
+class Speech2TextFeatureExtractor(metaclass=DummyObject):
+ _backends = ["speech"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["speech"])
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_timm_and_torchvision_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_timm_and_torchvision_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b67b5dac58db13278706e0838aebbe495a9d2fc
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_timm_and_torchvision_objects.py
@@ -0,0 +1,9 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import DummyObject, requires_backends
+
+
+class TimmWrapperImageProcessor(metaclass=DummyObject):
+ _backends = ["timm", "torchvision"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["timm", "torchvision"])
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_tokenizers_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_tokenizers_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e592f28570fedf4870d185e92d504fa82f6b545
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_tokenizers_objects.py
@@ -0,0 +1,9 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import DummyObject, requires_backends
+
+
+class PreTrainedTokenizerFast(metaclass=DummyObject):
+ _backends = ["tokenizers"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["tokenizers"])
diff --git a/lib/python3.11/site-packages/transformers/utils/dummy_torchvision_objects.py b/lib/python3.11/site-packages/transformers/utils/dummy_torchvision_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d19003699b01ffc4027c1b2039894760729fb5b
--- /dev/null
+++ b/lib/python3.11/site-packages/transformers/utils/dummy_torchvision_objects.py
@@ -0,0 +1,16 @@
+# This file is autogenerated by the command `make fix-copies`, do not edit.
+from ..utils import DummyObject, requires_backends
+
+
+class TorchvisionBackend(metaclass=DummyObject):
+ _backends = ["torchvision"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torchvision"])
+
+
+class BaseVideoProcessor(metaclass=DummyObject):
+ _backends = ["torchvision"]
+
+ def __init__(self, *args, **kwargs):
+ requires_backends(self, ["torchvision"])