Can machine learning teams run DeepSeek models on Huawei Ascend hardware using standard PyTorch?

Yes. Through the torch_npu library and the open-source extensions published by DeepSeek and Huawei, engineers can train and serve models in PyTorch with near-zero code modifications, targeting Ascend 910B and 910C hardware natively.

How does Huawei's CANN architecture technically differ from Nvidia CUDA?

CUDA is a general-purpose SIMT (Single Instruction, Multiple Threads) parallel computing architecture. In contrast, Huawei CANN (Compute Architecture for Neural Networks) is an application-specific architecture designed strictly for deep learning, compiling neural graphs directly into 3D Cube matrix multiplication engines and bypassing general compute shader overhead.

What financial impact does this alternative compute stack have on LLM training and serving costs?

It allows enterprise AI labs and cloud data centers to deploy high-throughput compute clusters at 40% to 60% lower total cost of ownership (TCO) per processed million tokens compared to equivalent Nvidia instances on public clouds, while completely bypassing hardware delivery backlogs.

Is this technology exclusive to the Chinese domestic market or does it benefit global engineering teams?

While physical Ascend silicon is manufactured in China, the compiler toolchains, attention kernels, and architectural blueprints are published under open-source licenses. This benefits global engineers by applying downward price pressure on Western cloud GPU providers and establishing an open reference model for alternative accelerator startups (such as Tenstorrent, Groq, and Untether AI).

ARTIFICIAL INTELLIGENCE & SEMICONDUCTORS

DeepSeek Joins Hands with Huawei to Build AI Chip Software, Cutting Nvidia Reliance

Executive Thesis: Nvidia's formidable defensive moat has never resided solely in the raw silicon of its H100 or B200 GPUs, but rather in its deeply entrenched proprietary software ecosystem: CUDA, cuDNN, TensorRT, and low-level distributed communication primitives. The strategic engineering partnership between DeepSeek and Huawei to open-source specialized compilers, high-performance attention kernels, and seamless PyTorch interoperability layers tailored to Huawei Ascend NPU processors marks a defining turning point in AI hardware geopolitics. For the first time, a frontier AI research lab is co-designing low-level compilers and distributed training toolchains for non-Western silicon, establishing a viable, production-ready alternative that meaningfully erodes the global dependence on Nvidia's CUDA architecture.

For the past fifteen years, the accelerated computing and deep learning sectors have operated under a virtually unquestioned industry dogma:to train and serve frontier large language models at enterprise scale, Nvidia is the only production-grade path. This architectural reality propelled Jensen Huang's firm into one of the most valuable corporations on Earth, while simultaneously creating unprecedented market concentration and acute supply-chain vulnerabilities for global technology companies and sovereign compute initiatives alike.

Major semiconductor titans (including AMD with its ROCm initiative, Intel with its Gaudi accelerators, and Google with proprietary Cloud TPUs) repeatedly sought to challenge this monopoly by engineering silicon with matching or superior theoretical TFLOPS. Yet virtually every contender collided with the exact same invisible fortress:the proprietary software wall of CUDA. Successfully scaling a distributed training cluster across tens of thousands of accelerators rarely depends on theoretical silicon compute density alone; it hinges on millions of lines of hyper-optimized assembly kernels, sub-microsecond inter-node collective communications (NCCL), memory virtualization engines, and specialized flash-attention kernels written exclusively for Nvidia's Streaming Multiprocessor (SM) memory hierarchy.

The announcement thatDeepSeek—the AI research laboratory that disrupted Silicon Valley through its groundbreaking architectural efficiency and sparse Mixture-of-Experts (MoE) designs— has entered into an intensive co-development partnership withHuaweito release an open-source compiler toolchain engineered for theAscend 910B and 910Cprocessors shatters this foundational bottleneck, permanently altering the global AI infrastructure landscape.

🏰1. The True Moat: Why Raw Silicon Is Powerless Without the Software Stack

