Open-Source Text-to-Image Models Trained End-to-End on Domestic AI Chips: Practical Evaluation Observations
This article examines open-source text-to-image models whose full pipeline—data processing, training, validation, inference, and deployment—runs on domestically developed AI chips. It explains why the technical value extends beyond image quality, outlines five practical user evaluation areas, discusses the engineering significance and migration risks of end-to-end training, and proposes a staged evaluation and deployment checklist covering semantics, complex instructions, professional scenarios, performance, cost, compliance, and ecosystem completeness.
1. The Core Value Goes Beyond “Generating Images”
From a functional perspective, open-source models trained end-to-end on domestic AI chips are typically text-to-image generation models. Users can enter Chinese or English prompts to generate realistic images, concept illustrations, promotional posters, product sketches, scene designs, and other visual content.
If the only thing observed is the result of “input a sentence, output an image,” it is easy to classify such a model alongside other text-to-image systems. However, the more important question is not limited to the visual quality of a single image. It is whether the complete technical pipeline can run as a closed loop within a domestic software and hardware environment.
Traditional model development usually involves multiple stages:
- Data cleaning and annotation depend on one computing environment.
- Model pre-training and fine-tuning depend on another set of acceleration hardware.
- Model conversion, inference optimization, and service deployment require another round of adaptation.
- Final launch may still face unsupported operators, precision inconsistencies, performance degradation, and other issues.
If a model completes data processing, training, validation, inference, and deployment on domestic AI infrastructure, it is more than a model that “can run on domestic devices.” It is a comprehensive validation of the domestic chip programming model, operator libraries, compiler toolchain, distributed training capability, and inference runtime.
Therefore, when evaluating this type of model, the question should not be only “do the images look good?” Additional questions include:
- Is Chinese semantic understanding accurate?
- Can complex prompts be executed consistently?
- Is text rendering clear?
- Are multi-subject relationships correct?
- How consistent are generated results?
- Is the deployment cost on domestic chips acceptable?
- Are the open-source code and model weights easy to use for secondary development?
- Can enterprises reproduce the training and inference pipeline?
2. Five Practical Experience Areas from a User Perspective
2.1 Chinese Prompt Understanding
For Chinese-speaking users, prompt understanding is the most direct entry point. Simple prompts usually contain only a subject, scene, and style, for example:
A small Jiangnan town after rain, reflections on stone-paved streets, cinematic lighting, rich detail.
What really distinguishes model capability is longer and more complex descriptions. For example, a prompt may simultaneously specify subject position, composition, light direction, color relationships, and style constraints:
In the center of the frame, a young person in a light-colored trench coat stands on an old station platform. On the left is a warm yellow lamp. In the distance, the weather is rainy and overcast. The overall image uses low-saturation colors, maintains a documentary photography style, and keeps the person’s face clear.
This type of prompt contains multiple constraints. The model needs to decompose the semantics and then map different constraints into image space. In practical use, users should focus on the following questions:
- Is the number of subjects accurate?
- Do the positional relationships between people and background match the description?
- Are spatial terms such as “left,” “distant,” and “center” correctly executed?
- Are lighting, weather, and color consistent?
- Does the style requirement cover the entire image rather than only a local area?
- Are any elements omitted from the complex description?
If the model captures only keywords such as “person” and “station” but ignores position, color tone, and lighting requirements, its ability to execute complex instructions is still limited.
2.2 Style Coverage and Aesthetic Stability
Common use cases for text-to-image models include realistic photography, commercial illustration, 2D painting, concept design, architectural sketches, and visual posters. Different styles place different demands on the model.
Realistic images require more attention to:
- Human body structure
- Hand and facial details
- Material realism
- Lighting logic
- Depth-of-field relationships
- Scene perspective
Illustration and concept design place more emphasis on:
- Degree of stylistic exaggeration
- Color coordination
- Visual storytelling
- Visual impact
- Style consistency
In practical testing, it is not enough to select one “best-looking” result. The same type of prompt should be used to generate multiple outputs in succession, and the stability of the outputs should be observed. If the style varies greatly each time, or if the subject structure changes frequently, the model is better suited to creative exploration than to direct batch production.
2.3 Complex Composition and Multi-Subject Relationships
Generating a single subject is relatively easy. The real difficulty lies in multi-subject scenes. For example:
In the foreground is a wooden table with three books of different colors on the surface. In the midground, a person is reading. In the background is a floor-to-ceiling window, and a city night view can be seen outside.
This description involves foreground, midground, and background at the same time, and it also requires spatial relationships among multiple objects. Testing can be judged from three dimensions:
First, is the quantity accurate? When three books are requested, does the model generate two or five?
Second, are the positions correct? Is the person behind the table? Is the window in the background rather than beside the main subject?
Third, is occlusion reasonable? Do the table surface, books, arms, and the person’s body follow normal occlusion logic?
Multi-subject generation capability directly affects the usability of applications such as e-commerce scene images, advertising creatives, interior design renderings, and storyboard sketches.
2.4 Text Generation Within Images
Text rendering has long been a difficult part of image generation. When a few signs, labels, or poster texts appear in an ordinary scene, the model may generate visual textures that resemble text, but it may not accurately output the specified content.
Therefore, text capability should be tested using a graded approach:
- First test a single Chinese character or a short word.
- Then test numbers, English text, and simple slogans.
- Finally test multi-line titles, complex layouts, and specified size relationships.
It is important to note that image generation models and professional layout tools have different objectives. Even if the overall image looks good, that does not mean it is suitable for directly generating a print-ready commercial poster. For scenarios with high text accuracy requirements, a post-editing workflow is usually still needed: the generated image can serve as a background or creative draft, and professional design tools can complete the text layout.
2.5 Result Consistency and Controllability
“Can generate” and “can control” are two different levels of capability.
In practical work, users often want:
- The same person to appear in multiple scenes
- The same product to maintain a consistent appearance
- The same set of images to maintain a unified color tone
- The subject to be preserved when the background is changed
- Clothing and identity features to remain unchanged when the pose is adjusted
If the model changes significantly on every generation, it is better suited to inspiration exploration than to continuous content production. During evaluation, the prompt can be fixed, multiple generations can be produced, and then changes in subject identity, composition, color, and details can be compared.
3. Technical Significance of End-to-End Training on Domestic Chips
3.1 Training Environment Adaptation Is More Complex Than Inference Adaptation
Running an already trained model on domestic chips mainly involves model conversion, operator adaptation, memory management, and inference performance optimization.
Training a model from scratch is more difficult. The training stage usually includes:
- Reading massive amounts of data
- Cleaning image-text data
- Tokenization and encoding
- Image preprocessing
- Forward computation
- Backpropagation
- Gradient synchronization
- Checkpoint saving
- Training state recovery
- Multi-node task scheduling
- Evaluation and log monitoring
A compatibility issue in any of these steps may affect training stability. Especially in large-scale parallel training, communication efficiency, memory or VRAM management, operator precision, and fault recovery capability all directly affect overall efficiency.
3.2 A Closed Loop Helps Reduce Migration Risk
If a model is trained only in another hardware environment and later migrated to domestic chips, common problems include:
- Some operators have no corresponding implementation.
- Outputs differ under different precision modes.
- The compiler cannot effectively fuse the computation graph.
- Dynamic inputs cause performance fluctuations.
- Precision loss occurs after model weight conversion.
- Training and inference results are inconsistent.
Completing the full pipeline on the same type of domestic software and hardware stack allows these problems to be discovered earlier and allows hardware characteristics to be incorporated into model architecture, training strategy, and inference optimization design. In other words, this is not simply “swapping a chip.” It is co-design around the computing infrastructure.
3.3 Impact on the Open-Source Ecosystem
The value of an open-source model lies not only in open weights but also in whether developers can understand, run, and modify the entire system.
A relatively complete open-source release usually includes:
- Model architecture documentation
- Data processing workflow
- Training configuration examples
- Inference invocation methods
- Weight loading instructions
- Dependency and environment requirements
- Evaluation methods
- Common troubleshooting suggestions
- License and usage boundaries
For enterprise users, whether the code is clear, the documentation is complete, and the dependencies are easy to build is often more important than a single generation result. Enterprises care about whether the model can be integrated into existing systems and whether it can be fine-tuned, quantized, pruned, or deployed as a service according to business requirements.
4. Designing an Objective Evaluation Plan
Stage 1: Basic Semantic Tests
Prepare a set of short prompts covering people, animals, buildings, natural environments, and product objects, and observe whether the model can accurately generate the main subject.
This stage does not pursue complex images. The focus is to confirm the model’s basic vocabulary understanding and image generation stability.
Stage 2: Complex Instruction Tests
Combine subject, action, position, style, lighting, and color in the same prompt, and focus on whether the model omits conditions.
It is recommended to generate multiple results for each prompt rather than looking at only one output. This helps distinguish “accidentally correct” from “stable instruction understanding.”
Stage 3: Professional Scenario Tests
Select test sets according to target users. For example:
- Designers focus on sketches and composition.
- Content teams focus on consistency between people and scenes.
- E-commerce teams focus on product appearance and background replacement.
- Game teams focus on character design and concept art.
- Educational users focus on illustrated explanations and material generation.
Evaluation should be based on actual tasks rather than only visual impact.
Stage 4: Deployment and Performance Tests
In a domestic chip environment, key records should include:
- Latency for generating a single image
- Throughput under concurrent requests
- Memory usage
- Stability during long-running operation
- First-load time
- Resource changes at different resolutions
- Recovery capability for abnormal tasks
Without public, unified, and reproducible test conditions, it is not appropriate to directly compare speed data across different models.
5. Engineering Issues to Watch During Deployment
5.1 Resource Requirements Are Not Determined Only by Parameter Count
Factors affecting deployment cost also include resolution, batch size, sampling steps, caching strategy, precision mode, and concurrency. A model with fewer parameters may still create significant resource pressure in high-resolution and high-concurrency scenarios.
5.2 Generation Quality Requires Post-Processing
Real-world business workflows usually do not directly use the first image generated by the model. Images are typically selected, cropped, repaired, upscaled, cut out, and laid out. A reasonable engineering solution should treat the image generation model as one part of the content production chain, not as a complete replacement for all design tools.
5.3 Data Compliance and Content Safety Cannot Be Ignored
During enterprise deployment, attention must be paid to training data provenance, copyright of generated content, portrait rights, sensitive information, and filtering of inappropriate content. Open source does not mean unconditional use in all commercial scenarios. License terms and internal review processes should be checked carefully before actual use.
6. Overall Judgment: A Foundation Capability, Not a Single Product
From a practical perspective, the value of open-source image generation models trained end-to-end on domestic chips is mainly reflected at three levels.
First, they validate the feasibility of a domestic AI software and hardware stack carrying complex generative model training tasks.
Second, they provide developers with a technical foundation that can be studied, modified, and deployed, helping to build industry-oriented image generation applications.
Third, they push evaluation standards from “whether a single image looks good” toward semantic understanding, complex instruction execution, output stability, engineering efficiency, and ecosystem completeness.
For ordinary users, the most important considerations are prompt understanding, image quality, and text generation results. For developers, code maintainability, model extensibility, and deployment difficulty deserve more attention. For enterprises, it is necessary to comprehensively evaluate data compliance, resource cost, service stability, and business closed-loop capability.
Therefore, judging whether this type of model is truly “usable” should not rely only on demo samples or promotional performance descriptions. A more reasonable approach is to build a complete test system covering quality, stability, cost, compatibility, and security, and then validate it against specific business scenarios.
