In recent months, domestic AI computing has begun to intensively transcend a new quantitative level.
In July, the nationwide production of 100,000-carat AI superclusters was completed; at the beginning of September, the state-owned WANCA-class Intelligent Computing Center in Wuxi, a series of 2,000-channel MTT S5000 GPU smart cards were fully operational, and the demand for cluster computing was almost at full load; the state-owned cards were moving further towards WANCA and even 100,000-carat training infrastructure.
In the engine room of the National Intellectual Property Center in Wuxi
As the clusters grow, new questions arise: How much of the actual training capacity can these chips deliver?
In large-scale training, the number of cards increases, and the complexity of the system also increases. The difference in computing efficiency on a chip is constantly enlarged to tens of thousands of chips; in small-scale training, less noticeable communication is expected, and the number of nodes increases significantly; and after the training cycle is lengthened, software failures become more frequent in daily operation.
Therefore, evaluating a computing system is not only about the number of chips and single-card performance, but also about the compatibility between the calculators, communication, parallel scheduling, fault recovery and software packages.
A newly released model has caught our attention.
On 7 September, Kodak officially released Starfire X2.5. The model uses a MoE architecture with a parameter scale of 293B-A30B, focusing on improving code and intelligence capabilities, while covering more than 200 languages and maintaining excellent performance on general tasks such as language understanding, answering and reasoning.
Among them, the WANCA-scale domestic product 910B group undertook pre- and post-training of the model, online reasoning based on the domestic platform, and accompanied by multi-step speculative decoding to improve reasoning efficiency. It is worth noting that as the code and tool call capabilities increased, Starfire X2.5 also began to participate in NPU algorithm optimization, and AI began to participate in the optimization of underlying algorithms in turn.
Through this real-world large-scale model training, we can further explore several specific engineering issues facing WANCA's state-of-the-art computing: algorithm efficiency, context processing, WANCA communication and long-cycle training stability, and how feedback relationships are forming between models and underlying computing.
This is an optimised training for the X2.5, which revolves around these issues.
What is the real functioning of the microchip?
One can imagine a large model training as a super-large factory.
The chips in the microchip group are thousands of "workers"; microchip storage is the "depository" of model parameters, context and intermediate data; and communication networks are the "transportation channels" through which data is exchanged between the chips. When the scale expands to the microchip level, computing speed, microchip capacity, communication efficiency and system stability directly affect the efficiency of the entire "factory".
Reasoning and training are not the same requirements for this "factory", which is the key difference between "reasoning adaptation" and "national production training".
Reasoning on whether the adaptive main solution model can run efficiently deployed on domestic chips; complete training also involves continuous parameter updates, cross-card synchronization, numerical stability, and long-cycle failure recovery, thus raising the demands for system collaboration as a whole.
Kodak Flight Technicians summarize the core challenges of the training as follows:It's about being fast, getting off, passing smoothly, and running steadily.
I'm going to start with "It's fast".
For the factory, the number of chips determines how many "workers" there are, while the efficiency of the calculator affects how much each "worker" actually works. The core calculations, such as Attention in model training, are ultimately executed through the calculator to the chip.
It's about X2.5, and it's about X2.5.The team focused on targeted optimization around key domestic factorsTechnicians at Koda said that the efficiency of the Attention calculator has been improved more than twice as much as the basics.
A single chip is not fast enough. The other problem is "how to divide the work".
Training tasks are broken down into large computing units, and if the amount of tasks taken on by different chips is unbalanced, part of the task may be completed and the other part is still running. The larger the scale, the easier it is to amplify this waiting, eventually slowing down the entire training process.
For long sequence training, Starfire X2.5 is used.Long sequence parallel schemes combined with dynamic load balanceAccording to technical experts at Koda, the program has improved the efficiency of long-text training by more than 30%.
The second question is "get dressed".
The larger the model, the longer the context, the more data that needs to be processed and stored, whether it is trained or reasoned, the greater the "storage" pressure.
At the model structure level, the Starburst X2.5 was introduced to improve the reasoning efficiency of long-range tasks.Rare Attention Mechanisms and Cross-Level Shared Rare Attention IndicesIn addition to this, there is a significant reduction in resource spending.
The idea of scant attention is to concentrate more computation on information that really needs attention, reducing unnecessary computation; cross-level sharing indexes allow different computation layers to duplicate already established indexes, reducing repetitive expenses. Simply put, doing as little inefficient computation as possible and doing less repetitive work.
The third question is "how to pass it on".
When it comes to the microchip scale, "transmission" can also be a bottleneck. Big model training is not for every microchip, requiring continuous exchange of training data and state between different chips. The larger the cluster, the more complex the communication relationship, and once the data transmission fails, the previous computing capabilities will be consumed by waiting time.
In ultra-long sequence training, especially after the sequence is broken down into more computing units, cross-card communication will increase further.
In response to this issue, the Starfire X2.5 was introduced in addition to general communication optimization, but also to address the communication costs of ultra-long sequences.Communication compression, layered communication and parallel computingTechnicians at Koda Sentinel said that the training efficiency was increased by 10 percent.
Communication compression can reduce the amount of data that needs to be exchanged, while layered communication is used to organize data exchanges according to different levels of interconnected relationships; combined with mechanisms such as communication concealment, the goal is to minimize the cost of communication and waiting time in ultra-sequential training.
And finally, "Run steadily".
The larger the plant, the longer the operating time, and the more difficult it is to completely avoid equipment failures. What is really important for Wanka training is to be able to detect problems, isolate problems as quickly as possible, and restore the training tasks affected.
In terms of training stability, Starfire X2.5 combined with domestic chips provide unusual detection capabilities, based on the problem analysis of hundreds of thousands of training tasks, achieving mission configuration pre-training, training card automatic detection, failure task automatic weighting, automatic removal of historical fixed error reporting nodes, and terminal checkpoints for rapid recovery and cancellation of failures.
The checkpoint is the "archives" of the training process. The current state is maintained after the training runs to a certain stage, and if there is a subsequent failure, it can continue to recover from the nearest state without having to start again.
Therefore, the value of the Hanka cluster is not only determined by the number of chips, but also whether the entire training system needs to be stable and efficient in the long run.
What else can we do after we've trained the model?
Starfire X2.5 is focused on code and intelligence capabilities.
During the training phase, the model performs large-scale reinforcement learning around tasks such as mathematics, programming, smart device calls and instructions, and trains teacher models in different fields, distilling them through multi-teacher online strategies (MOPD), using trajectories generated online by student models to build training signals for different abilities, effectively integrating the advantages of multiple teacher models into a unified publishing model.
Simply put, it's about letting each "teacher" guide them and putting them together into a model. These capabilities are more intuitive in code tasks.
The disclosed tests covered tasks such as Terminal Bench, SWE Pro, SWE Verified, SWE Multilingual, NL2Repo, and SciCode. Their focus has extended to scenarios such as terminal operations, real-time code warehouse modification, multilingual software engineering, and scientific programming.
Let's take a look at some practical demonstrations.
In Web front-end generating cases, the user only needs to provide natural language requirements, and models can combine tools such as image generation to complete a complete web page, from page layout, visual design to rolling animation and interactive effects, all contained in the same task.
In the case of human-machine interaction, the model also needs to combine visual recognition with character feedback. For example, the user requests to create a web page that can interact with the cat through gestures and pixels, the model needs to complete camera calls, video stream processing, gesture recognition, and map different movements to the cat's corresponding feedback, such as approaching, tapping, comforting, and so on, while completing character animation, interaction logic, and page debugging, ultimately generating a fun interactive Web application that can run directly.
The significance of these cases is not only that the model can generate a web page, but also that the coding capabilities and intelligence capabilities are flowing together: the model first understands tasks and constraints, then breaks down complex targets into multiple steps, calls tools to execute the code, and continually modifies it based on erroneous information or performance results.
When this closed loop moves from web development to the underlying software domain, the problem of model processing goes from "can the code run correctly" to "can the code run faster and more efficiently on real hardware under the assumption of correctness".
So, when the model has this closed-loop capability of "understanding crystal decomposition and performing crystal feedback corrections", can it further engage in the underlying algorithm and software crystal optimization it relies on?
This involves NPU algorithm optimization.
Algorithm optimization itself is a high-stakes job. Engineers need to understand hardware architecture, programming interfaces, storage methods, and performance analytics tools. Once the code is running correctly, they must continue to perform performance dissections to determine the time spent primarily on computing, storage, or data transfer, which implementations do not make full use of chip capabilities, and how they should be adjusted.
In order to equip the Starfire X2.5 with these capabilities, Kodak flew in an unsupervised training phase, building a high-quality upgrade algorithm warehouse based on GitCode, building training contents that contained CANN programming specifications and typical high-performance implementation patterns, allowing the model to learn programming knowledge under the upgrade hardware system; entering the post-training phase, building large-scale verifiable algorithm efficiency optimization tasks around real development scenarios, allowing the model to directly develop design, performance analysis and iterative optimization in real NPU environments.
This process can be understood as adding a "laboratory" to the model.
The model first writes a version of the code, runs on a real chip, gets performance results, and then continues to modify according to the results. The next round of re-compilation, re-testing until a more suitable implementation is found. However, this does not mean that the model can independently complete the underlying system development without any conditions. In current practice, task objectives, initial code, hardware environments and evaluation scripts still need to be pre-set. The role of the model is to perform multi-cycle tool calls and program exploration under these conditions, improving the automation of partial arithmetic development and optimizing links.
The DSA finite particle scarcity attentional algorithm is a concrete example of this disclosure.
DSA is geared towards the long-term contextual scenario of reducing computation by focusing on the critical parts of computing. However, sparse computing will also lead to more fragmented data access, and data transfer efficiency will be a new influencer.
While providing only the basic version of the Ascend C implementation, mission description and evaluation script, the Starfire X2.5 was self-optimized multiple times on the Ascension 910B device. Technicians at Kodak Flight said that the model used about 1600 tools to explore different performance schemes, ultimately achieving 3.5 times the acceleration compared to torch_npu.
What's left of one vanka workout?
At the end of the big model training, the most intuitive product is a set of model parameters.
But from the Starfire X2.5 training, it can be seen that the value of domestic training is being extended to multiple levels: training experience can be further embedded in platform capabilities, optimization methods are migrating to different domestic hardware environments, and models themselves are starting to participate in underlying algorithm optimization. These changes have a common impact on whether the Wanka group can be integrated from the infrastructure and transformed into a training system for continuous production of model capabilities.
Big models are constantly updated, Attention, MoE, context-based and intelligent body reinforcement are constantly making new demands on algorithm performance, display bandwidth, cluster communication, parallel scheduling and fault recovery. Each full training is actually a stress test on the underlying software hardware system.
If the optimized algorithms, communication strategies and recovery mechanisms can be consolidated into the training platform, subsequent models do not have to repeat the same adaptation work. The engineering team can also put more resources into new model structures, training methods and application tasks.
This accumulated value is amplified as the number of trainings increases: temporary optimization in a project, with the opportunity to gradually transform into a platform capable of being replicated by subsequent models.
A further question is whether these capabilities can be migrated from a single hardware environment to more domestic platforms.
Different domestic AI chips differ in their computational architecture, programming interfaces, communication methods and performance analytics tools, and the migration still requires reworking of the algorithm implementation, parallel strategies and tool chains.
Therefore, further attention can be paid to how much code needs to be adjusted after replacing the hardware, to what extent both parallel strategies can be retained, and the performance after the migration. The lower the cost of migration, the less difficult the training capacity to cover more national platforms, and the easier it is for the optimization experience for individual projects to be absorbed into a replicable general method.
At the same time, the model itself began to enter the engineering cycle.
Starfire X2.5 has the capability to develop design, performance dissection and iterative optimization in real NPU environments. The DSA case mentioned above also reflects the actual effect of this "generating hydrogen functional hydrogen feedback optimization" in algorithm performance optimization.
This indicates that the model has been able to achieve continuous exploration optimization in real NPU environments through multi-cycle tools, and the boundaries of capability are further extended by code generation to actual performance optimization. As this process gradually matures, the model's involvement in underlying software hardware optimization is deepening further.
So the feedback chain is becoming clearer:National Arithmetic Training Big Models → Models acquire the ability to code and call tools → Models participate in NPU Arithmetic Optimization → Optimization experience further embedded in engineering ability → Anti-feeding follow-up model training.
This cycle affects both the current training efficiency and the subsequent iteration rate. Algorithm, communication and scheduling optimization can reduce computation and wait times, failure recovery mechanisms can improve the effective training time; verified code, performance data and optimization methods can also be further embedded into engineering assets that can be reused for subsequent training.
What is the meaning of this verse?
Returning to the company Kodak, the Starfire X2.5 demonstrates not only a model training, but a closer technical link between training, reasoning and underlying algorithmic adaptation. Completing the national algorithm VANCA training is one of the important nodes, and these links are gradually forming an interconnected technical system.
As these optimizations continue to be verified and consolidated, the system is also expected to yield a set of replicable engineering capabilities. Calculator optimization, distributed training, fault recovery, software hardware adaptation and toolchain construction can continue to serve subsequent model iterations. As the engineering system gradually matures, the cost of training, moving and deploying new models is also expected to decrease further.
Another feature of Kodak is that long-term accumulated industry scenarios such as education, healthcare, and enterprise services can continue to provide real needs and feedback. Businesses pose new problems, models evolve, and the underlying systems are continuously optimized based on training and reasoning, thus forming a cycle from application needs to model upgrades, and back to business locations.
When this cycle is steadily running, the national production training for Kodak will not just be a technical route choice, but will gradually sink into long-term engineering advantages.