For software engineers and infrastructure architects outside the specialized realm of low-level compiler optimization, it is easy to conflate Nvidia's competitive moat with physical silicon fabrication. In high-performance distributed machine learning, however, physical hardware represents barely 30% of the operational equation; the remaining 70% is governed entirely by the software compilation substrate:

•

CUDA and the Kernel Moat:When a Transformer model processes Multi-head Latent Attention, RMS normalization, or SwiGLU activation passes, it does not execute generalized instruction sets. It executes custom hand-tuned C++/CUDA kernels engineered to exploit the specific SRAM register banks and shared memory architectures of each Nvidia microarchitecture generation. Executing that identical neural graph on competing silicon without an equivalent compiler collapses hardware utilization by 60% to 90%.

•

Inter-Node Collective Communications (NCCL):In clusters scaling to 10,000 or 50,000 accelerators, up to 40% of wall-clock training time is spent exchanging gradients, key-value caches, and activation tensors across high-speed fabrics. The Nvidia Collective Communications Library (NCCL) paired with NVLink and NVSwitch hardware fabric orchestrates these transfers with near-zero latency. Competing silicon vendors historically lacked enterprise-grade distributed communication libraries capable of scaling beyond a single rack.

•

Open-Source Framework Bias:Paradoxically, the open-source ML community itself reinforced Nvidia's monopoly. Deep learning frameworks like PyTorch, vLLM, DeepSpeed, and Megatron-LM prioritized CUDA optimization paths above all else. Deploying on non-CUDA accelerators historically demanded months of fragile patch management, undocumented driver debugging, and manual C++ wrapper development.

The collaborative engineering initiative between DeepSeek and Huawei directly dismantles this dependency:bypassing the need for CUDA by establishing an open-source compilation and execution layer engineered natively on top of Huawei's CANN architecture.

⚙️2. Architectural Deep Dive: Huawei CANN Meets DeepSeek's Algorithmic Innovations

Huawei's artificial intelligence computing substrate is built uponCANN (Compute Architecture for Neural Networks)and its proprietaryDaVinci Coremicroarchitecture powering the Ascend processor series. While Nvidia GPUs execute matrix math via Tensor Cores nested alongside general SIMT streaming shaders, Ascend NPUs leverage a dedicated 3D Cube compute matrix engine specifically hardwired for ultra-dense tensor multiplication.

Historically, developer adoption of CANN was constrained by the scarcity of engineers fluent in Ascend C and the relative immaturity of its profiling toolchains. DeepSeek's systems engineering expertise addresses this challenge with surgical precision:

Native Multi-head Latent Attention (MLA) Kernels:A cornerstone mathematical innovation in DeepSeek V2 and V3 models is the low-rank compression of the Key-Value (KV) cache into compact latent vectors. DeepSeek and Huawei have engineered custom Ascend C kernels that directly stream and decompress these latent representations within on-chip HBM2e/HBM3 memory without choking the PCIe host bus.

Optimized Routing for Fine-Grained Mixture of Experts (DeepSeekMoE):Sparse MoE architectures route tokens dynamically across hundreds of specialized expert sub-networks spread across thousands of compute nodes. This induces severeAll-to-Allnetwork communication overhead. The open-source toolchain leverages Huawei'sHCCS (Huawei Cache Coherence System)inter-chip interconnect—Huawei's high-speed equivalent to NVLink—paired with custom network primitives to halve inter-node token routing latencies.

JIT Open-Source Compiler with Full PyTorch Interoperability:Through the officialtorch_npuacceleration plugin, machine learning engineers can execute existing PyTorch workloads by simply toggling the target runtime device fromcudatonpu, delegating computational graph fusion and instruction scheduling to the open-source CANN backend.

💻3. Production Code Walkthrough: Transitioning from CUDA to Ascend NPU in PyTorch

To illustrate the practical developer experience of this emerging toolchain, consider how machine learning engineers interface with Huawei Ascend NPU clusters using DeepSeek's optimized runtime compared to standard Nvidia CUDA environments:

