Upload model

README.md

@@ -0,0 +1,199 @@
+---
+library_name: transformers
+tags: []
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]

config.json

@@ -0,0 +1,14 @@
+{
+  "architectures": [
+    "Model"
+  ],
+  "auto_map": {
+    "AutoConfig": "minimal_hub_utils.Config",
+    "AutoModel": "minimal_hub_utils.Model"
+  },
+  "input_dim": 4,
+  "model_type": "dummy",
+  "output_dim": 2,
+  "torch_dtype": "float32",
+  "transformers_version": "4.51.3"
+}

minimal_hub_utils.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+from pathlib import Path
+from torch import nn
+from transformers import AutoConfig, AutoModel, AutoTokenizer
+from transformers import PretrainedConfig, PreTrainedModel, PreTrainedTokenizer
+
+def make_config_class(model_args: dict, model_type: str) -> type[PretrainedConfig]:
+    model_type_ = model_type
+
+    class Config(PretrainedConfig):
+        model_type = model_type_
+
+        def __init__(self, **kwargs):
+            for k, v in model_args.items():
+                setattr(self, k, kwargs.get(k, v))
+
+            super().__init__(**kwargs)
+
+    return Config
+
+
+def make_model_class(base_class: type[nn.Module]) -> type[PreTrainedModel]:
+    class Model(PreTrainedModel):
+        config_class: type[PretrainedConfig]
+
+        def __init__(self, config: PretrainedConfig, *args, **kwargs):
+            super().__init__(config)
+            self._model = base_class(config, *args, **kwargs)
+
+        def forward(self, *args, **kwargs):
+            return self._model(*args, **kwargs)
+
+    return Model
+
+
+def make_tokenizer_class(
+    vocab: list[str],
+    special_tokens: dict[str, str]
+) -> type[PreTrainedTokenizer]:
+
+    for key in special_tokens:
+        if key not in ["unk", "pad", "bos", "eos", "sep", "cls", "mask"]:
+            raise ValueError(f"unrecognized special token key: `{key}`")
+
+    unk_token = special_tokens.get("unk", vocab[0])
+    token_to_idx = {k: v for v, k in enumerate(vocab)}
+    idx_to_token = {v: k for k, v in token_to_idx.items()}
+
+    # I have no idea how this class works, I copied from somewhere else and forgot
+    class Tokenizer(PreTrainedTokenizer):
+        model_input_names = ["input_ids"]
+
+        def __init__(
+            self,
+            model_max_length: int | None = None,
+            split_special_tokens: bool = True,
+            **kwargs
+        ):
+            self.model_max_length = model_max_length
+            self._vocab = token_to_idx
+            self._inv_vocab = idx_to_token
+            tokens = dict(
+                unk_token=special_tokens.get("unk"),
+                pad_token=special_tokens.get("pad"),
+                bos_token=special_tokens.get("bos"),
+                eos_token=special_tokens.get("eos"),
+                sep_token=special_tokens.get("sep"),
+                cls_token=special_tokens.get("cls"),
+                mask_token=special_tokens.get("mask"),
+            )
+            tokens = {k: v for k, v in tokens.items() if v is not None}
+            super().__init__(
+                model_max_length=model_max_length,
+                split_special_tokens=split_special_tokens,
+                **tokens,
+                **kwargs,
+            )
+
+        def _tokenize(self, seq: str) -> list[str]:
+            return list(seq)
+
+        def _convert_token_to_id(self, token: str) -> int:
+            return self._vocab.get(token, self._vocab[unk_token])
+
+        def _convert_id_to_token(self, idx: int) -> str:
+            return self._inv_vocab[idx]
+
+        @property
+        def vocab_size(self) -> int:
+            return len(self._vocab)
+
+        def get_vocab(self) -> dict[str, int]:
+            return self._vocab
+
+        def save_vocabulary(self, save_directory: str, filename_prefix: str | None = None) -> tuple:
+            return ()
+
+    return Tokenizer
+
+
+def register_auto_classes(
+    config_class: type[PretrainedConfig],
+    model_class: type[PreTrainedModel] = None,
+    tokenizer_class: type[PreTrainedTokenizer] = None,
+    force_registration: bool = False,
+):
+    model_type = getattr(config_class, "model_type", None)
+    if model_type is None:
+        raise ValueError("`config_class` must have a `model_type` attribute")
+
+    # Check if already registered
+    already_registered = check_auto_class_registered(
+        *(c for c in [config_class, model_class, tokenizer_class] if c is not None)
+    )
+    if already_registered and not force_registration:
+        raise RuntimeError("One or more classes are already registered. Set `force_registration=True` to override.")
+
+    AutoConfig.register(model_type, config_class)
+    config_class.register_for_auto_class()
+
+    if model_class is not None:
+        if not hasattr(model_class, "config_class") or model_class.config_class is None:
+            model_class.config_class = config_class
+        
+        AutoModel.register(config_class, model_class)
+        model_class.register_for_auto_class("AutoModel")
+
+    if tokenizer_class is not None:
+        AutoTokenizer.register(config_class, tokenizer_class)
+        tokenizer_class.register_for_auto_class("AutoTokenizer")
+
+
+def check_auto_class_registered(*classes) -> bool:
+    # Simple check: just return False to always allow registration
+    # This avoids complex version-dependent internal API checks
+    return False
+
+
+def push_model_to_hub(
+    config_class: type[PretrainedConfig],
+    model_class: type[PreTrainedModel],
+    model_args: dict,
+    state_dict: dict,
+    id_: str,
+    commit_message: str = "Upload model",
+) -> str:
+    config = config_class(**model_args)
+    huggingface_model = model_class(config)
+    pytorch_model = getattr(huggingface_model, "_model")
+    pytorch_model.load_state_dict(state_dict)
+    config.save_pretrained(id_)
+    huggingface_model.save_pretrained(id_)
+    return huggingface_model.push_to_hub(id_, commit_message=commit_message)
+
+
+def push_tokenizer_to_hub(
+    tokenizer_class: type[PreTrainedTokenizer],
+    id_: str,
+    commit_message: str = "Upload tokenizer",
+    **kwargs,
+) -> str:
+    tokenizer = tokenizer_class(**kwargs)
+    tokenizer.save_pretrained(id_)
+    return tokenizer.push_to_hub(id_, commit_message=commit_message)

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bebf415bc71c24ea6e3c1d28695ec58ffe1742a58b371640c8b821a13ab1b396
+size 232