# MiniMax H3 Semantic Bridge ## Cross-Architecture Semantic Transfer and Distillation for Video Generation ### Abstract **MiniMax H3 Semantic Bridge** is the result of an experimental investigation into whether higher-level semantic behavior can be transferred between fundamentally different generative model architectures without directly merging their weights. The project began with an attempt to transfer selected capabilities from **SenseNova U1.5** into **MiniMax H3**, particularly in areas such as complex composition, spatial relationships, human anatomy, counting, prompt following, text interpretation, materials, lighting, reflections, transparency, and occlusion. Direct parameter grafting proved unsuitable because the two models do not expose meaningfully compatible weight structures. This led to a different approach: instead of transferring parameters, I investigated whether the models' internal representations of the **same textual prompt** contained a learnable cross-model relationship. They did. An experimental **Full Bridge** was developed in which SenseNova acted as a semantic donor at inference time and its representation was transformed into H3-compatible conditioning. The resulting system produced meaningful changes in actual H3 generations and demonstrated that semantic information could be transferred without modifying H3's generative transformer. However, the Full Bridge required the complete donor model during inference. The final stage therefore treated this system as a teacher and distilled its behavior into a compact adapter operating entirely from H3's own representation. The resulting **MiniMax H3 Semantic Bridge** requires no SenseNova checkpoint, runtime, tokenizer, or additional large model during inference. Only this final distilled version is included in the public release. --- ### Experimental Hardware All experiments reported in this project were conducted locally using a single **NVIDIA GeForce RTX 3090 Ti (24 GB VRAM)**. This includes hidden-state extraction from the source and target models, projector screening, semantic-bridge construction, student distillation, quantitative evaluation, and qualitative MiniMax H3 generation experiments. No multi-GPU or datacenter training cluster was used. This hardware constraint was intentional: part of the experiment was to determine whether cross-architecture semantic representation transfer could be explored and distilled into a practical adapter using consumer-accessible compute. # 1. Motivation Large generative models can possess all of the concepts necessary to satisfy a prompt while still failing to preserve the relationships between those concepts. A simple prompt such as: > *A woman holding a glass bottle.* primarily requires concept recognition. A more structured instruction is different: > *A woman stands behind a transparent glass table holding a polished metal cup in her left hand. A mirror behind her reflects the room, while warm side light passes through a glass bottle on the table.* Now the model must maintain several relationships simultaneously: ```text woman └─ left hand └─ polished metal cup glass table └─ glass bottle └─ warm light passes through it mirror └─ reflects the room ``` All of the individual concepts may already be well represented by the model. The difficult part is their **composition**. This distinction motivated the project. Rather than attempting to add new visual knowledge to MiniMax H3, I wanted to investigate whether another model's semantic interpretation could alter how H3 represents complex instructions before generation begins. The original areas of interest were: * spatial and compositional reasoning; * human anatomy and body relationships; * object counting; * prompt following; * text interpretation; * material properties; * lighting relationships; * reflection and transparency; * occlusion; * long prompts containing multiple simultaneous constraints. The question was therefore not simply: > Can another model be merged into H3? It was: > **Can useful semantic structure learned by another architecture be translated into H3's representation space?** --- # 2. The First Approach: Direct Model Grafting The project initially began as a model-grafting experiment. The intuitive approach was to identify semantically relevant components in SenseNova and transfer them directly into MiniMax H3. Architectural analysis quickly showed why this was unlikely to work. The two models have substantially different internal structures, dimensionalities and parameter organization. Examination of the major two-dimensional weight matrices did not reveal useful direct correspondences suitable for conventional grafting. There were no meaningful exact shape matches in the parts investigated, nor did simple transposition or matching input/output dimensions provide a useful mapping. This is an important negative result. Two models can potentially encode related semantic knowledge without storing that knowledge in parameter matrices that are directly interchangeable. A parameter-level question was therefore replaced by a representation-level question. Instead of looking for: ```text SenseNova weights ↓ matching H3 weights ``` I began looking for: ```text same prompt ↓ ↓ SenseNova H3 ↓ ↓ internal representation ↓ learnable relationship? ``` This turned out to be much more productive. --- # 3. Searching for Cross-Model Representation Alignment Both models were presented with the same prompts and their internal textual representations were examined at multiple depths. The models do not use the same hidden dimensionality, so their representations cannot simply be compared directly. A learned projection was therefore introduced during the research stage. The objective was not initially to improve H3 generation. It was simply to answer a more fundamental question: > **Can a representation produced by one architecture be predictably mapped into a representation produced by another architecture?** Multiple internal representation combinations were screened. One correspondence was substantially stronger than the alternatives. On held-out prompts from the initial dataset, the learned cross-model mapping reached approximately: ```text validation cosine similarity ≈ 0.904 ``` This was encouraging, but there was an obvious danger. The mapping might simply have learned the distribution of prompts used to construct it. A stricter test was required. --- # 4. Out-of-Distribution Test A separate set of **160 new prompts** was constructed. These prompts were designed to stress combinations such as: * complex spatial relationships; * difficult counting; * anatomy; * material/light interactions; * text; * architecture and vehicles; * reflection and occlusion; * longer multi-object compositions. The prompts were kept separate from the original fitting set. When the frozen cross-model bridge was evaluated on these new prompts, representation similarity decreased from approximately: ```text 0.904 ``` to: ```text 0.749 ``` This drop was significant. But the mapping did not collapse. That distinction was important. A completely prompt-specific mapping would be expected to fail much more severely once moved outside its fitting distribution. Instead, a substantial relationship remained. This suggested that the bridge had captured at least part of a genuine cross-model representation alignment rather than simply memorizing sentences. At this point, numerical similarity alone was no longer sufficient. The mapping had to be tested inside the actual video-generation pipeline. --- # 5. The Experimental Full Bridge The next implementation introduced the mapped SenseNova representation directly into MiniMax H3 conditioning. Conceptually, the system became: ```text Prompt │ ├──────────────► H3 Text Encoder │ │ │ ▼ │ native conditioning H │ └──────────────► SenseNova │ ▼ semantic representation │ ▼ learned projection │ ▼ H3-compatible semantic S ``` The transformed semantic representation was magnitude-aligned with native H3 conditioning and combined through a controllable residual blend: ```text C = H + α(S - H) ``` where: ```text H = native H3 conditioning S = mapped semantic representation α = bridge strength C = final conditioning supplied to H3 ``` This became the **Full Bridge**. Crucially, H3 itself was not modified. The video transformer remained unchanged. The intervention occurred entirely in the conditioning supplied to it. --- # 6. From Tensor Similarity to Actual Generation The Full Bridge was then tested through actual MiniMax H3 generation. This was the first point at which the experiment became substantially more interesting. The mapped conditioning did not merely remain numerically valid. It produced coherent H3 generations and observable changes in how prompts were interpreted. This demonstrated that the transferred representation existed in a region of conditioning space that H3 could meaningfully use. The Full Bridge therefore served as a proof of concept for three ideas: **First**, useful information could be transferred between these architectures at the representation level despite the failure of direct parameter grafting. **Second**, the transferred representation could influence H3 without modifying its generative transformer. **Third**, the effect could be controlled continuously through the blend strength. But the solution was impractical. Every generation required the donor model to participate in prompt processing. The runtime pipeline therefore contained two large models simply to produce one conditioning tensor. That was acceptable for research. It was not a good release architecture. --- # 7. Removing the Donor This led to the central distillation experiment. If the Full Bridge could determine an appropriate semantic correction for H3, perhaps H3's own representation already contained enough information for a smaller model to **predict what the Full Bridge would have done**. The Full Bridge was therefore converted from an inference solution into a **teacher**. The objective changed from: ```text SenseNova ↓ map representation into H3 ``` to: ```text H3 representation ↓ small student ↓ predict teacher-derived semantic representation ``` If successful, SenseNova could disappear completely from inference. --- # 8. Early Distillation The first distilled experiments attempted to predict the semantic correction directly. These results were useful but not sufficiently strong. The best early single-representation configuration achieved correction prediction similarity of only roughly: ```text ≈ 0.51 ``` A naïve attempt to combine several H3 representations performed even worse. This was another useful negative result. Simply providing the student with more internal features did not automatically produce a better approximation. The target itself needed to be reconsidered. Rather than asking the student to directly predict the difference between native and teacher conditioning, the next version learned the **teacher-derived semantic representation itself**. This changed the result dramatically. --- # 9. Distilled Student V2 The second student learned to approximate the semantic representation produced by the Full Bridge before the final blend with H3 conditioning. On the development distribution, representation similarity reached approximately: ```text 0.995 ``` and semantic-correction similarity reached approximately: ```text 0.973 ``` This was a major improvement. However, the strict OOD evaluation revealed a remaining weakness. Across the previously unseen 160-prompt set, representation similarity remained strong: ```text 0.941840 ``` but correction similarity fell to: ```text 0.879840 ``` The model clearly understood much of the teacher transformation, but the generalization gap was still visible. Long, highly compositional prompts were among the more difficult cases. This motivated one final training stage. --- # 10. Final Distillation The original and difficult prompt distributions were combined and the student was refined while preserving a held-out validation subset. The final evaluation used: ```text 500 training prompts 100 validation prompts ``` with the validation set containing both original-distribution and strict OOD examples. The final student produced: ```text Teacher representation similarity 0.995890 Semantic correction similarity 0.983558 Main-distribution correction 0.980888 OOD correction 0.989788 Minimum correction similarity 0.935910 ``` The final blended conditioning was even closer to the Full Bridge: ```text Bridge strength α = 0.10 0.999958 Bridge strength α = 0.20 0.999827 Bridge strength α = 0.30 0.999602 ``` The final evaluation therefore showed not only high approximation of the teacher representation, but strong approximation of the **actual semantic correction** produced by the Full Bridge. --- # 11. Performance Across Semantic Categories The final validation set covered multiple semantic categories. Correction similarity by category was: | Category | Similarity | | -------------------------- | ---------: | | Text | 0.996061 | | Reflection / occlusion | 0.995932 | | Complex counting | 0.994557 | | Complex text | 0.991912 | | Reflection / occlusion OOD | 0.991855 | | Complex spatial | 0.991125 | | Long composition | 0.990637 | | Architecture / vehicle | 0.990606 | | Complex material / light | 0.987394 | | Material | 0.986263 | | Complex anatomy | 0.982104 | | Anatomy | 0.980773 | | Lighting | 0.978327 | | Spatial | 0.974002 | | Counting | 0.965250 | One particularly interesting result is the recovery on long-composition prompts. These had been among the weaker cases during earlier OOD testing, yet the final student reached approximately `0.991` correction similarity for this category. This suggests that the student capacity itself was not necessarily the primary limitation. The distribution used during distillation was equally important. --- # 12. The Final Architecture The research system had started as: ```text H3 + SenseNova + cross-model bridge ``` The final system is simply: ```text MiniMax H3 │ ▼ H3 conditioning │ ▼ Semantic Bridge │ ▼ modified conditioning │ ▼ MiniMax H3 video generation ``` SenseNova is no longer involved. The final adapter operates exclusively on information already produced by H3. It predicts a learned semantic transformation, magnitude-aligns that representation with native conditioning, and blends the two according to a user-controlled strength. No weights inside the MiniMax H3 diffusion transformer are modified. --- # 13. An Unexpected Qualitative Result The final distilled adapter was originally expected to behave simply as a cheaper approximation of the Full Bridge. Actual generation produced a more interesting result. The distilled version preserves the general behavioral effect of the Full Bridge, but the resulting videos are not always visually identical. In some of my tests, I actually preferred the output of the **distilled adapter** to the original Full Bridge. This observation should be interpreted cautiously. It does not prove that the distilled student is objectively superior to its teacher. One possible explanation is a regularization effect. The Full Bridge contains the complete mapped donor representation, including components that may not be consistently useful to H3. A compact student cannot reproduce every variation perfectly and may preferentially learn the more predictable structure of the transformation. In that interpretation, distillation behaves somewhat like a semantic filter: ```text Full teacher signal ↓ distillation ↓ most reproducible transformation ↓ H3 ``` This is currently a hypothesis rather than a demonstrated mechanism. More qualitative testing is needed. Nevertheless, it was unexpected because the purpose of distillation was originally efficiency—not improvement. --- # 14. What Semantic Bridge Actually Is Semantic Bridge is **not a LoRA**. It is not a checkpoint merge. It is not a conventional model graft. And the released file does not contain a second generative model. A more accurate description is: > **A compact conditioning-space adapter distilled from a cross-architecture semantic mapping.** A LoRA modifies effective model weights: ```text base weights + low-rank weight update ↓ modified network behavior ``` Semantic Bridge instead modifies information entering the generative transformer: ```text prompt ↓ H3 representation ↓ Semantic Bridge ↓ modified representation ↓ unchanged H3 generator ``` This distinction also means that Semantic Bridge and conventional LoRAs are conceptually complementary rather than mutually exclusive. --- # 15. What Is Being Released There were two fundamentally different implementations during this research. ### Full SenseNova → H3 Bridge **Research prototype only — not released.** This implementation required SenseNova during inference and was used to establish that cross-model semantic transfer could influence H3 generation. It subsequently became the teacher system for distillation. ### MiniMax H3 Semantic Bridge **This is the version being released.** It is the distilled standalone implementation. It requires: ```text MiniMax H3 H3-compatible text encoder MiniMaxH3_SemanticBridge_v1.safetensors MiniMax H3 Semantic Bridge custom node ``` It does **not** require: ```text SenseNova checkpoint SenseNova runtime SenseNova tokenizer a second large language/multimodal model the experimental Full Bridge ``` SenseNova was involved in the research and training process only. **No SenseNova installation is required to use the public release.** --- # 16. Installation The release consists of the ComfyUI custom node and the distilled `.safetensors` adapter. ### Custom Node Copy: ```text MiniMax_H3_Semantic_Bridge ``` to: ```text ComfyUI/custom_nodes/ ``` The resulting structure should look like: ```text ComfyUI/ └── custom_nodes/ └── MiniMax_H3_Semantic_Bridge/ ├── __init__.py ├── nodes.py ├── README.txt ├── ADAPTER_INSTALLATION.txt └── RELEASE_NOTES.txt ``` ### Adapter Copy: ```text MiniMaxH3_SemanticBridge_v1.safetensors ``` to: ```text ComfyUI/models/semantic_bridge/ ``` The final location should therefore be: ```text ComfyUI/ └── models/ └── semantic_bridge/ └── MiniMaxH3_SemanticBridge_v1.safetensors ``` Restart ComfyUI after installation. --- # 17. ComfyUI Nodes Three nodes are included. ### MiniMax H3 Image to Video + Semantic Bridge This is the recommended node for normal use. It replaces the standard MiniMax H3 Image to Video conditioning stage and applies the distilled semantic transformation internally. It supports first-frame and last-frame conditioning and can therefore be used directly in standard H3 image-to-video workflows. ### MiniMax H3 Semantic Bridge This is the standalone conditioning version. It accepts existing MiniMax H3 `CONDITIONING` and applies the Semantic Bridge transformation. This is useful for custom workflows where H3 conditioning is already being generated elsewhere. ### MiniMax H3 Clear Semantic Bridge Cache An optional utility for clearing the small adapter from memory. It is generally unnecessary during normal operation but is provided for workflow and debugging convenience. --- # 18. Recommended Settings The recommended starting configuration is: ```text semantic_bridge: MiniMaxH3_SemanticBridge_v1.safetensors alpha: 0.10 magnitude_match: per_token ``` `alpha` controls how strongly the predicted semantic representation influences native H3 conditioning. Conceptually: ```text alpha = 0.00 │ │ Native H3 │ ├── 0.05 ├── 0.10 ← recommended starting point ├── 0.20 └── 0.30 ``` A higher value does **not** necessarily mean a better result. It simply increases the distance from native H3 conditioning. For controlled comparisons I recommend testing: ```text 0.00 0.05 0.10 0.20 0.30 ``` while keeping all other generation parameters unchanged. --- # 19. How to Evaluate It Semantic Bridge is intended primarily for prompts where **relationships** matter. A weak test is: > *A beautiful woman walking through a city.* There is little semantic structure for the bridge to affect. More informative tests involve multiple constraints: > *A woman holds a transparent bottle in her left hand while pointing toward a red sign with her right hand. A polished metal sphere sits behind the bottle and reflects a blue object outside the frame.* Useful evaluation areas include: ```text left / right relationships front / behind inside / outside multiple people specific body parts object counts reflections transparent objects material interactions lighting direction visible text long compositions multiple simultaneous instructions ``` For a controlled A/B test, keep the following identical: ```text prompt seed source image resolution length steps sampler guidance ``` and compare: ```text A — Native MiniMax H3 B — MiniMax H3 + Semantic Bridge ``` `alpha = 0.00` can also be used as a native-conditioning baseline within the Semantic Bridge node. --- # 20. Qualitative A/B Examples Two controlled A/B pairs are included in the public repository. Within each pair, the prompt and generation setup were kept the same; the intended comparison is native H3 conditioning versus Semantic Bridge. The published Bridge examples use `alpha = 0.15` to make the behavioral difference easier to inspect. These examples are qualitative observations, not a statistical benchmark. ## Example 01 — Rooftop Train Chase This test stresses complex motion, running anatomy, pursuit geometry, a specific vault interaction, hand-to-obstacle contact, landing continuity, wet reflective metal, rain, sparks, and camera motion. The exact prompt and both videos are included under `examples/01_rooftop_train_chase/`. ## Example 02 — Prompt Adherence, Materials, Reflection and Transparency This test contains a particularly explicit instruction: > **“Her right hand rests flat on the glass tabletop with all five fingers naturally separated and clearly visible.”** In the native H3 generation, the character introduces an unrequested action by moving the right hand across the tabletop. In the Semantic Bridge generation at `alpha = 0.15`, the hand remains resting on the surface, more closely matching the explicitly requested state. This observation is useful because the target is directly inspectable: the requested state is *resting*, rather than moving. It is still presented only as qualitative evidence from this specific controlled pair, not as proof of universal prompt-adherence improvement. The same prompt also stresses left/right hand roles, exactly three tabletop objects in a specified order, text rendering, transparent glass, reflective metal, mirror correspondence, refraction, and mixed warm/cool lighting. The exact prompt and both videos are included under `examples/02_glass_table_prompt_adherence/`. --- # 21. Scope: FL2VA / Standard Text-Conditioned H3 Only An important limitation emerged during later testing. The released Semantic Bridge was developed and distilled from the standard H3 text-conditioning path. It was not trained on the separate multimodal reference-conditioning distribution used by Ref2VA. An experimental Ref2VA-compatible implementation was tested with reference images and reference audio. At a structural level it was possible to preserve visual-reference token positions while applying the adapter to text-designated positions. However, singing and lip-sync tests showed a clear practical regression: vocal articulation became less distinct and more mumbling-like than with native Ref2VA conditioning. This suggests that preserving reference-image token positions is not sufficient. In Ref2VA, the text representation participates in a larger multimodal alignment involving text, reference media, audio, and visual performance. Altering only the text-designated part of that representation can still disturb the multimodal relationship. The current release should therefore be treated as designed for: **MiniMax H3 FL2VA / standard text-conditioned generation.** It should not currently be considered compatible with: **MiniMax H3 Ref2VA / reference-conditioned generation**, particularly workflows involving reference audio, singing, voice-driven performance, or lip synchronization. This negative result does not establish that semantic bridging is fundamentally incompatible with Ref2VA. It indicates that a Ref2VA bridge should likely be trained separately on the multimodal conditioning regime it is intended to modify. A broader lesson is that **representation compatibility is contextual, not merely dimensional**. Two conditioning tensors can have the same dimensionality while participating in different semantic and temporal alignment mechanisms. --- # 22. Limitations This is an experimental research release, not a universal H3 enhancement. The adapter should not be expected to improve every generation. MiniMax H3 already has strong semantic capabilities, and many simple prompts do not require any additional transformation. There may also be prompts for which native conditioning produces a preferable result. Another important limitation is that the reported numerical metrics measure agreement with the experimental teacher system. They do **not** directly measure video quality. A student that perfectly reproduces its teacher is not necessarily a better video generator, and a small difference in conditioning can sometimes result in a substantial visual difference after generative sampling. For this reason, actual controlled video comparisons remain the most important evaluation. The current research also focuses on a particular group of semantic behaviors. Other areas may respond differently and have not yet been evaluated systematically. Finally, Semantic Bridge does not create information that H3 fundamentally cannot represent. It should be viewed as a learned transformation of H3's existing semantic conditioning, not as an independent reasoning system. --- # 23. Why the Result May Matter Beyond MiniMax H3 The most interesting result of this experiment may not be the released adapter itself. Direct weight transfer between unrelated architectures is extremely restrictive. Different hidden dimensions, layer structures, attention implementations and parameter organizations make conventional grafting difficult or meaningless. Representations are different. If two models have learned related concepts, their internal spaces do not necessarily need to be structurally identical for a **learnable relationship** to exist between them. This suggests a more general workflow: ```text Model A │ │ semantic teacher ▼ cross-architecture representation mapping │ ▼ Model B-compatible teacher signal │ ▼ distillation │ ▼ small Model B adapter ``` After distillation: ```text Model A ✕ no longer required Model B + small distilled adapter ``` The expensive cross-model system can therefore potentially exist only during research and training. The deployed model remains essentially its original architecture. This opens an interesting research direction: instead of asking whether two models can share weights, we can ask whether they can **teach each other representations**. --- # 24. Conclusion MiniMax H3 Semantic Bridge began as an attempt to graft semantic capabilities between two incompatible model architectures. That approach failed. The failure led to a more interesting question. Rather than transferring weights, I investigated whether the models' representations of the same prompt contained a learnable relationship. A measurable cross-model alignment was found. That alignment was then incorporated into an experimental Full Bridge, which demonstrated that a mapped donor representation could meaningfully influence actual MiniMax H3 generation. The Full Bridge solved the semantic-transfer problem but introduced an impractical runtime dependency on the donor model. Distillation removed that dependency. The final system is therefore much simpler than the research pipeline that produced it: ```text MiniMax H3 + MiniMax H3 Semantic Bridge ``` The public adapter contains no SenseNova checkpoint and requires no SenseNova installation or inference pass. It operates entirely from H3's own conditioning and introduces the learned transformation at a controllable strength. The result suggests a broader possibility: > **Useful learned behavior may be transferable between incompatible model architectures even when their weights themselves are not.** The bridge between models may not have to exist in parameter space. It may exist in representation space. And once that bridge has taught a sufficiently small student, the original teacher may no longer need to be there at all. --- ## Release Summary **MiniMax H3 Semantic Bridge v1.0** Standalone distilled semantic conditioning adapter for MiniMax H3. **Release includes:** * ComfyUI custom node * distilled Semantic Bridge `.safetensors` **Release does not require:** * SenseNova * the experimental Full Bridge * a second multimodal model at inference **Recommended starting configuration:** ```text alpha = 0.10 magnitude_match = per_token ``` **Primary experimental targets:** ```text complex composition spatial relationships anatomy counting prompt following text materials lighting reflection transparency occlusion ``` **Status:** Experimental / Research Release. **Supported path:** MiniMax H3 FL2VA / standard text-conditioned generation. **Not supported in v1:** Ref2VA / reference-conditioned generation, particularly reference-audio singing and lip-sync.