Training Text-to-Image Models on Homegrown AI Chips: Technical Claims and Deployment Considerations

    An open-source text-to-image model claims to be trained end to end on homegrown AI chips and a self-developed software stack. This article separates official claims from items that require verification, reviews data, training, and inference pipeline changes, summarizes reported capability boundaries, and offers practical guidance for developers evaluating deployment, memory planning, and fine-tuning.

    Introduction: The Challenge of Self-Reliance in Training

    Large model training has long depended on imported high-end accelerators. This creates two kinds of pressure: relatively high purchase and rental costs, and supply-chain uncertainty. The industry is therefore asking whether training can be completed independently on a homegrown software and hardware stack and produce results comparable to mainstream models.

    A text-to-image model recently open-sourced by a domestic team and a cloud service provider offers a positive answer. The publisher says the model runs its entire workflow—from data cleaning and pretraining to inference deployment—on homegrown AI chips and a self-developed software framework. The publisher also claims that its performance reaches the level of mainstream commercial models. At present, this claim comes mainly from official materials. This article treats it as a claim pending verification and clarifies what can be confirmed and what readers need to verify themselves.

    1. Model Positioning: The Training Pipeline Matters More Than Generation Quality

    Functionally, the model has the common capabilities of a text-to-image model:

    • Understanding of Chinese and English prompts, with support for longer semantic combinations.
    • Multiple visual styles, including realistic photography, children’s illustration, UI sketches, and 3D rendering.
    • Can be integrated as a visual generation component in multimodal systems.

    Evaluating only generation quality would miss the main difference in this work. The common path for most teams is to complete training on imported GPUs and then adapt the model to homegrown chips for inference. That solves self-reliance only at the deployment stage; training still depends on imported hardware. The key point of this model is replacing training compute with homegrown AI chips while claiming no obvious decline in training efficiency or model quality. This requires public training curves and comparative experiments for support, and the current release materials do not provide them.

    2. Three Layers of Changes in the Training Pipeline

    Moving training to another class of chips is not just a matter of recompiling code. The software ecosystem, parallelism strategy, and hardware characteristics all need adjustment. According to the publisher, the changes fall into three layers.

    2.1 Data Layer: Reducing Data Copies Between CPU and Accelerators

    Data preprocessing includes image decoding, cropping, deduplication, and annotation. The publisher mentions that companion acceleration libraries for the homegrown chips optimize image encoding and decoding, and that a distributed file system improves read throughput. The publisher also mentions using unified memory addressing to reduce I/O bottlenecks. But “unified memory addressing” is only an umbrella term. It could mean a unified address space (such as UVA), zero-copy, pinned memory, or asynchronous data pipelines. These mechanisms have different applicability conditions. Evaluation should confirm the specific implementation and how it behaves on the target hardware and driver versions.

    2.2 Training Layer: Communication and Memory Adaptation

    When training diffusion models with tens of billions of parameters, tensor parallelism and pipeline parallelism introduce substantial communication overhead. The publisher says the team performed low-level tuning for the homegrown chips’ communication topology and used a ring AllReduce algorithm to synchronize gradients across multiple cards. The name, version, and topology conditions of the communication library all affect results and should be recorded together.

    The publisher also mentions dynamically adjusting batch size using large memory to avoid training interruptions caused by out-of-memory errors. Mixed-precision training (FP16 or BF16) is common industry practice. The numerical stability of low-precision training is generally maintained through gradient clipping, loss scaling, and gradient accumulation. The publisher mentions gradient clipping but does not describe the specific settings for loss scaling and gradient accumulation.

    2.3 Inference Layer: Operator Fusion and Quantization

    At the deployment stage, the publisher describes using a homegrown inference engine for operator fusion and quantization compression, and writing custom operator kernels for the diffusion model’s Transformer blocks to reduce branch overhead in general-purpose compute libraries. The publisher claims that, on homegrown chips, the latency for generating a single 512x512 image on one card is under 2 seconds. This figure lacks a measurement methodology. Latency depends on the hardware model, batch size, sampling steps, compute precision, and inference engine version. Without these conditions, the latency number cannot be used for comparison and can only be treated as the publisher’s measured claim.

    3. Capability Boundaries: Observations Provided by the Publisher

    Based on multiple rounds of testing, the publisher made qualitative assessments across several dimensions. The table below summarizes these conclusions; it is not an independent evaluation result.

    Dimension Publisher’s assessment Publisher’s example
    Chinese semantics Fairly good; some ability to reproduce the imagery of idioms and classical poetry Ink-wash style output based on the mood of a classical poem
    Multi-object spatial relationships Fairly good; can handle positional relations such as “A is to the left of B” A corgi wearing headphones sitting on a sofa
    Text rendering Moderate; short words are relatively accurate, while long sentences occasionally have missing characters A birthday card containing “Happy Birthday”; occasional capitalization errors in the first letter
    Lighting and physics Barely passing; specular reflection and translucent materials still show deviations Position and saturation of rainbow light spots refracted through a glass

    The publisher also gives two examples. The first is a children’s science illustration: the model can correctly arrange the orbital order of the eight planets and distinguish their sizes and colors. The second is a sci-fi poster: the model can simulate volumetric light and dust effects, but biological skin texture details are slightly weaker than those of international closed-source models. These examples show the model’s tendencies, but the sample size is small and cannot represent overall performance.

    To judge whether the model fits a business use case, teams need to build their own prompt sets and record human scoring criteria, comparison baselines, random seeds, and failure cases.

    4. Practical Guidance for Developers

    First, prompt formatting. The publisher recommends using short, separated sentences for precise counts (such as “five cats”) or negation (such as “no red”), avoiding semantic dilution caused by long subordinate clauses. This suggestion is worth validating on your own data rather than adopting directly.

    Second, memory planning. The publisher gives a minimum memory requirement of 40 GB for FP16 loading. This figure needs additional conditions: input resolution, batch size, and whether additional modules such as ControlNet are stacked. Additional modules significantly increase memory usage. If using a homegrown compute platform, the publisher recommends choosing instances that support heterogeneous computing and using model parallelism instead of data parallelism to reduce per-card pressure. Before selecting an instance, verify the actual memory specifications.

    Third, style fine-tuning. To generate images in a consistent style, such as e-commerce white-background images, the publisher recommends lightweight fine-tuning with LoRA and says that about 100 high-quality samples and 500 iterations can noticeably change the output style. The sample count and iteration steps depend on the complexity of the target style and the learning rate setting; validation set results should be the basis for judgment.

    5. Conclusion: Possibility Demonstrated, Conclusions Still Need More Evidence

    This case shows that, under specific configurations, homegrown AI chips may be able to complete large-scale diffusion model training. This is more concrete than the old impression that such chips can only handle inference, not training. But a single open-source project is not enough to prove that the homegrown training stack is mature. Readers need to pay attention to three questions: whether training scale and duration are disclosed; whether comparisons with baseline models use the same evaluation set; and whether communication library, driver, and framework versions are reproducible.

    As software ecosystems such as unified communication libraries and automatic differentiation frameworks gradually improve, from-scratch training on homegrown platforms may increase. Whether it becomes widespread depends on whether more teams can reproduce such results.

    For teams planning to evaluate this model, the recommendation is to first run inference on their own hardware, record latency and memory data, and then decide whether to invest in training or fine-tuning. The model’s specific version, technical report, and evaluation data should be based on the official release page.