Distributed Training & Inference Pipeline: Nvidia CUDA vs. Huawei Ascend NPU

# Distributed Training & Inference Pipeline: Nvidia CUDA vs. Huawei Ascend NPU

import os
import torch

# 1. Device Dispatch and Collective Communication Backend Setup
USE_ASCEND_NPU = os.getenv("BACKEND_HARDWARE", "NPU") == "NPU"

if USE_ASCEND_NPU:
    # Import Huawei Ascend Acceleration Plugin (CANN 8.0 Integration)
    import torch_npu
    from torch_npu.contrib import transfer_to_npu
    
    device = torch.device("npu:0")
    # Huawei Collective Communication Library (NCCL equivalent)
    dist_backend = "hccl"
    print(f"[*] Initialized Huawei Ascend NPU via CANN: {torch.npu.get_device_name(0)}")
else:
    device = torch.device("cuda:0")
    dist_backend = "nccl"
    print(f"[*] Initialized Nvidia GPU via CUDA: {torch.cuda.get_device_name(0)}")

# 2. Distributed Process Group Initialization (Tensor & Expert Parallelism)
torch.distributed.init_process_group(
    backend=dist_backend,
    init_method="env://"
)

# 3. High-Performance DeepSeek MLA Attention Layer
class DeepSeekAttentionLayer(torch.nn.Module):
    def __init__(self, dim, num_heads, kv_latent_dim):
        super().__init__()
        self.dim = dim
        self.num_heads = num_heads
        self.kv_latent_dim = kv_latent_dim
        self.q_proj = torch.nn.Linear(dim, dim, bias=False)
        self.kv_compress = torch.nn.Linear(dim, kv_latent_dim, bias=False)

    def forward(self, x):
        # On Ascend NPUs, the compiler automatically fuses and schedules
        # matrix multiplication across DaVinci 3D Cube cores without manual assembly rewrites
        q = self.q_proj(x)
        compressed_kv = self.kv_compress(x)
        return torch_npu.npu_fused_attention(q, compressed_kv) if USE_ASCEND_NPU else torch.nn.functional.scaled_dot_product_attention(q, compressed_kv, compressed_kv)

Through automatic graph rewrites (transfer_to_npu) and drop-in HCCL collective communications,over 95% of existing open-source training and inference frameworks (including vLLM, SGLang, and Megatron-LM) can seamlessly transition to Ascend clusters without rewriting model architecture logic.

⚖️4. Architecture Comparison: Nvidia CUDA Stack vs. Huawei Ascend + DeepSeek Stack

The table below provides an exhaustive systems-level evaluation comparing the legacy proprietary Nvidia stack with the open-source Huawei Ascend and DeepSeek ecosystem:

Architectural Vector	Nvidia Ecosystem (H100 / B200)	Huawei Ascend + DeepSeek Stack (910B/C)
Underlying Software Substrate	CUDA, cuDNN, TensorRT (Closed proprietary runtime)	CANN 8.0 + DeepSeek Open Toolchain (Open, extensible stack)
Inter-Node Fabric	NVLink 4/5 (900 - 1800 GB/s bidirectional) + NVSwitch	HCCS (392 - 784 GB/s) + RoCE v2 400G/800G Ethernet
Collective Communications	NCCL (Nvidia Collective Communications Library)	HCCL (Huawei Collective Communication Library)
MoE Architecture Optimization	Megatron-LM, DeepSpeed (General-purpose kernel scheduling)	Co-designed custom Ascend C kernels for DeepSeekMoE & MLA
Capital Expenditure & Availability	Prohibitive ($30k - $40k per accelerator) with multi-month lead times	40% to 60% lower hardware acquisition and cloud hosting costs
Geopolitical Supply Chain Risk	Subject to unilateral US BIS export controls and licensing bans	Completely sovereign end-to-end semiconductor supply chain

💡

Frequently Asked Questions about DeepSeek, Huawei Ascend, and the Post-CUDA Era

