Add inference.py, README.md, config.json, training_args.json, model.safetensors, USE_POLICY.md

README.md

@@ -0,0 +1,91 @@
+---
+license: bsd-3-clause
+tags:
+- pytorch
+- cnn-transformer
+- generation
+---
+
+# Generation (Cnn Transformer)
+
+## Overview
+
+This repository is a compact, custom PyTorch implementation of **Cnn Transformer** for **Generation**. The **xlarge** configuration is intended for code review, smoke tests, and small controlled experiments rather than as a production-ready pretrained release.
+
+---
+
+## Citation
+
+If this repository is useful for your work, a link back is appreciated. No formal citation is required yet.
+
+---
+
+## Quick Check
+
+Run `python inference.py --help` for the built-in smoke test. Because this is a custom implementation, generic automatic loading APIs require an explicit adapter before use.
+
+---
+
+## Evaluation Guidance
+
+A first evaluation could use a task-specific held-out set. Report the metric across at least three seeds and include a matched-capacity baseline; keep logs and library versions with any published number.
+
+---
+
+## Limitations
+
+The initialization checkpoint has not been trained or audited for robustness, fairness, or domain transfer. The implementation should be treated as an experimental starting point. Results from a future trained checkpoint must be documented separately from the defaults shipped here.
+
+---
+
+## Repository Status
+
++ The Python file contains the model and runnable example or training entry point.
++ `config.json` records the generated architecture settings.
++ `training_args.json` records the default experiment recipe.
++ `model.safetensors` is a valid initialization checkpoint for smoke tests; it is **not** presented as a trained benchmark checkpoint.
++ No benchmark score is claimed in this repository.
+
+---
+
+## Changelog
+
++ 2026-10-04 — initial upload
++ 2026-10-19 — config and docs sync
+
+---
+
+## Training Details
+
++ **Framework**: PyTorch
++ **Precision**: fp32
++ **Init scheme**: xavier uniform
++ **Hardware**: a single consumer GPU is enough
++ **Typical run**: minutes, not hours
+
+---
+
+## Default Experiment Recipe
+
+The generated recipe uses rmsprop with a onecycle schedule.
+
+These values exist so the script runs end-to-end. A meaningful experiment needs its own tuning budget and at least three seeds.
+
+---
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `inference.py` | primary artifact |
+| `README.md` | this documentation |
+| `config.json` | architecture configuration |
+| `training_args.json` | default experiment settings |
+| `model.safetensors` | initialization checkpoint |
+| `USE_POLICY.md` | use and redistribution notes |
+
+---
+
+## License
+
+Distributed under the **bsd-3-clause** license. External datasets keep their own terms — check them separately.

USE_POLICY.md

@@ -0,0 +1,6 @@
+# Use policy
+
+This repository is shared for research and evaluation purposes only. Please do not present the bundled checkpoint as a trained result.
+
+- No benchmark claims are made here.
+- Derivative work should keep the original license notice.

config.json

@@ -0,0 +1,19 @@
+{
+  "architectures": [
+    "CustomResearchModel"
+  ],
+  "architecture": "cnn_transformer",
+  "model_type": "cnn_transformer",
+  "hidden_size": 128,
+  "num_hidden_layers": 4,
+  "num_attention_heads": 2,
+  "intermediate_size": 512,
+  "hidden_act": "relu",
+  "max_position_embeddings": 128,
+  "layer_norm_eps": 1e-12,
+  "checkpoint_status": "initialization-only",
+  "notes": "Untrained checkpoint for smoke tests; no benchmark claim.",
+  "use_cache": true,
+  "torch_dtype": "float32",
+  "vocab_size": 2048
+}

inference.py

