Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,14 @@
+checkpoints/
+*.pt
+*.pth
+__pycache__/
+*.pyc
+venv/
+.venv/
+*.log
+.DS_Store
+*.pt
+venv/
+data_*/
+__pycache__/
+latex/

.python-version

@@ -0,0 +1 @@
+3.11

LICENSE

@@ -0,0 +1,73 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+     (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+     (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+     (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+     (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+     You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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.

configs/ablation_12layers.yaml

@@ -0,0 +1,36 @@
+# Ablation: 12 layers (vs baseline 8)
+# Everything else same as v1 baseline
+model:
+  vocab_size: 250002
+  max_seq_len: 32
+  hidden_dim: 768
+  num_layers: 12
+  num_heads: 12
+  ff_dim: 3072
+  dropout: 0.1
+  embedding_cond_dim: 1024
+  mask_token_id: 250001
+
+training:
+  batch_size: 600
+  grad_accum: 4
+  max_steps: 20000
+  lr: 0.00046875
+  min_lr_ratio: 0.0
+  weight_decay: 0.01
+  warmup_steps: 2000
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 500
+  num_workers: 4
+  mixed_precision: true
+  ema_decay: 0.9999
+
+data:
+  data_dir: data
+  val_split: 0.01
+
+evaluation:
+  num_denoise_steps: 50
+  num_samples: 1000
+  jina_model: jinaai/jina-embeddings-v3

configs/ablation_dropout005.yaml

@@ -0,0 +1,36 @@
+# Ablation: dropout 0.05 (vs baseline 0.1)
+# Everything else same as v1 baseline
+model:
+  vocab_size: 250002
+  max_seq_len: 32
+  hidden_dim: 768
+  num_layers: 8
+  num_heads: 12
+  ff_dim: 3072
+  dropout: 0.05
+  embedding_cond_dim: 1024
+  mask_token_id: 250001
+
+training:
+  batch_size: 600
+  grad_accum: 4
+  max_steps: 20000
+  lr: 0.00046875
+  min_lr_ratio: 0.0
+  weight_decay: 0.01
+  warmup_steps: 2000
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 500
+  num_workers: 4
+  mixed_precision: true
+  ema_decay: 0.9999
+
+data:
+  data_dir: data
+  val_split: 0.01
+
+evaluation:
+  num_denoise_steps: 50
+  num_samples: 1000
+  jina_model: jinaai/jina-embeddings-v3

configs/ablation_minlr01.yaml

@@ -0,0 +1,36 @@
+# Ablation: min_lr_ratio=0.1 (vs baseline 0.0)
+# Cosine schedule floors at 10% of max lr instead of 0
+model:
+  vocab_size: 250002
+  max_seq_len: 32
+  hidden_dim: 768
+  num_layers: 8
+  num_heads: 12
+  ff_dim: 3072
+  dropout: 0.1
+  embedding_cond_dim: 1024
+  mask_token_id: 250001
+
+training:
+  batch_size: 600
+  grad_accum: 4
+  max_steps: 20000
+  lr: 0.00046875
+  min_lr_ratio: 0.1
+  weight_decay: 0.01
+  warmup_steps: 2000
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 500
+  num_workers: 4
+  mixed_precision: true
+  ema_decay: 0.9999
+
+data:
+  data_dir: data
+  val_split: 0.01
+
+evaluation:
+  num_denoise_steps: 50
+  num_samples: 1000
+  jina_model: jinaai/jina-embeddings-v3

configs/default.yaml

@@ -0,0 +1,33 @@
+# Conditional MDLM for Embedding Inversion
+model:
+  vocab_size: 250002
+  max_seq_len: 32
+  hidden_dim: 768
+  num_layers: 8
+  num_heads: 12
+  ff_dim: 3072
+  dropout: 0.1
+  embedding_cond_dim: 1024  # jina-embeddings-v3 output dim
+  mask_token_id: 250001
+
+training:
+  batch_size: 128
+  grad_accum: 4
+  max_steps: 50000
+  lr: 0.0001
+  weight_decay: 0.01
+  warmup_steps: 2000
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 500
+  num_workers: 2
+  mixed_precision: true
+
+data:
+  data_dir: data
+  val_split: 0.01
+
+evaluation:
+  num_denoise_steps: 50
+  num_samples: 1000
+  jina_model: jinaai/jina-embeddings-v3

configs/v2.yaml

@@ -0,0 +1,34 @@
+model:
+  vocab_size: 250002
+  max_seq_len: 128
+  hidden_dim: 768
+  num_layers: 12
+  num_heads: 12
+  ff_dim: 3072
+  dropout: 0.05
+  embedding_cond_dim: 1024
+  mask_token_id: 250001
+
+training:
+  batch_size: 200
+  grad_accum: 8
+  max_steps: 200000
+  lr: 0.0003125
+  min_lr_ratio: 0.1
+  weight_decay: 0.01
+  warmup_steps: 3000
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 500
+  num_workers: 4
+  mixed_precision: true
+  ema_decay: 0.9999
+
+data:
+  data_dir: data_v2
+  val_split: 0.01
+
+evaluation:
+  num_denoise_steps: 50
+  num_samples: 1000
+  jina_model: jinaai/jina-embeddings-v3

configs/v2_gemma.yaml

@@ -0,0 +1,31 @@
+model:
+  vocab_size: 262145
+  max_seq_len: 32
+  hidden_dim: 768
+  num_layers: 8
+  num_heads: 12
+  ff_dim: 3072
+  dropout: 0.0
+  embedding_cond_dim: 768
+  mask_token_id: 262144  # vocab_size - 1
+  encoder_model: unsloth/embeddinggemma-300m
+  decoder_tokenizer: unsloth/embeddinggemma-300m
+
+training:
+  batch_size: 400
+  grad_accum: 4
+  max_steps: 200000
+  lr: 0.0001
+  min_lr_ratio: 0.1
+  weight_decay: 0.01
+  warmup_steps: 2000
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 500
+  num_workers: 4
+  mixed_precision: true
+  ema_decay: 0.9999
+
+data:
+  data_dir: data_gemma
+  val_split: 0.01

configs/v2_jinav3.yaml

@@ -0,0 +1,31 @@
+model:
+  vocab_size: 250002
+  max_seq_len: 32
+  hidden_dim: 768
+  num_layers: 8
+  num_heads: 12
+  ff_dim: 3072
+  dropout: 0.0
+  embedding_cond_dim: 1024
+  mask_token_id: 250001
+  encoder_model: jinaai/jina-embeddings-v3
+  decoder_tokenizer: xlm-roberta-base
+
+training:
+  batch_size: 400
+  grad_accum: 4
+  max_steps: 200000
+  lr: 0.0001
+  min_lr_ratio: 0.1
+  weight_decay: 0.01
+  warmup_steps: 2000
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 500
+  num_workers: 4
+  mixed_precision: true
+  ema_decay: 0.9999
+
+data:
+  data_dir: data_jinav3
+  val_split: 0.01

configs/v2_qwen3.yaml

@@ -0,0 +1,32 @@
+model:
+  vocab_size: 151669
+  max_seq_len: 32
+  pretrained_token_embeddings: "Qwen/Qwen3-Embedding-0.6B"
+  hidden_dim: 1024
+  num_layers: 8
+  num_heads: 12
+  ff_dim: 3072
+  dropout: 0.0
+  embedding_cond_dim: 1024
+  mask_token_id: 151668  # vocab_size - 1
+  encoder_model: Qwen/Qwen3-Embedding-0.6B
+  decoder_tokenizer: Qwen/Qwen3-Embedding-0.6B
+
+training:
+  batch_size: 400
+  grad_accum: 4
+  max_steps: 200000
+  lr: 0.0001
+  min_lr_ratio: 0.1
+  weight_decay: 0.01
+  warmup_steps: 2000
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 500
+  num_workers: 4
+  mixed_precision: true
+  ema_decay: 0.9999
+
+data:
+  data_dir: /kaggle/embedding-inversion-demo/omega_books_500k_32.pt
+  val_split: 0.01

configs/v3_mmbert_jinav3.yaml

@@ -0,0 +1,37 @@
+# v3: mmBERT-base backbone with AdaLN-Zero conditioning + jina-v3 encoder
+# Full pretrained mmBERT (22 layers, 768d) with conditioning on jina-embeddings-v3
+model:
+  vocab_size: 256001          # mmBERT vocab (256000) + 1 mask token
+  max_seq_len: 32
+  hidden_dim: 768             # mmBERT hidden size
+  num_layers: 22              # mmBERT num layers (loaded from pretrained)
+  num_heads: 12               # mmBERT num attention heads
+  ff_dim: 1152                # mmBERT intermediate size (not used, loaded from pretrained)
+  dropout: 0.0
+  embedding_cond_dim: 1024    # jina-embeddings-v3 output dim
+  mask_token_id: 256000       # vocab_size - 1
+  encoder_model: jinaai/jina-embeddings-v3
+  decoder_tokenizer: jhu-clsp/mmBERT-base
+  pretrained_token_embeddings: jhu-clsp/mmBERT-base
+  freeze_token_embeddings: true
+  tie_weights: false            # output_proj independent from frozen token_embed
+
+training:
+  batch_size: 400
+  grad_accum: 4
+  max_steps: 200000
+  lr: 0.0001
+  min_lr_ratio: 0.1
+  weight_decay: 0.01
+  warmup_steps: 2000
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 500
+  num_workers: 4
+  mixed_precision: true
+  ema_decay: 0.9999
+  early_stop_patience: 5000
+
+data:
+  data_dir: data_mmbert_jinav3
+  val_split: 0.01

dataset.py

@@ -0,0 +1,120 @@
+"""
+Dataset for embedding inversion training.
+Reads pre-converted numpy .npy files for instant loading.
+"""
+
+import os
+import glob
+import bisect
+import json
+import numpy as np
+import torch
+from torch.utils.data import Dataset, DataLoader
+from transformers import AutoTokenizer
+
+class EmbeddingInversionDataset(Dataset):
+    """
+    Dataset đọc dữ liệu từ file .pt đã được preprocess.
+    """
+    def __init__(self, pt_file_path, tokenizer, max_seq_len=32, val=False, val_split=0.01):
+        self.tokenizer = tokenizer
+        self.max_seq_len = max_seq_len
+        
+        # Load dữ liệu từ file .pt
+        print(f"Loading data from {pt_file_path}...")
+        self.raw_data = torch.load(pt_file_path) # List[Dict]
+        
+        # Tạo mapping để truy cập chunk theo index phẳng (flat index)
+        # Vì mỗi cuốn sách có số lượng chunk khác nhau
+        self.flat_indices = []
+        for book_idx, book in enumerate(self.raw_data):
+            num_chunks = len(book["chunks_text"])
+            for chunk_idx in range(num_chunks):
+                self.flat_indices.append((book_idx, chunk_idx))
+        
+        self.total_rows = len(self.flat_indices)
+
+        # Chia Train/Val
+        val_count = int(self.total_rows * val_split)
+        if val:
+            self.start_idx = self.total_rows - val_count
+            self.length = val_count
+        else:
+            self.start_idx = 0
+            self.length = self.total_rows - val_count
+
+    def __len__(self):
+        return self.length
+
+    def __getitem__(self, idx):
+        global_idx = self.start_idx + idx
+        book_idx, chunk_in_book_idx = self.flat_indices[global_idx]
+        
+        # Lấy dữ liệu
+        book_data = self.raw_data[book_idx]
+        text = book_data["chunks_text"][chunk_in_book_idx]
+        embedding = book_data["embeddings"][chunk_in_book_idx] # Tensor đã có sẵn
+
+        # Tokenize lại text để lấy token_ids (vì file .pt chỉ lưu text)
+        encoding = self.tokenizer(
+            text,
+            max_length=self.max_seq_len,
+            padding="max_length",
+            truncation=True,
+            return_tensors="pt"
+        )
+        
+        token_ids = encoding["input_ids"].squeeze(0) # (max_seq_len)
+        
+        # Tạo padding mask
+        # Thông thường 0 hoặc 1 tùy model, Qwen thường dùng padding_mask từ tokenizer
+        padding_mask = (token_ids == self.tokenizer.pad_token_id)
+
+        return {
+            "token_ids": token_ids.long(),
+            "embedding": embedding.float(),
+            "padding_mask": padding_mask,
+        }
+
+# /kaggle/embedding-inversion-demo/dataset.py
+
+def create_dataloaders(config):
+    dc = config["data"]
+    tc = config["training"]
+    mc = config["model"]
+
+    # Sửa lỗi KeyError: Thử lấy 'encoder_model', nếu không có thì lấy 'encoder_model_name'
+    model_name = mc.get("encoder_model") or mc.get("encoder_model_name")
+    
+    if not model_name:
+        raise KeyError("Config file thiếu key 'encoder_model' hoặc 'encoder_model_name' trong phần 'model'")
+
+    print(f"Initializing tokenizer from: {model_name}")
+    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+    
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    pt_path = dc["data_dir"]
+
+    train_ds = EmbeddingInversionDataset(
+        pt_path, tokenizer, 
+        max_seq_len=mc["max_seq_len"],
+        val=False, val_split=dc["val_split"]
+    )
+    val_ds = EmbeddingInversionDataset(
+        pt_path, tokenizer, 
+        max_seq_len=mc["max_seq_len"],
+        val=True, val_split=dc["val_split"]
+    )
+
+    train_loader = DataLoader(
+        train_ds, batch_size=tc["batch_size"], shuffle=True,
+        num_workers=tc["num_workers"], pin_memory=True, drop_last=True
+    )
+    val_loader = DataLoader(
+        val_ds, batch_size=tc["batch_size"], shuffle=False,
+        num_workers=tc["num_workers"], pin_memory=True
+    )
+
+    return train_loader, val_loader

demo/index.html

@@ -0,0 +1,464 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<link rel="icon" type="image/png" href="/favicon-32.png">
+<meta property="og:type" content="website">
+<meta property="og:title" content="Embedding Inversion via Conditional Masked Diffusion">
+<meta property="og:description" content="Reconstruct original text from embedding vectors using conditional masked diffusion. Live interactive demo.">
+<meta property="og:image" content="https://embedding-inversion-demo.jina.ai/og-image.png">
+<meta property="og:url" content="https://embedding-inversion-demo.jina.ai">
+<meta name="twitter:card" content="summary_large_image">
+<meta name="twitter:title" content="Embedding Inversion via Conditional Masked Diffusion">
+<meta name="twitter:description" content="Reconstruct original text from embedding vectors using conditional masked diffusion. Live interactive demo.">
+<meta name="twitter:image" content="https://embedding-inversion-demo.jina.ai/og-image.png">
+<meta name="twitter:creator" content="@hxiao">
+<title>Embedding Inversion via Conditional Masked Diffusion</title>
+<style>
+*,*::before,*::after{margin:0;padding:0;box-sizing:border-box}
+:root{
+  --bg:#fafafa;--surface:#fff;--border:#d8d8d8;
+  --text:#1a1a2e;--dim:#666;--accent:#e17055;
+  --green:#00b894;--mask:#c0c0c0;
+  --mono:"Berkeley Mono","JetBrains Mono","Fira Code",monospace;
+  --radius:4px;
+}
+html{font-size:15px}
+body{font-family:var(--mono);background:var(--bg);color:var(--text);min-height:100vh;line-height:1.5}
+::selection{background:var(--accent);color:#fff}
+
+.wrap{max-width:760px;margin:0 auto;padding:2.5rem 1.5rem 3rem}
+
+header{text-align:center;margin-bottom:2.5rem}
+h1{font-size:1.6rem;font-weight:600;letter-spacing:-0.01em;color:var(--text)}
+.sub{color:var(--dim);font-size:.8rem;margin-top:.4rem}
+.sub a{color:var(--dim);text-decoration:underline;transition:color .2s}
+.sub a:hover{color:var(--accent)}
+
+/* Fieldsets - TurboPuffer style */
+fieldset{
+  background:var(--surface);
+  border:2px dashed var(--border);
+  border-radius:var(--radius);
+  padding:1.5rem;
+  margin-bottom:1.5rem;
+}
+legend{
+  font-size:.65rem;
+  text-transform:uppercase;
+  letter-spacing:.12em;
+  color:var(--dim);
+  font-weight:600;
+  padding:0 .5rem;
+}
+
+/* Model selector - tabs style */
+.model-selector{
+  display:inline-flex;gap:0;margin-bottom:1.2rem;
+  border:1.5px solid var(--border);border-radius:var(--radius);
+  overflow:hidden;
+}
+.model-btn{
+  padding:.5rem 1.2rem;
+  background:transparent;color:var(--text);
+  border:none;border-right:1.5px solid var(--border);
+  font-family:var(--mono);font-size:.75rem;font-weight:600;
+  cursor:pointer;transition:all .2s;text-align:center;
+  letter-spacing:.02em;
+}
+.model-btn:last-child{border-right:none}
+.model-btn:hover{background:#f5f5f5}
+.model-btn.active{
+  background:var(--accent);color:#fff;
+}
+
+/* input area */
+.input-row{position:relative;display:flex;align-items:center}
+.input-row input{
+  width:100%;padding:.65rem 2.5rem .65rem .8rem;
+  border:1.5px solid var(--border);border-radius:var(--radius);
+  font-family:var(--mono);font-size:.85rem;
+  background:var(--surface);color:var(--text);outline:none;
+  transition:border-color .2s;
+}
+.input-row input:focus{border-color:var(--accent)}
+.input-row input::placeholder{color:#aaa;font-style:italic}
+.dice{
+  position:absolute;right:8px;top:50%;transform:translateY(-50%);
+  background:none;border:none;cursor:pointer;font-size:1.1rem;
+  opacity:.4;transition:opacity .15s;
+}
+.dice:hover{opacity:.8}
+
+/* buttons - outlined style */
+.btn{
+  display:inline-block;padding:.55rem 1.4rem;
+  background:transparent;color:var(--accent);
+  border:1.5px solid var(--accent);border-radius:var(--radius);
+  font-family:var(--mono);font-size:.8rem;font-weight:600;
+  cursor:pointer;transition:all .15s;margin-top:.8rem;
+  letter-spacing:.02em;
+}
+.btn:hover{background:var(--accent);color:#fff}
+.btn:disabled{opacity:.3;cursor:not-allowed}
+.btn.btn-primary{
+  background:var(--accent);color:#fff;
+}
+.btn.btn-primary:hover{background:#c0543d}
+
+/* embedding viz */
+#embed-result{display:none}
+.stats-row{
+  display:flex;gap:1.5rem;font-size:.75rem;
+  color:var(--dim);margin-bottom:.8rem;flex-wrap:wrap;
+}
+.stats-row span{white-space:nowrap}
+.stats-row .val{color:var(--text);font-weight:600;margin-left:.3rem}
+
+canvas#histogram{width:100%;height:110px;border-radius:var(--radius);background:var(--surface);border:1.5px solid var(--border)}
+
+/* invert section */
+#invert-section{display:none}
+#invert-result{display:none}
+
+/* token grid */
+.token-grid{
+  display:flex;flex-wrap:wrap;gap:5px;
+  font-size:.8rem;
+  margin-top:.8rem;
+}
+.token{
+  padding:3px 7px;border-radius:3px;
+  transition:all .25s ease;
+  border:1px solid transparent;
+}
+.token.masked{background:#f0f0f0;color:var(--mask);border-color:var(--border)}
+.token.revealed{background:var(--surface);color:var(--text);font-weight:600;border-color:var(--border)}
+.token.just-changed{
+  background:#fde8e2;color:var(--accent);font-weight:700;
+  border-color:var(--accent);
+  animation:pop .3s ease;
+}
+@keyframes pop{0%{transform:scale(1.12)}100%{transform:scale(1)}}
+
+/* comparison */
+.compare{margin-top:1.2rem;font-size:.8rem}
+.compare-row{display:flex;gap:.6rem;margin-bottom:.5rem;align-items:baseline}
+.compare-label{font-size:.65rem;text-transform:uppercase;letter-spacing:.1em;color:var(--dim);width:85px;flex-shrink:0;font-weight:600}
+.compare-text{color:var(--text)}
+
+.metric{
+  display:inline-flex;align-items:center;gap:.4rem;
+  font-size:.75rem;color:var(--dim);
+  margin-top:.6rem;
+}
+.metric .val{color:var(--green);font-weight:700;font-size:.9rem}
+
+.step-info{font-size:.7rem;color:var(--dim);margin-top:.6rem}
+
+/* progress */
+.progress-bar{height:2px;background:#e5e5e5;border-radius:1px;margin-top:.6rem;overflow:hidden}
+.progress-fill{height:100%;background:var(--accent);border-radius:1px;transition:width .15s;width:0%}
+
+footer{text-align:center;margin-top:2.5rem;font-size:.7rem;color:var(--dim);border-top:1px solid var(--border);padding-top:1.5rem}
+footer a{color:var(--dim);text-decoration:underline}
+footer a:hover{color:var(--accent)}
+</style>
+</head>
+<body>
+<div class="wrap">
+
+<header>
+  <h1>Embedding Inversion via Conditional Masked Diffusion <a href="https://github.com/jina-ai/embedding-inversion-demo" target="_blank" title="GitHub" style="color:var(--dim);transition:color .2s;text-decoration:none;vertical-align:middle;margin-left:.2rem" onmouseover="this.style.color='var(--accent)'" onmouseout="this.style.color='var(--dim)'"><svg width="18" height="18" viewBox="0 0 16 16" fill="currentColor" style="vertical-align:middle;position:relative;top:-2px"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"/></svg></a><a href="https://github.com/jina-ai/embedding-inversion-demo/blob/main/technical-report.pdf" target="_blank" title="Paper" style="color:var(--dim);transition:color .2s;text-decoration:none;vertical-align:middle;margin-left:.3rem" onmouseover="this.style.color='var(--accent)'" onmouseout="this.style.color='var(--dim)'"><svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" style="vertical-align:middle;position:relative;top:-2px"><path d="M14 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V8l-6-6zm4 18H6V4h7v5h5v11zM9 13h6v2H9v-2zm0 4h6v2H9v-2zm0-8h3v2H9V9z"/></svg></a></h1>
+</header>
+
+<!-- Step 1: Input & Embed -->
+<fieldset>
+  <legend>Input</legend>
+  
+  <!-- Model selector -->
+  <div class="model-selector">
+    <button class="model-btn active" onclick="selectModel('qwen3')">Qwen3-Embedding</button>
+    <button class="model-btn" onclick="selectModel('gemma')">EmbeddingGemma</button>
+  </div>
+  
+  <div class="input-row">
+    <input type="text" id="input-text" placeholder="Enter a sentence..." maxlength="1000" />
+    <button class="dice" onclick="randomSentence()" title="Random sentence">&#x1F3B2;</button>
+  </div>
+  <button class="btn btn-primary" id="btn-embed" onclick="doEmbed()">Embed</button>
+</fieldset>
+
+<!-- Embedding Result -->
+<fieldset id="embed-result">
+  <legend>Embedding</legend>
+  <div class="stats-row">
+    <span>dim <span class="val" id="stat-dim">-</span></span>
+    <span>min <span class="val" id="stat-min">-</span></span>
+    <span>max <span class="val" id="stat-max">-</span></span>
+    <span>norm <span class="val" id="stat-norm">-</span></span>
+    <span>entropy <span class="val" id="stat-entropy">-</span></span>
+  </div>
+  <canvas id="histogram"></canvas>
+</fieldset>
+
+<!-- Step 2: Invert -->
+<div id="invert-section">
+  <fieldset>
+    <legend>Diffusion Decoding</legend>
+    <button class="btn" id="btn-invert" onclick="doInvert()">Invert</button>
+    <div class="progress-bar" id="progress-bar"><div class="progress-fill" id="progress-fill"></div></div>
+    <div class="step-info" id="step-info"></div>
+
+    <div id="invert-result">
+      <div class="token-grid" id="token-grid"></div>
+
+      <div class="compare">
+        <div class="compare-row">
+          <span class="compare-label">Original</span>
+          <span class="compare-text" id="original-text"></span>
+        </div>
+        <div class="compare-row">
+          <span class="compare-label">Recovered</span>
+          <span class="compare-text" id="recovered-text"></span>
+        </div>
+      </div>
+
+      <div class="metric">
+        cosine similarity <span class="val" id="cosine-sim">-</span>
+      </div>
+    </div>
+  </fieldset>
+</div>
+
+
+
+</div>
+
+<script>
+let currentEmbedding = null;
+let currentText = '';
+let selectedModel = 'qwen3';
+let diceClicks = 0;
+
+const MODEL_NAMES = {
+  'qwen3': 'Qwen3-Embedding',
+  'gemma': 'EmbeddingGemma'
+};
+
+function selectModel(model) {
+  selectedModel = model;
+  
+  // Update button states
+  document.querySelectorAll('.model-btn').forEach(btn => {
+    btn.classList.remove('active');
+  });
+  event.target.classList.add('active');
+  
+  // Update subtitle
+  document.getElementById('header-sub').textContent = MODEL_NAMES[model] + ' | Conditional Masked Diffusion';
+  
+  // Reset state if user switches models
+  currentEmbedding = null;
+  document.getElementById('embed-result').style.display = 'none';
+  document.getElementById('invert-section').style.display = 'none';
+}
+
+async function randomSentence() {
+  diceClicks++;
+  const hard = diceClicks > 1 ? '&hard=true' : '';
+  const r = await fetch('/random?model=' + selectedModel + hard);
+  const d = await r.json();
+  document.getElementById('input-text').value = d.text;
+}
+
+async function doEmbed() {
+  const text = document.getElementById('input-text').value.trim();
+  if (!text) return;
+  currentText = text;
+
+  const btn = document.getElementById('btn-embed');
+  btn.disabled = true;
+  btn.textContent = 'Encoding...';
+
+  try {
+    const r = await fetch('/encode', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({text, model: selectedModel})
+    });
+    const d = await r.json();
+    currentEmbedding = d.embedding;
+
+    // Stats
+    const arr = d.embedding;
+    const min = Math.min(...arr);
+    const max = Math.max(...arr);
+    const norm = Math.sqrt(arr.reduce((s,v) => s + v*v, 0));
+    document.getElementById('stat-dim').textContent = arr.length;
+    document.getElementById('stat-min').textContent = min.toFixed(3);
+    document.getElementById('stat-max').textContent = max.toFixed(3);
+    document.getElementById('stat-norm').textContent = norm.toFixed(2);
+    // Shannon entropy of embedding distribution
+    const nbins = 50;
+    const emin = Math.min(...arr); const emax = Math.max(...arr);
+    const bw = (emax - emin) / nbins || 1;
+    const bins = new Array(nbins).fill(0);
+    arr.forEach(v => { const b = Math.min(nbins-1, Math.floor((v - emin) / bw)); bins[b]++; });
+    const n = arr.length;
+    const entropy = -bins.filter(b=>b>0).reduce((s,b) => s + (b/n)*Math.log2(b/n), 0);
+    document.getElementById('stat-entropy').textContent = entropy.toFixed(2);
+
+    document.getElementById('embed-result').style.display = 'block';
+
+    // Histogram (draw after element is visible so getBoundingClientRect works)
+    requestAnimationFrame(() => drawHistogram(arr));
+    document.getElementById('invert-section').style.display = 'block';
+
+    // Reset invert state
+    document.getElementById('invert-result').style.display = 'none';
+    document.getElementById('progress-fill').style.width = '0%';
+    document.getElementById('step-info').textContent = '';
+    document.getElementById('btn-invert').disabled = false;
+  } catch(e) {
+    console.error(e);
+  } finally {
+    btn.disabled = false;
+    btn.textContent = 'Embed';
+  }
+}
+
+function drawHistogram(arr) {
+  const canvas = document.getElementById('histogram');
+  const dpr = window.devicePixelRatio || 1;
+  const rect = canvas.getBoundingClientRect();
+  canvas.width = rect.width * dpr;
+  canvas.height = rect.height * dpr;
+  const ctx = canvas.getContext('2d');
+  ctx.scale(dpr, dpr);
+  const W = rect.width, H = rect.height;
+
+  ctx.clearRect(0, 0, W, H);
+
+  const nBins = 50;
+  const min = Math.min(...arr), max = Math.max(...arr);
+  const range = max - min || 1;
+  const bins = new Array(nBins).fill(0);
+  for (const v of arr) {
+    const i = Math.min(Math.floor((v - min) / range * nBins), nBins - 1);
+    bins[i]++;
+  }
+  const maxBin = Math.max(...bins);
+
+  const pad = {l:0, r:0, t:8, b:0};
+  const pw = (W - pad.l - pad.r) / nBins;
+
+  for (let i = 0; i < nBins; i++) {
+    const h = (bins[i] / maxBin) * (H - pad.t - pad.b);
+    const x = pad.l + i * pw;
+    const y = H - pad.b - h;
+
+    const t = i / nBins;
+    const r2 = Math.round(225 + t * 20);
+    const g = Math.round(100 + t * 30);
+    const b = Math.round(65 + t * 20);
+    ctx.fillStyle = `rgb(${r2},${g},${b})`;
+    ctx.fillRect(x, y, pw - 1, h);
+  }
+}
+
+async function doInvert() {
+  if (!currentEmbedding) return;
+
+  const btn = document.getElementById('btn-invert');
+  btn.disabled = true;
+  btn.textContent = 'Inverting...';
+  document.getElementById('invert-result').style.display = 'block';
+  document.getElementById('original-text').textContent = currentText;
+  document.getElementById('cosine-sim').textContent = '-';
+
+  const grid = document.getElementById('token-grid');
+  grid.innerHTML = '';
+
+  let prevTokens = [];
+
+  try {
+    const r = await fetch('/decode', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({embedding: currentEmbedding, steps: 32, model: selectedModel})
+    });
+
+    const reader = r.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let totalSteps = 32;
+    let stepCount = 0;
+
+    while (true) {
+      const {done, value} = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, {stream: true});
+
+      const lines = buffer.split('\n');
+      buffer = lines.pop();
+
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const raw = line.slice(6).trim();
+        if (raw === '[DONE]') continue;
+
+        try {
+          const d = JSON.parse(raw);
+          stepCount++;
+
+          if (d.total) totalSteps = d.total;
+          if (d.total_steps) totalSteps = d.total_steps;
+          const pct = d.progress ? d.progress * 100 : Math.min(100, (stepCount / totalSteps) * 100);
+          document.getElementById('progress-fill').style.width = pct + '%';
+          document.getElementById('step-info').textContent = `step ${d.step !== undefined ? d.step + 1 : stepCount}/${totalSteps}`;
+
+          const tokens = d.tokens || [];
+          grid.innerHTML = '';
+          for (let i = 0; i < tokens.length; i++) {
+            const span = document.createElement('span');
+            // tokens can be objects {t: text, s: state} or strings
+            const tok = typeof tokens[i] === 'object' ? tokens[i] : {t: tokens[i], s: 'u'};
+            const text = tok.t || '';
+            const isMask = text === '[MASK]' || text === '<mask>' || tok.s === 'm';
+            const changed = tok.s === 'c' || (prevTokens[i] && prevTokens[i] !== text && !isMask);
+
+            span.className = 'token ' + (isMask ? 'masked' : (changed ? 'just-changed' : 'revealed'));
+            span.textContent = isMask ? '\u2588' : text;
+            grid.appendChild(span);
+          }
+          prevTokens = tokens.map(t => typeof t === 'object' ? t.t : t);
+
+          if (d.cosine_similarity !== undefined) {
+            document.getElementById('cosine-sim').textContent = d.cosine_similarity.toFixed(4);
+          } else if (d.cosine_sim !== undefined) {
+            document.getElementById('cosine-sim').textContent = d.cosine_sim.toFixed(4);
+          }
+          if (d.text) {
+            document.getElementById('recovered-text').textContent = d.text;
+          }
+        } catch(e) {}
+      }
+    }
+
+    document.getElementById('progress-fill').style.width = '100%';
+    document.getElementById('step-info').textContent = `done (${totalSteps} steps)`;
+  } catch(e) {
+    console.error(e);
+  } finally {
+    btn.disabled = false;
+    btn.textContent = 'Invert';
+  }
+}
+
+// Auto-load random on page load
+window.addEventListener('load', randomSentence);
+</script>
+</body>
+</html>

demo_server.py

@@ -0,0 +1,602 @@
+#!/usr/bin/env python3
+"""
+Interactive Embedding Inversion Demo Server - Multi-Model Support.
+Runs on port 8080. Serves a TurboPuffer-style dark UI for real-time diffusion visualization.
+
+Supports both Qwen3-Embedding and EmbeddingGemma models.
+"""
+
+import sys
+import os
+import pickle
+import yaml
+import json
+import math
+import random
+import asyncio
+import time
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoModel, AutoTokenizer
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.responses import JSONResponse
+from fastapi.responses import HTMLResponse, StreamingResponse, FileResponse
+from pydantic import BaseModel
+from typing import List, Optional
+
+# ---------------------------------------------------------------------------
+# Model architecture (matches checkpoint state_dict exactly)
+# ---------------------------------------------------------------------------
+
+class AdaLN(nn.Module):
+    """Adaptive LayerNorm: norm(x) * (1+scale) + shift, conditioned on cond."""
+    def __init__(self, hidden_dim, cond_dim):
+        super().__init__()
+        self.norm = nn.LayerNorm(hidden_dim, elementwise_affine=False)
+        self.proj = nn.Linear(cond_dim, 2 * hidden_dim)
+
+    def forward(self, x, cond):
+        # cond: [B, cond_dim] -> [B, 2*hidden]
+        params = self.proj(cond).unsqueeze(1)  # [B, 1, 2*hidden]
+        scale, shift = params.chunk(2, dim=-1)
+        return self.norm(x) * (1 + scale) + shift
+
+
+class Block(nn.Module):
+    """Transformer block with AdaLN conditioning."""
+    def __init__(self, hidden_dim, num_heads, ff_dim, dropout=0.0):
+        super().__init__()
+        self.adaln1 = AdaLN(hidden_dim, hidden_dim)
+        self.attn = nn.MultiheadAttention(hidden_dim, num_heads, dropout=dropout, batch_first=True)
+        self.adaln2 = AdaLN(hidden_dim, hidden_dim)
+        self.ff = nn.Sequential(
+            nn.Linear(hidden_dim, ff_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(ff_dim, hidden_dim),
+        )
+
+    def forward(self, x, cond):
+        # Self-attention with AdaLN
+        normed = self.adaln1(x, cond)
+        attn_out, _ = self.attn(normed, normed, normed, need_weights=False)
+        x = x + attn_out
+        # Feed-forward with AdaLN
+        normed = self.adaln2(x, cond)
+        x = x + self.ff(normed)
+        return x
+
+
+class ConditionalMDLM(nn.Module):
+    """Conditional Masked Diffusion Language Model - matches checkpoint exactly."""
+    def __init__(self, config):
+        super().__init__()
+        mc = config["model"]
+        self.vocab_size = mc["vocab_size"]
+        self.hidden_dim = mc["hidden_dim"]
+        self.max_seq_len = mc["max_seq_len"]
+        self.mask_token_id = mc["mask_token_id"]
+
+        self.token_embed = nn.Embedding(self.vocab_size, self.hidden_dim)
+        self.pos_embed = nn.Embedding(self.max_seq_len, self.hidden_dim)
+        self.cond_proj = nn.Sequential(
+            nn.Linear(mc["embedding_cond_dim"], self.hidden_dim),
+            nn.GELU(),
+            nn.Linear(self.hidden_dim, self.hidden_dim),
+        )
+        self.blocks = nn.ModuleList([
+            Block(self.hidden_dim, mc["num_heads"], mc["ff_dim"], mc.get("dropout", 0.0))
+            for _ in range(mc["num_layers"])
+        ])
+        self.final_norm = AdaLN(self.hidden_dim, self.hidden_dim)
+        self.output_proj = nn.Linear(self.hidden_dim, self.vocab_size, bias=False)
+
+    def forward(self, input_ids, cond_embedding, padding_mask=None):
+        B, L = input_ids.shape
+        positions = torch.arange(L, device=input_ids.device).unsqueeze(0)
+        x = self.token_embed(input_ids) + self.pos_embed(positions)
+        cond = self.cond_proj(cond_embedding)
+        for block in self.blocks:
+            x = block(x, cond)
+        x = self.final_norm(x, cond)
+        return self.output_proj(x)
+
+
+# ---------------------------------------------------------------------------
+# Encoder helper
+# ---------------------------------------------------------------------------
+
+def last_token_pool(hidden, attention_mask):
+    """Pool using last non-padding token (Qwen3-Embedding style)."""
+    left_padding = attention_mask[:, -1].sum() == attention_mask.shape[0]
+    if left_padding:
+        return hidden[:, -1]
+    seq_lens = attention_mask.sum(dim=1) - 1
+    return hidden[torch.arange(hidden.shape[0], device=hidden.device), seq_lens]
+
+
+def mean_pool(hidden, attention_mask):
+    m = attention_mask.unsqueeze(-1).expand(hidden.size()).float()
+    return (hidden * m).sum(1) / m.sum(1).clamp(min=1e-9)
+
+def get_pool_fn(model_name):
+    if "qwen" in model_name.lower():
+        return last_token_pool
+    return mean_pool
+
+# ---------------------------------------------------------------------------
+# Globals - Multi-model support + Concurrency Control
+# ---------------------------------------------------------------------------
+
+app = FastAPI()
+
+# CORS: only allow our domain
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://embedding-inversion-demo.jina.ai"],
+    allow_methods=["GET", "POST"],
+    allow_headers=["Content-Type"],
+)
+
+ALLOWED_ORIGINS = {
+    "https://embedding-inversion-demo.jina.ai",
+    "http://localhost:8080",
+    "http://127.0.0.1:8080",
+}
+
+@app.middleware("http")
+async def check_browser_request(request: Request, call_next):
+    # Skip health/queue checks
+    if request.url.path in ("/health", "/queue", "/", "/favicon.ico"):
+        return await call_next(request)
+    
+    # Check origin or referer
+    origin = request.headers.get("origin", "")
+    referer = request.headers.get("referer", "")
+    
+    origin_ok = any(origin.startswith(o) for o in ALLOWED_ORIGINS) if origin else False
+    referer_ok = any(referer.startswith(o) for o in ALLOWED_ORIGINS) if referer else False
+    
+    # Also allow requests with no origin/referer (same-origin page load)
+    is_page_load = not origin and not referer and request.method == "GET"
+    
+    if not origin_ok and not referer_ok and not is_page_load:
+        return JSONResponse(
+            status_code=403,
+            content={"error": "API access not allowed. Use the web interface."}
+        )
+    
+    return await call_next(request)
+
+# Each model has its own: MODEL, CONFIG, ENCODER_MODEL, ENCODER_TOK, DECODER_TOK
+MODELS = {}  # model_key -> dict with model, config, encoder_model, encoder_tok, decoder_tok
+DEVICE = None
+
+# Concurrency control
+ENCODE_SEM = asyncio.Semaphore(8)   # encode is fast, allow 4 concurrent
+DECODE_SEM = asyncio.Semaphore(6)   # decode has 32 steps, allow 3 concurrent
+ACTIVE_COUNT = 0
+WAITING_COUNT = 0
+count_lock = asyncio.Lock()
+
+# Model configurations
+MODEL_CONFIGS = {
+    "qwen3": {
+        "checkpoint_path": str(Path.home() / "checkpoints" / "qwen3_best.pt"),
+        "config_path": "configs/v2_qwen3.yaml",
+    },
+    "gemma": {
+        "checkpoint_path": str(Path.home() / "checkpoints" / "gemma_best.pt"),
+        "config_path": "configs/v2_gemma.yaml",
+    },
+}
+
+SAMPLE_SENTENCES_QWEN3_EASY = [
+    "The coldest winter I ever spent was a summer in San Francisco, said Mark Twain",
+    "Napoleon marched his Grand Army from Paris to Moscow in the winter of 1812",
+    "The Great Wall of China stretches over 13,000 miles from Dandong to Lop Lake",
+    "Albert Einstein developed the theory of relativity while working in Bern, Switzerland",
+    "The Titanic sank in the North Atlantic Ocean after hitting an iceberg in April 1912",
+    "Neil Armstrong landed on the Moon at the Sea of Tranquility on July 20, 1969",
+    "The Berlin Wall fell on November 9, 1989, reuniting East and West Germany",
+    "Amazon was founded by Jeff Bezos in his garage in Bellevue, Washington in 1994",
+    "The Eiffel Tower in Paris was built by Gustave Eiffel for the 1889 World Fair",
+    "Marco Polo traveled from Venice to China along the Silk Road in the 13th century",
+    "The Panama Canal connects the Atlantic Ocean to the Pacific Ocean across Panama",
+    "Steve Jobs unveiled the first iPhone at Moscone Center in San Francisco in 2007",
+    "Mount Everest stands at 8,849 meters on the border between Nepal and Tibet",
+    "The Treaty of Versailles was signed near Paris, France on June 28, 1919",
+    "SpaceX launched its first Falcon 9 rocket from Cape Canaveral, Florida in 2010",
+]
+
+SAMPLE_SENTENCES_QWEN3_HARD = [
+    "is this a pigeon? no it is a transformer model",
+    "i asked chatgpt to write my resignation letter and it was too polite",
+    "my embeddings are not aligned and neither is my sleep schedule",
+    "sir this is a vector database not a therapy session",
+    "instructions unclear, model started generating poetry",
+    "me: i will go to bed early. also me at 3am: reading arxiv papers",
+    "nobody: absolutely nobody: AI twitter: we need to talk about scaling laws",
+    "OpenAI announces GPT-5 while researchers debate if benchmarks even matter",
+    "NVIDIA stock hits new high as demand for H100 GPUs continues to outpace supply",
+    "Google DeepMind achieves breakthrough in protein structure prediction",
+    "the mitochondria is the powerhouse of the cell and I still remember that",
+    "according to all known laws of aviation a bee should not be able to fly",
+    "you miss 100 percent of the shots you do not take says Wayne Gretzky",
+    "404 meaning of life not found try again after coffee",
+    "rm -rf is not a valid debugging strategy no matter what stackoverflow says",
+]
+
+SAMPLE_SENTENCES_GEMMA_EASY = [
+    "The coldest winter I ever spent was a summer in San Francisco, said Mark Twain",
+    "Napoleon marched his Grand Army from Paris to Moscow in the winter of 1812",
+    "The Great Wall of China stretches over 13,000 miles from Dandong to Lop Lake",
+    "Albert Einstein developed the theory of relativity while working in Bern, Switzerland",
+    "The Titanic sank in the North Atlantic Ocean after hitting an iceberg in April 1912",
+    "Neil Armstrong landed on the Moon at the Sea of Tranquility on July 20, 1969",
+    "Amazon was founded by Jeff Bezos in his garage in Bellevue, Washington in 1994",
+    "The Eiffel Tower in Paris was built by Gustave Eiffel for the 1889 World Fair",
+    "Marco Polo traveled from Venice to China along the Silk Road in the 13th century",
+    "Mount Everest stands at 8,849 meters on the border between Nepal and Tibet",
+]
+
+SAMPLE_SENTENCES_GEMMA_HARD = [
+    "Die Kunst des Maschinenlernens liegt in den Daten",
+    "L intelligence artificielle transforme notre quotidien",
+    "El aprendizaje profundo revoluciona la medicina moderna",
+    "La ricerca scientifica apre nuove frontiere ogni giorno",
+    "Yapay zeka gunluk hayatimizi derinden etkiliyor",
+    "A inteligencia artificial esta revolucionando a pesquisa",
+    "Le traitement du langage naturel permet aux machines de comprendre",
+    "Los modelos de lenguaje grandes generan texto sorprendentemente coherente",
+    "chatgpt wrote my thesis and my professor did not notice anything wrong",
+    "the cake is a lie but the embeddings are real",
+    "the voyager 1 spacecraft is still sending data from interstellar space",
+    "Ich bin ein Berliner said JFK but the model thinks he said donut",
+    "selon toutes les lois connues de l aviation une abeille ne devrait pas voler",
+]
+
+SAMPLE_SENTENCES = SAMPLE_SENTENCES_QWEN3_EASY
+
+
+def load_model(model_key):
+    """Load a specific model (qwen3 or gemma)."""
+    global DEVICE
+    
+    if DEVICE is None:
+        DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Device: {DEVICE}")
+
+    cfg = MODEL_CONFIGS[model_key]
+    print(f"\n{'='*60}")
+    print(f"Loading {model_key.upper()} model")
+    print(f"{'='*60}")
+
+    # Load checkpoint
+    ckpt_path = cfg["checkpoint_path"]
+    print(f"Loading checkpoint {ckpt_path} ...")
+    with open(ckpt_path, "rb") as f:
+        ckpt = torch.load(f, map_location=DEVICE, pickle_module=pickle)
+    config = ckpt["config"]
+    print(f"  step={ckpt['step']}, val_loss={ckpt['best_val_loss']:.4f}")
+    print(f"  config: vocab={config['model']['vocab_size']}, "
+          f"seq_len={config['model']['max_seq_len']}, "
+          f"layers={config['model']['num_layers']}, "
+          f"embedding_cond_dim={config['model']['embedding_cond_dim']}")
+
+    # Create model
+    model = ConditionalMDLM(config).to(DEVICE)
+    state = {k: v.float() for k, v in ckpt["ema_state_dict"].items()}
+    model.load_state_dict(state, strict=True)
+    model.eval()
+    print("  Model loaded OK")
+    del ckpt
+
+    # Encoder
+    enc_name = config["model"]["encoder_model"]
+    print(f"Loading encoder: {enc_name} ...")
+    encoder_tok = AutoTokenizer.from_pretrained(enc_name, trust_remote_code=True)
+    encoder_model = AutoModel.from_pretrained(enc_name, trust_remote_code=True).to(DEVICE).eval()
+    print("  Encoder loaded OK")
+
+    # Decoder tokenizer
+    dec_name = config["model"]["decoder_tokenizer"]
+    print(f"Loading decoder tokenizer: {dec_name} ...")
+    decoder_tok = AutoTokenizer.from_pretrained(dec_name, trust_remote_code=True)
+    print("  Decoder tokenizer loaded OK")
+
+    MODELS[model_key] = {
+        "model": model,
+        "config": config,
+        "encoder_model": encoder_model,
+        "encoder_tok": encoder_tok,
+        "decoder_tok": decoder_tok,
+    }
+    print(f"{model_key.upper()} ready")
+
+
+def load_models():
+    """Load all models on startup."""
+    for model_key in MODEL_CONFIGS:
+        load_model(model_key)
+    print("\n" + "="*60)
+    print("=== Ready ===")
+    print("="*60 + "\n")
+
+
+# ---------------------------------------------------------------------------
+# Concurrency helpers
+# ---------------------------------------------------------------------------
+
+async def increment_active():
+    global ACTIVE_COUNT
+    async with count_lock:
+        ACTIVE_COUNT += 1
+
+async def decrement_active():
+    global ACTIVE_COUNT
+    async with count_lock:
+        ACTIVE_COUNT -= 1
+
+async def increment_waiting():
+    global WAITING_COUNT
+    async with count_lock:
+        WAITING_COUNT += 1
+
+async def decrement_waiting():
+    global WAITING_COUNT
+    async with count_lock:
+        WAITING_COUNT -= 1
+
+async def get_queue_status():
+    async with count_lock:
+        return {"active": ACTIVE_COUNT, "waiting": WAITING_COUNT}
+
+# ---------------------------------------------------------------------------
+# API
+# ---------------------------------------------------------------------------
+
+class EncodeRequest(BaseModel):
+    text: str
+    model: str = "qwen3"
+
+class DecodeRequest(BaseModel):
+    embedding: List[float]
+    steps: int = 32
+    model: str = "qwen3"
+
+class EncodeResponse(BaseModel):
+    embedding: List[float]
+    text: str
+
+
+@app.on_event("startup")
+async def startup():
+    load_models()
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index():
+    html_path = Path(__file__).parent / "demo" / "index.html"
+    return HTMLResponse(html_path.read_text())
+
+
+
+
+@app.get("/og-image.png")
+async def og_image():
+    return FileResponse(Path(__file__).parent / "demo" / "og-image.png", media_type="image/png", headers={"Cache-Control": "no-cache, max-age=0"})
+
+@app.get("/favicon-32.png")
+async def favicon():
+    return FileResponse(Path(__file__).parent / "demo" / "favicon-32.png", media_type="image/png", headers={"Cache-Control": "no-cache, max-age=0"})
+
+@app.get("/favicon.ico")
+async def favicon_ico():
+    return FileResponse(Path(__file__).parent / "demo" / "favicon-32.png", media_type="image/png")
+
+@app.get("/queue")
+async def queue_status():
+    """Return current queue status for frontend polling."""
+    return await get_queue_status()
+
+
+@app.post("/encode", response_model=EncodeResponse)
+async def encode(req: EncodeRequest):
+    model_key = req.model.lower()
+    if model_key not in MODELS:
+        return {"error": f"Unknown model: {model_key}"}
+    
+    m = MODELS[model_key]
+    
+    # Track waiting
+    await increment_waiting()
+    start_wait = time.time()
+    
+    try:
+        # Wait for semaphore with timeout
+        try:
+            async with asyncio.timeout(30):
+                async with ENCODE_SEM:
+                    await decrement_waiting()
+                    await increment_active()
+                    try:
+                        with torch.no_grad():
+                            inputs = m["encoder_tok"](
+                                [req.text], return_tensors="pt",
+                                padding=True, truncation=True, max_length=512
+                            ).to(DEVICE)
+                            out = m["encoder_model"](**inputs)
+                            pool_fn = get_pool_fn(m["config"]["model"]["encoder_model"])
+                            emb = pool_fn(out.last_hidden_state, inputs["attention_mask"])
+                            emb = F.normalize(emb, dim=-1)
+                        return EncodeResponse(embedding=emb[0].cpu().tolist(), text=req.text)
+                    finally:
+                        await decrement_active()
+        except asyncio.TimeoutError:
+            await decrement_waiting()
+            raise HTTPException(
+                status_code=503,
+                detail="Server busy, please try again in a moment"
+            )
+    except HTTPException:
+        raise
+    except Exception as e:
+        await decrement_waiting()
+        raise
+
+
+@app.post("/decode")
+async def decode(req: DecodeRequest):
+    model_key = req.model.lower()
+    if model_key not in MODELS:
+        return {"error": f"Unknown model: {model_key}"}
+    
+    m = MODELS[model_key]
+    model = m["model"]
+    config = m["config"]
+    encoder_model = m["encoder_model"]
+    encoder_tok = m["encoder_tok"]
+    decoder_tok = m["decoder_tok"]
+
+    async def generate():
+        # Track waiting
+        await increment_waiting()
+        
+        try:
+            # Wait for semaphore with timeout
+            try:
+                async with asyncio.timeout(30):
+                    async with DECODE_SEM:
+                        await decrement_waiting()
+                        await increment_active()
+                        try:
+                            embedding = torch.tensor([req.embedding], device=DEVICE, dtype=torch.float32)
+                            embedding = F.normalize(embedding, dim=-1)
+
+                            L = m["config"]["model"]["max_seq_len"]
+                            mask_id = m["config"]["model"]["mask_token_id"]
+                            steps = max(1, min(req.steps, L))
+                            per_step = max(1, L // steps)
+
+                            ids = torch.full((1, L), mask_id, dtype=torch.long, device=DEVICE)
+                            unmasked = torch.zeros(L, dtype=torch.bool, device=DEVICE)
+
+                            with torch.no_grad():
+                                for step in range(steps):
+                                    if unmasked.all():
+                                        break
+
+                                    logits = model(ids, embedding)
+                                    probs = F.softmax(logits[0], dim=-1)
+                                    confidence, preds = probs.max(dim=-1)
+                                    confidence[unmasked] = -1.0
+
+                                    k = min(per_step, (~unmasked).sum().item())
+                                    if k == 0:
+                                        break
+                                    _, topk = confidence.topk(k)
+                                    topk_set = set(topk.cpu().tolist())
+
+                                    ids[0, topk] = preds[topk]
+                                    unmasked[topk] = True
+
+                                    # Build per-token info
+                                    tokens = []
+                                    for i in range(L):
+                                        tid = ids[0, i].item()
+                                        if tid == mask_id:
+                                            tokens.append({"t": "[MASK]", "s": "m"})  # masked
+                                        else:
+                                            tok_text = decoder_tok.decode([tid])
+                                            state = "c" if i in topk_set else "u"  # changed / unchanged
+                                            tokens.append({"t": tok_text, "s": state})
+
+                                    # Decode full text (skip mask tokens)
+                                    clean = [t for t in ids[0].cpu().tolist() if t != mask_id]
+                                    text = decoder_tok.decode(clean, skip_special_tokens=True)
+
+                                    evt = {
+                                        "step": step,
+                                        "total": steps,
+                                        "tokens": tokens,
+                                        "text": text,
+                                        "progress": float(unmasked.sum().item()) / L,
+                                    }
+                                    yield f"data: {json.dumps(evt)}\n\n"
+                                    await asyncio.sleep(0.08)
+
+                            # Final: compute cosine similarity by re-encoding decoded text
+                            clean = [t for t in ids[0].cpu().tolist() if t != mask_id]
+                            final_text = decoder_tok.decode(clean, skip_special_tokens=True)
+
+                            with torch.no_grad():
+                                inputs2 = encoder_tok(
+                                    [final_text], return_tensors="pt",
+                                    padding=True, truncation=True, max_length=512
+                                ).to(DEVICE)
+                                out2 = encoder_model(**inputs2)
+                                pool_fn2 = get_pool_fn(m["config"]["model"]["encoder_model"])
+                                emb2 = pool_fn2(out2.last_hidden_state, inputs2["attention_mask"])
+                                emb2 = F.normalize(emb2, dim=-1)
+                                cos_sim = F.cosine_similarity(embedding, emb2).item()
+
+                            # Build final token list
+                            tokens = []
+                            for i in range(L):
+                                tid = ids[0, i].item()
+                                if tid == mask_id:
+                                    tokens.append({"t": "[MASK]", "s": "m"})
+                                else:
+                                    tokens.append({"t": decoder_tok.decode([tid]), "s": "u"})
+
+                            evt = {
+                                "step": steps,
+                                "total": steps,
+                                "tokens": tokens,
+                                "text": final_text,
+                                "progress": 1.0,
+                                "cosine_similarity": round(cos_sim, 4),
+                                "done": True,
+                            }
+                            yield f"data: {json.dumps(evt)}\n\n"
+                        finally:
+                            await decrement_active()
+            except asyncio.TimeoutError:
+                await decrement_waiting()
+                yield f"data: {json.dumps({'error': 'Server busy, please try again in a moment'})}\n\n"
+                return
+        except Exception as e:
+            await decrement_waiting()
+            yield f"data: {json.dumps({'error': str(e)})}\n\n"
+
+    return StreamingResponse(generate(), media_type="text/event-stream")
+
+
+@app.get("/random")
+async def get_random(model: str = "qwen3", hard: bool = False):
+    if model.lower() == "gemma":
+        pool = SAMPLE_SENTENCES_GEMMA_HARD if hard else SAMPLE_SENTENCES_GEMMA_EASY
+    else:
+        pool = SAMPLE_SENTENCES_QWEN3_HARD if hard else SAMPLE_SENTENCES_QWEN3_EASY
+    return {"text": random.choice(pool)}
+
+
+@app.get("/health")
+async def health():
+    queue = await get_queue_status()
+    return {
+        "status": "ok",
+        "device": str(DEVICE),
+        "models": list(MODELS.keys()),
+        "queue": queue
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8080, log_level="info")

get_model_in_text.py

@@ -0,0 +1,43 @@
+import os
+
+def export_files_to_txt(file_list, output_file):
+    # Các đuôi file văn bản phổ biến
+    text_extensions = {'.py', '.txt', '.md', '.json', '.yaml', '.yml', '.c', '.cpp', '.h', '.sql', '.html', '.css', '.js'}
+
+    with open(output_file, 'w', encoding='utf-8') as outfile:
+        for file_path in file_list:
+            # Kiểm tra file có tồn tại không
+            if not os.path.exists(file_path):
+                outfile.write(f"[LỖI] File không tồn tại: {file_path}\n\n")
+                continue
+
+            # Kiểm tra định dạng file
+            _, ext = os.path.splitext(file_path)
+            if ext.lower() in text_extensions:
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as infile:
+                        content = infile.read()
+                        
+                    outfile.write(f"{'='*80}\n")
+                    outfile.write(f"FILE PATH: {file_path}\n")
+                    outfile.write(f"{'='*80}\n\n")
+                    outfile.write(content)
+                    outfile.write("\n\n")
+                    
+                except Exception as e:
+                    outfile.write(f"[LỖI] Không thể đọc file {file_path}: {e}\n\n")
+            else:
+                outfile.write(f"[BỎ QUA] Định dạng file không hỗ trợ: {file_path}\n\n")
+
+    print(f"Xong! Nội dung đã được lưu vào: {output_file}")
+
+# --- Cấu hình danh sách file ở đây ---
+files_to_export = [
+    '/kaggle/embedding-inversion-demo/dataset.py',
+    '/kaggle/embedding-inversion-demo/configs/v2_qwen3.yaml',
+    '/kaggle/embedding-inversion-demo/model.py',
+    '/kaggle/embedding-inversion-demo/train.py'
+]
+
+file_out = '/kaggle/embedding-inversion-demo/prompt.txt'
+export_files_to_txt(files_to_export, file_out)

hf_data_download.py

@@ -0,0 +1,11 @@
+from huggingface_hub import hf_hub_download
+
+# Ví dụ: tải file "metadata.csv" từ dataset "nội_dung_dataset"
+file_path = hf_hub_download(
+    repo_id="doannv/omegabook_embs", 
+    filename="omega_books_500k_32.pt", 
+    repo_type="dataset",
+    local_dir="."
+)
+
+print(f"File đã được tải về tại: {file_path}")

hf_download.py

@@ -0,0 +1,15 @@
+from huggingface_hub import snapshot_download
+
+# Cấu hình các tham số
+repo_id = "doannv/dmlm_inv"
+local_dir = "/kaggle/embedding-inversion-demo" # Thư mục đích trên Kaggle
+
+# Tải toàn bộ repo
+snapshot_download(
+    repo_id=repo_id,
+    repo_type="dataset",
+    local_dir=local_dir,
+    max_workers=8                            # Tăng số luồng để tải nhanh hơn
+)
+
+print(f"Đã tải xong dữ liệu về: {local_dir}")

hf_upload.py

@@ -0,0 +1,10 @@
+from huggingface_hub import HfApi
+
+api = HfApi()
+
+api.upload_folder(
+    folder_path="/kaggle/embedding-inversion-demo",
+    repo_id="doannv/dmlm_inv",
+    repo_type="dataset",
+    ignore_patterns=[".venv/*", "*/.venv/*"], # Loại bỏ thư mục .venv
+)

invert.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+Minimal embedding inversion: embedding vector -> text.
+Only depends on: torch, transformers, yaml.
+
+Usage:
+    python invert.py "any text to test round-trip"
+    python invert.py --embedding path/to/embedding.npy
+"""
+
+import argparse
+import yaml
+import torch
+import torch.nn.functional as F
+from transformers import AutoModel, AutoTokenizer
+from model import ConditionalMDLM
+
+CHECKPOINT = "checkpoints/v1_inference_fp16.pt"
+
+
+def mean_pool(hidden, mask):
+    m = mask.unsqueeze(-1).expand(hidden.size()).float()
+    return (hidden * m).sum(1) / m.sum(1).clamp(min=1e-9)
+
+
+@torch.no_grad()
+def invert(embedding, model, config, steps=50):
+    """Invert a [1, 1024] embedding back to token ids."""
+    device = embedding.device
+    L = config["model"]["max_seq_len"]
+    mask_id = config["model"]["mask_token_id"]
+
+    ids = torch.full((1, L), mask_id, dtype=torch.long, device=device)
+    unmasked = torch.zeros(L, dtype=torch.bool, device=device)
+    per_step = max(1, L // steps)
+
+    for step in range(steps):
+        if unmasked.all():
+            break
+        logits = model(ids, embedding)
+        probs = F.softmax(logits[0], dim=-1)
+        confidence, preds = probs.max(dim=-1)
+        confidence[unmasked] = -1
+        k = min(per_step, (~unmasked).sum().item())
+        _, topk = confidence.topk(k)
+        ids[0, topk] = preds[topk]
+        unmasked[topk] = True
+
+    return ids[0]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Invert embeddings to text")
+    parser.add_argument("text", nargs="?", help="Text to embed then invert (round-trip test)")
+    parser.add_argument("--embedding", help="Path to .npy embedding file")
+    parser.add_argument("--checkpoint", default=CHECKPOINT)
+    parser.add_argument("--steps", type=int, default=50)
+    args = parser.parse_args()
+
+    if not args.text and not args.embedding:
+        parser.error("Provide text or --embedding")
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Load model
+    if args.checkpoint.endswith(".safetensors"):
+        from safetensors.torch import load_file as safetensors_load
+        import json as _json
+        tensors = safetensors_load(args.checkpoint, device=str(device))
+        # Read metadata from safetensors header
+        from safetensors import safe_open
+        with safe_open(args.checkpoint, framework="pt") as f:
+            meta = f.metadata()
+        config = _json.loads(meta["config_json"])
+        model = ConditionalMDLM(config).to(device).eval()
+        state = {k: v.float() for k, v in tensors.items()}
+        model.load_state_dict(state)
+        print(f"Loaded safetensors (step {meta['step']}, val_loss {meta['best_val_loss']})")
+    else:
+        ckpt = torch.load(args.checkpoint, map_location=device, weights_only=False)
+        config = ckpt["config"]
+        model = ConditionalMDLM(config).to(device).eval()
+        state = ckpt.get("ema_model", ckpt.get("model"))
+        state = {k: v.float() for k, v in state.items()}
+        model.load_state_dict(state)
+        print(f"Loaded checkpoint (step {ckpt['step']}, val_loss {ckpt['best_val_loss']:.4f})")
+
+    # Get embedding
+    if args.text:
+        jina_tok = AutoTokenizer.from_pretrained("jinaai/jina-embeddings-v3",
+                                                  trust_remote_code=True)
+        jina_model = AutoModel.from_pretrained("jinaai/jina-embeddings-v3",
+                                                trust_remote_code=True).to(device).eval()
+        inputs = jina_tok([args.text], return_tensors="pt", padding=True,
+                          truncation=True, max_length=512).to(device)
+        out = jina_model(**inputs)
+        emb = mean_pool(out.last_hidden_state, inputs["attention_mask"])
+        emb = F.normalize(emb, dim=-1)
+        print(f"Input: {args.text}")
+    else:
+        import numpy as np
+        emb = torch.from_numpy(np.load(args.embedding)).to(device)
+        if emb.dim() == 1:
+            emb = emb.unsqueeze(0)
+        emb = F.normalize(emb, dim=-1)
+
+    # Invert
+    pred_ids = invert(emb, model, config, steps=args.steps)
+    xlmr_tok = AutoTokenizer.from_pretrained("xlm-roberta-base")
+    clean = [t for t in pred_ids.cpu().tolist() if t not in (0, 1, config["model"]["mask_token_id"])]
+    text = xlmr_tok.decode(clean, skip_special_tokens=True)
+    print(f"Output: {text}")
+
+    # Cosine similarity if round-trip
+    if args.text:
+        inputs2 = jina_tok([text], return_tensors="pt", padding=True,
+                           truncation=True, max_length=512).to(device)
+        out2 = jina_model(**inputs2)
+        emb2 = mean_pool(out2.last_hidden_state, inputs2["attention_mask"])
+        emb2 = F.normalize(emb2, dim=-1)
+        cos = F.cosine_similarity(emb, emb2).item()
+        print(f"Cosine similarity: {cos:.4f}")
+
+
+if __name__ == "__main__":
+    main()

model.py

@@ -0,0 +1,153 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoModel
+
+class AdaLNZero(nn.Module):
+    def __init__(self, hidden_dim, cond_dim):
+        super().__init__()
+        self.norm = nn.LayerNorm(hidden_dim, elementwise_affine=False)
+        self.proj = nn.Linear(cond_dim, 3 * hidden_dim)
+        nn.init.zeros_(self.proj.weight)
+        nn.init.zeros_(self.proj.bias)
+
+    def forward(self, x, cond):
+        params = self.proj(cond).unsqueeze(1)
+        scale, shift, alpha = params.chunk(3, dim=-1)
+        normalized = self.norm(x) * (1 + scale) + shift
+        return normalized, alpha
+
+class ModernBertLayerWithAdaLN(nn.Module):
+    def __init__(self, pretrained_layer, hidden_dim, cond_dim):
+        super().__init__()
+        self.pretrained_layer = pretrained_layer
+        self.cond_proj = nn.Linear(cond_dim, 6 * hidden_dim)
+        nn.init.zeros_(self.cond_proj.weight)
+        nn.init.zeros_(self.cond_proj.bias)
+        
+        # Tự động map đúng tên module của Qwen3
+        self.attn_module = getattr(pretrained_layer, 'self_attn', getattr(pretrained_layer, 'attn', None))
+        self.mlp_module = getattr(pretrained_layer, 'mlp', getattr(pretrained_layer, 'feed_forward', None))
+        self.attn_norm = getattr(pretrained_layer, 'input_layernorm', getattr(pretrained_layer, 'attn_norm', nn.Identity()))
+        self.mlp_norm = getattr(pretrained_layer, 'post_attention_layernorm', getattr(pretrained_layer, 'mlp_norm', nn.Identity()))
+
+    def forward(self, hidden_states, cond, position_ids=None, attention_mask=None, position_embeddings=None):
+        adaln_params = self.cond_proj(cond).unsqueeze(1)
+        scale_attn, shift_attn, alpha_attn, scale_mlp, shift_mlp, alpha_mlp = adaln_params.chunk(6, dim=-1)
+        
+        # --- Attention Block ---
+        normed_attn = self.attn_norm(hidden_states) * (1 + scale_attn) + shift_attn
+        
+        # Đóng gói kwargs an toàn để truyền cho Attention
+        kwargs = {}
+        if attention_mask is not None: kwargs['attention_mask'] = attention_mask
+        if position_ids is not None: kwargs['position_ids'] = position_ids
+        if position_embeddings is not None: kwargs['position_embeddings'] = position_embeddings
+        
+        attn_out = self.attn_module(normed_attn, **kwargs)
+        attn_output = attn_out[0] if isinstance(attn_out, tuple) else attn_out
+        hidden_states = hidden_states + (alpha_attn * attn_output)
+        
+        # --- MLP Block ---
+        normed_mlp = self.mlp_norm(hidden_states) * (1 + scale_mlp) + shift_mlp
+        mlp_out = self.mlp_module(normed_mlp)
+        mlp_output = mlp_out[0] if isinstance(mlp_out, tuple) else mlp_out
+        hidden_states = hidden_states + (alpha_mlp * mlp_output)
+        
+        return hidden_states
+
+class ConditionalMDLM(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        mc = config["model"]
+        self.vocab_size = mc["vocab_size"]
+
+        print(f"Loading pretrained backbone from {mc['pretrained_token_embeddings']}...")
+        self.backbone = AutoModel.from_pretrained(mc["pretrained_token_embeddings"], trust_remote_code=True)
+        
+        # FIX CỐT LÕI: Tự động lấy kích thước chuẩn (1024) từ model gốc, bỏ qua khai báo sai trong yaml
+        self.hidden_dim = self.backbone.config.hidden_size 
+        self.cond_dim = mc["embedding_cond_dim"]
+        print(f"Dynamically mapped: hidden_dim={self.hidden_dim}, cond_dim={self.cond_dim}")
+
+        self.token_embed = self.backbone.get_input_embeddings()
+        self.embed_norm = getattr(self.backbone, 'norm', nn.Identity())
+        
+        self.layers = nn.ModuleList([
+            ModernBertLayerWithAdaLN(layer, self.hidden_dim, self.cond_dim)
+            for layer in self.backbone.layers
+        ])
+        
+        self.final_adaln = AdaLNZero(self.hidden_dim, self.cond_dim)
+        self.output_proj = nn.Linear(self.hidden_dim, self.vocab_size, bias=False)
+        
+        if mc.get("tie_weights", True):
+            self.output_proj.weight = self.token_embed.weight
+
+    def _forward_impl(self, input_ids, cond_embedding, padding_mask, return_logits=False):
+        device = input_ids.device
+        batch_size, seq_len = input_ids.shape
+
+        # 1. Chuẩn bị Attention Mask (Fix lõi SDPA dtype & Ép Bidirectional)
+        if padding_mask is not None:
+            # Chuyển sang bool: True = Attend (Giữ lại), False = PAD (Bỏ qua)
+            attn_mask = (~padding_mask).bool() 
+        else:
+            attn_mask = torch.ones(batch_size, seq_len, dtype=torch.bool, device=device)
+            
+        # Mở rộng chiều thành [Batch, 1, 1, SeqLen] để broadcast với đa Head
+        # Phải truyền mask này vào để tắt Causal Mask mặc định của Qwen3
+        attn_mask = attn_mask.unsqueeze(1).unsqueeze(2)
+
+        # 2. Chuẩn bị Position IDs
+        pos_ids = torch.arange(seq_len, dtype=torch.long, device=device).unsqueeze(0).expand(batch_size, -1)
+
+        # 3. Trích xuất RoPE đa năng
+        pos_emb = None
+        if hasattr(self.backbone, 'rotary_emb'):
+            dummy_x = torch.empty(batch_size, seq_len, self.hidden_dim, device=device, dtype=torch.bfloat16)
+            try:
+                pos_emb = self.backbone.rotary_emb(dummy_x, pos_ids)
+            except Exception:
+                try:
+                    pos_emb = self.backbone.rotary_emb(pos_ids)
+                except Exception:
+                    pass
+
+        # 4. Forward Pass
+        x = self.token_embed(input_ids)
+        x = self.embed_norm(x)
+        
+        for layer in self.layers:
+            # Đã truyền attn_mask chuẩn bool
+            x = layer(x, cond_embedding, position_ids=pos_ids, attention_mask=attn_mask, position_embeddings=pos_emb)
+            
+        x, _ = self.final_adaln(x, cond_embedding)
+        
+        if return_logits:
+            return self.output_proj(x)
+        return x
+
+    def forward(self, input_ids, cond_embedding, padding_mask=None):
+        return self._forward_impl(input_ids, cond_embedding, padding_mask, return_logits=True)
+
+    def forward_hidden(self, input_ids, cond_embedding, padding_mask=None):
+        return self._forward_impl(input_ids, cond_embedding, padding_mask, return_logits=False)
+
+    def count_params(self):
+        total = sum(p.numel() for p in self.parameters())
+        trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
+        return total, trainable
+
+def apply_mask(token_ids, mask_token_id, padding_mask=None):
+    B, L = token_ids.shape
+    device = token_ids.device
+    u = torch.rand(B, 1, device=device)
+    mask_ratio = (1 - (1 - 1e-3)**u).clamp(min=0.1, max=1.0)
+    rand_scores = torch.rand(B, L, device=device)
+    if padding_mask is not None:
+        rand_scores[padding_mask] = 2.0
+    target_mask = rand_scores < mask_ratio
+    masked_ids = token_ids.clone()
+    masked_ids[target_mask] = mask_token_id
+    return masked_ids, target_mask, mask_ratio

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "mi-research"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "datasets>=4.8.4",
+    "fastapi>=0.104.0",
+    "numpy>=1.24.0",
+    "pyyaml>=6.0",
+    "torch>=2.0.0",
+    "transformers>=4.35.0",
+    "uvicorn>=0.24.0",
+]

train.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+import os
+import time
+import argparse
+import json
+import yaml
+import math
+import copy
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from safetensors.torch import save_file as safetensors_save
+
+from model import ConditionalMDLM, apply_mask
+from dataset import create_dataloaders
+
+def get_lr(step, warmup_steps, max_steps, max_lr, min_lr_ratio=0.0):
+    if step < warmup_steps:
+        return max_lr * step / warmup_steps
+    progress = (step - warmup_steps) / max(1, max_steps - warmup_steps)
+    min_lr = max_lr * min_lr_ratio
+    return min_lr + (max_lr - min_lr) * 0.5 * (1 + math.cos(math.pi * progress))
+
+def _meta(step, best_val_loss, config):
+    mc = config.get("model", {})
+    return {
+        "step": str(step),
+        "best_val_loss": f"{best_val_loss:.6f}",
+        "encoder_model": str(mc.get("encoder_model", "unknown")),
+        "decoder_tokenizer": str(mc.get("decoder_tokenizer", "unknown")),
+        "vocab_size": str(mc.get("vocab_size", 0)),
+        "hidden_dim": str(mc.get("hidden_dim", 0)),
+        "config_json": json.dumps(config, default=str),
+    }
+
+def save_checkpoint(path, step, best_val_loss, model, ema_model, optimizer, config):
+    torch.save({
+        "step": step,
+        "best_val_loss": best_val_loss,
+        "model": model.state_dict(),
+        "ema_model": ema_model.state_dict(),
+        "optimizer": optimizer.state_dict(),
+        "config": config,
+    }, path)
+
+def save_ema(path, step, best_val_loss, ema_model, config):
+    st_path = path.replace(".pt", ".safetensors")
+    safetensors_save(ema_model.state_dict(), st_path, metadata=_meta(step, best_val_loss, config))
+
+def train(config, resume=False):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Device: {device}\nGPU: {torch.cuda.get_device_name() if device.type == 'cuda' else 'N/A'}")
+
+    mc, tc = config["model"], config["training"]
+
+    model = ConditionalMDLM(config).to(device)
+    total_params, trainable_params = model.count_params()
+    print(f"Model params: {total_params:,} total, {trainable_params:,} trainable")
+
+    ema_decay = tc.get("ema_decay", 0.9999)
+    ema_model = copy.deepcopy(model)
+    ema_model.eval()
+    for p in ema_model.parameters(): p.requires_grad_(False)
+
+    batch_size = tc.get("batch_size", 128)
+    print(f"Loading data... (Batch size: {batch_size})")
+    train_loader, val_loader = create_dataloaders(config)
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=tc["lr"], weight_decay=tc["weight_decay"])
+    
+    # KHÔNG DÙNG GradScaler cho bfloat16
+    grad_accum = tc.get("grad_accum", 1)
+    
+    ckpt_dir = config.get("_ckpt_dir", "checkpoints")
+    os.makedirs(ckpt_dir, exist_ok=True)
+    start_step, best_val_loss = 0, float("inf")
+
+    if resume:
+        ckpt_path = f"{ckpt_dir}/latest.pt"
+        if not os.path.exists(ckpt_path): ckpt_path = f"{ckpt_dir}/best.pt"
+        if os.path.exists(ckpt_path):
+            ckpt = torch.load(ckpt_path, map_location=device, weights_only=False)
+            model.load_state_dict({k.replace("_orig_mod.", ""): v for k, v in ckpt["model"].items()})
+            optimizer.load_state_dict(ckpt["optimizer"])
+            start_step, best_val_loss = ckpt["step"], ckpt.get("best_val_loss", float("inf"))
+            if "ema_model" in ckpt:
+                ema_model.load_state_dict({k.replace("_orig_mod.", ""): v for k, v in ckpt["ema_model"].items()})
+
+    model.train()
+    step = start_step
+    max_steps, log_every, eval_every = tc["max_steps"], tc["log_every"], tc.get("eval_every", 500)
+    early_stop_patience = tc.get("early_stop_patience", 5000)
+
+    running_loss, running_acc, running_count, total_samples = 0.0, 0.0, 0, 0
+    micro_step = 0
+    t0_global = time.time()
+    data_iter = iter(train_loader)
+
+    print(f"\n=== Training started (step {step}/{max_steps}) ===")
+
+    while step < max_steps:
+        try:
+            batch = next(data_iter)
+        except StopIteration:
+            data_iter = iter(train_loader)
+            batch = next(data_iter)
+
+        token_ids = batch["token_ids"].to(device)
+        embedding = batch["embedding"].to(device)
+        padding_mask = batch["padding_mask"].to(device)
+
+        masked_ids, target_mask, mask_ratio = apply_mask(token_ids, mc["mask_token_id"], padding_mask)
+
+        if micro_step == 0:
+            lr = get_lr(step, tc["warmup_steps"], max_steps, tc["lr"], tc.get("min_lr_ratio", 0.0))
+            for pg in optimizer.param_groups: pg["lr"] = lr
+            optimizer.zero_grad()
+
+        # Dùng bfloat16 siêu việt của H100
+        with torch.amp.autocast('cuda', dtype=torch.bfloat16):
+            hidden = model.forward_hidden(masked_ids, embedding, padding_mask)
+            
+            mask_flat = target_mask.view(-1)
+            pad_flat = padding_mask.view(-1)
+            active_mask = mask_flat & (~pad_flat)
+            total_active = active_mask.sum().item()
+
+            chunk_size = 256
+            total_positions = hidden.shape[0] * hidden.shape[1]
+            hidden_flat = hidden.view(-1, hidden.shape[-1])
+            targets_flat = token_ids.view(-1)
+            
+            total_loss = torch.tensor(0.0, device=device)
+            total_correct = 0
+
+            for i in range(0, total_positions, chunk_size):
+                end = min(i + chunk_size, total_positions)
+                h_chunk = hidden_flat[i:end]
+                t_chunk = targets_flat[i:end]
+                m_chunk = active_mask[i:end].float()
+
+                w = model.output_proj.weight
+                logits_chunk = F.linear(h_chunk, w)
+                
+                loss_chunk = F.cross_entropy(logits_chunk, t_chunk, reduction="none")
+                total_loss = total_loss + (loss_chunk * m_chunk).sum()
+
+                with torch.no_grad():
+                    preds_chunk = logits_chunk.argmax(-1)
+                    total_correct += ((preds_chunk == t_chunk) * m_chunk.bool()).sum().item()
+
+            loss = total_loss / max(total_active, 1)
+            loss_weight = (1.0 / mask_ratio.squeeze(1)).mean()
+            loss = (loss * loss_weight) / grad_accum
+
+        # Gọi backward trực tiếp, không dùng scaler
+        loss.backward()
+
+        running_loss += loss.item() * grad_accum
+        running_acc += total_correct / max(total_active, 1)
+        running_count += 1
+        total_samples += token_ids.shape[0]
+        micro_step += 1
+
+        if micro_step < grad_accum: continue
+
+        # Bước Optimizer chuẩn: Clip -> Step
+        micro_step = 0
+        nn.utils.clip_grad_norm_(model.parameters(), tc["max_grad_norm"])
+        optimizer.step()
+        
+        with torch.no_grad():
+            for ep, mp in zip(ema_model.parameters(), model.parameters()):
+                ep.mul_(ema_decay).add_(mp, alpha=1 - ema_decay)
+        step += 1
+
+        if step % log_every == 0:
+            avg_loss = running_loss / running_count
+            avg_acc = running_acc / running_count
+            elapsed = (time.time() - t0_global) / 60
+            rate = total_samples / (time.time() - t0_global)
+            print(f"step {step} | loss {avg_loss:.4f} | acc {avg_acc:.3f} | lr {lr:.2e} | {rate:.0f} samp/s | {elapsed:.1f}m", flush=True)
+            running_loss, running_acc, running_count = 0.0, 0.0, 0
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", default="configs/v2_qwen3.yaml")
+    parser.add_argument("--resume", action="store_true")
+    args = parser.parse_args()
+
+    with open(args.config) as f: config = yaml.safe_load(f)
+    config["_ckpt_dir"] = f"checkpoints_{os.path.splitext(os.path.basename(args.config))[0]}"
+    train(config, resume=args.resume)
+
+if __name__ == "__main__":
+    main()