Modern neural networks cannot operate efficiently without compilers that orchestrate matrix multiplication in on-chip SRAM and synchronize distributed communication across thousands of chips. Nvidia dominated because CUDA has refined every mathematical micro-operation over 18 years. Without a sophisticated software stack, even the fastest physical silicon yields less than half its theoretical computational capacity.

🌐5. Geopolitical Repercussions: The Reshaping of the Global Semiconductor Landscape

The engineering alliance between DeepSeek and Huawei extends far beyond commercial developer collaboration; it marks one of the most consequential geopolitical developments in modern technology history:

•

The Failure of Semiconductor Export Controls as an Innovation Brake:Unilateral export restrictions enacted by the United States Department of Commerce were explicitly designed to choke access to advanced Nvidia GPUs (such as the A100 and H100) to stall rival AI development. Rather than arresting progress, it forced the non-Western tech ecosystem to confront and solve its singular structural vulnerability: software. Compelled to maximize native silicon, engineers achieved breakthrough performance-per-watt on older fab nodes through radically superior algorithmic design and low-level kernel optimization.

•

The Demystification of the 'CUDA Network Effect':Industry analysts long asserted that CUDA's monopoly was insurmountable because millions of software developers only knew how to code in CUDA C++. However, the meteoric rise of intermediate representation compilers (such asOpenAI Triton) and PyTorch 2.x's automated graph capture proves that modern developers do not want to write low-level CUDA; they want to write high-level Python and rely on modular compilers to target arbitrary silicon backends.

•

The Emergence of a Genuine Bipolar Compute Paradigm:Global cloud infrastructure operators possess an inherent aversion to permanent single-vendor monopolies. Through this alliance, hyperscalers and private data centers gain a verified, production-grade alternative validated by frontier models that compete on equal footing with closed models from OpenAI and Google.

💡6. Strategic Takeaways for Machine Learning Architects and DevOps Leaders

For engineering directors and platform architects designing next-generation AI infrastructure in 2026, the DeepSeek-Huawei collaboration offers three indispensable architectural lessons:

Architect for Absolute Hardware Neutrality:If your machine learning pipeline is rigidly coupled to proprietary Nvidia CUDA APIs, your business remains exposed to catastrophic supply bottlenecks and arbitrary cloud GPU markups. Decouple your infrastructure using hardware-agnostic compilation layers like OpenAI Triton, PyTorchtorch.compile, and multi-backend inference runtimes (such as vLLM and SGLang).

Algorithmic Efficiency Trumps Brute Silicon Scale:DeepSeek V3 demonstrated that mathematical innovations like Multi-head Latent Attention and fine-grained expert routing allow a 671-billion-parameter model to train at a fraction of the compute cost of legacy dense models. Generational performance gains stem not from accumulating more physical chips, but from optimizing memory bandwidth transfers between storage and compute registers.

Actively Track Open CANN and Alternative Accelerator Toolchains:The open-source repositories published by DeepSeek and Huawei represent mandatory reference architectures for any platform team striving to master low-level kernel optimization and reduce token serving costs across private hardware clusters.

💡 Related AI & Infrastructure Deep Dives

🚀7. Conclusion: The Heterogeneous Future of Artificial Intelligence

The engineering alliance between DeepSeek and Huawei is far more than a localized corporate agreement; it is the catalyst accelerating the post-CUDA era in high-performance computing. For nearly two decades, the tech industry assumed that Nvidia's software moat was an impenetrable fortress that would guarantee near-total market control indefinitely.

Today, the convergence of algorithmically superior neural architectures with co-designed, open-source compilers engineered for alternative silicon proves that the future of artificial intelligence will be heterogeneous, modular, and globally distributed. For the international engineering community, this evolution is overwhelmingly positive: intensifying competitive pressure, lowering compute costs per token, and above all, restoring the freedom to innovate without requesting permission from a single silicon monopoly.

¿Te gustó este artículo?

Conectemos en mis redes sociales donde comparto más contenido, tutoriales y tips de ingeniería de software a diario.