@@ -0,0 +1,126 @@
+import torch
+import torch.nn as nn
+import math
+
+
+class CnnTransformerModel(nn.Module):
+    '''
+    cnn_transformer model with standard attention.
+    Scale: xlarge (dim=512, layers=10, heads=8)
+    Fusion: cross_attention, Task: generation
+    '''
+
+    def __init__(self, embed_dim=512, num_layers=10, num_heads=8, num_classes=10):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+
+        # image patch embedding
+        self.patch_proj = nn.Conv2d(3, embed_dim, kernel_size=16, stride=16)
+        self.cls_token = nn.Parameter(torch.randn(1, 1, embed_dim) * 0.02)
+        self.pos_embed = nn.Parameter(torch.randn(1, 197, embed_dim) * 0.02)
+        self.dropout = nn.Dropout(0.1)
+
+        # image transformer blocks
+        self.image_blocks = nn.ModuleList([
+            nn.TransformerEncoderLayer(
+                embed_dim, num_heads, embed_dim * 4, 0.1,
+                activation='gelu', batch_first=True, norm_first=True
+            )
+            for _ in range(num_layers)
+        ])
+        self.image_norm = nn.LayerNorm(embed_dim)
+
+        # text embedding
+        self.text_embed = nn.Embedding(30522, embed_dim, padding_idx=0)
+        self.text_pos = nn.Parameter(torch.randn(1, 128, embed_dim) * 0.02)
+        self.text_blocks = nn.ModuleList([
+            nn.TransformerEncoderLayer(
+                embed_dim, num_heads, embed_dim * 4, 0.1,
+                activation='gelu', batch_first=True, norm_first=True
+            )
+            for _ in range(num_layers)
+        ])
+        self.text_norm = nn.LayerNorm(embed_dim)
+
+        # fusion
+        self.fusion_blocks = nn.ModuleList([
+            nn.TransformerEncoderLayer(
+                embed_dim, num_heads, embed_dim * 4, 0.1,
+                activation='gelu', batch_first=True, norm_first=True
+            )
+            for _ in range(2)
+        ])
+        self.fusion_norm = nn.LayerNorm(embed_dim)
+
+        # task head
+        self.classifier = nn.Sequential(
+            nn.Linear(embed_dim, embed_dim),
+            nn.ReLU(),
+            nn.Dropout(0.1),
+            nn.Linear(embed_dim, num_classes),
+        )
+
+        self._initialize_weights()
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.Embedding):
+                nn.init.trunc_normal_(m.weight, std=0.02)
+                if m.padding_idx is not None:
+                    m.weight[m.padding_idx].zero_()
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.ones_(m.weight)
+                nn.init.zeros_(m.bias)
+
+    def encode_image(self, images):
+        x = self.patch_proj(images)
+        x = x.flatten(2).transpose(1, 2)
+        cls = self.cls_token.expand(x.size(0), -1, -1)
+        x = torch.cat([cls, x], dim=1)
+        x = x + self.pos_embed
+        x = self.dropout(x)
+        for block in self.image_blocks:
+            x = block(x)
+        return self.image_norm(x)
+
+    def encode_text(self, input_ids, attention_mask=None):
+        x = self.text_embed(input_ids)
+        x = x + self.text_pos[:, :input_ids.size(1)]
+        x = self.dropout(x)
+        padding = (attention_mask == 0) if attention_mask is not None else None
+        for block in self.text_blocks:
+            x = block(x, src_key_padding_mask=padding)
+        return self.text_norm(x)
+
+    def forward(self, images, input_ids, attention_mask=None, labels=None):
+        image_features = self.encode_image(images)
+        text_features = self.encode_text(input_ids, attention_mask)
+
+        fused = text_features
+        for block in self.fusion_blocks:
+            fused = block(fused)
+        fused = self.fusion_norm(fused[:, 0])
+        logits = self.classifier(fused)
+
+        loss = None
+        if labels is not None:
+            loss = nn.functional.cross_entropy(logits, labels)
+
+        return {'logits': logits, 'loss': loss}
+
+
+if __name__ == '__main__':
+    model = CnnTransformerModel()
+    total = sum(p.numel() for p in model.parameters())
+    print(f'CnnTransformerModel: {total:,} params ({total/1e6:.2f}M)')
+    img = torch.randn(2, 3, 224, 224)
+    ids = torch.randint(0, 30522, (2, 128))
+    mask = torch.ones(2, 128)
+    out = model(img, ids, mask, torch.tensor([0, 1]))
+    print(f'Output: {out["logits"].shape}, Loss: {out["loss"].item():.4f}')

model.safetensors

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

training_args.json

@@ -0,0 +1,9 @@
+{
+  "optimizer": "rmsprop",
+  "scheduler": "onecycle",
+  "learning_rate": 0.0002,
+  "batch_size": 16,
+  "epochs": 30,
+  "seed": 42,
+  "status": "default recipe; not a completed run"
+}