DeepSeek Is Far More Than an Open-Source Victory | BlueRun Ventures

Earlier, Yann LeCun, Meta's chief AI scientist, stated that the biggest takeaway from DeepSeek's success is the importance of keeping AI models open source so that everyone can benefit. He argued that this was not a case of China's AI "surpassing the United States," but rather "open source models defeating proprietary models."

So, is that really the case? Recently, Wang Wenyu, co-founder and CTO of PPIO (a BlueRun Ventures portfolio company) and a member of TGO Kunpeng Society, was invited to participate in the fourth episode of InfoQ's DeepSeek livestream series. During the broadcast, he had an in-depth discussion with Kevin Huo, founder and CEO of Geekbang, about the impact of open source strategies on AI companies' business models behind DeepSeek's viral rise, and the broader implications of the open source versus closed source debate.

In Wang Wenyu's view, beyond breakthroughs in model training algorithms and engineering, DeepSeek's important innovations in AI infrastructure have enabled many AI infrastructure companies to explore ways to reduce costs and improve performance. Lower inference costs will lower the barrier to large-scale AI applications. When AI inference costs drop by tenfold, hundredfold, or even thousandfold, AI applications will see explosive growth.

In today's featured article, we invited ten entrepreneurs from BlueRun Ventures portfolio companies to discuss open source models like DeepSeek R1. We believe that more perspectives lead to more comprehensive understanding, so we are also sharing Wang Wenyu's reflections on open source models with you. Below is an edited transcript of Wang Wenyu's remarks:

Let's first review why DeepSeek went viral. In the past two months, DeepSeek released two models: V3 and R1. The V3 model is benchmarked against OpenAI's strongest multimodal model 4o, while R1 is benchmarked against OpenAI's deep reasoning model o1. DeepSeek's two models not only match OpenAI in performance but even outperform it in certain scenarios—for example, on the classic question "which is larger, 3.11 or 3.9," DeepSeek answers correctly while OpenAI's model gets it wrong. Summarizing the reasons for DeepSeek's success, there are mainly three points:

1. DeepSeek's models perform exceptionally well on evaluation datasets, with both V3 and R1 scoring higher than OpenAI's corresponding models. This proves its technical capabilities are on par with OpenAI.
2. DeepSeek's costs are extremely low. From a training perspective, its paper shows total training costs of approximately $5 million, equivalent to the annual salary of a Meta executive. By comparison, OpenAI's model costs are much higher. On inference costs, DeepSeek's R1 model is only 1/30th of OpenAI's, and V3 is 1/10th of 4o's. Even after OpenAI urgently launched its O3 mini model following DeepSeek's release, costs remained higher than DeepSeek's.
3. Finally, DeepSeek's open source strategy is the real reason it garnered such attention. It not only benchmarked against OpenAI's flagship models but also "demystified" OpenAI's core technology through open source. DeepSeek demonstrated numerous innovations in its open source release, such as the Mixture-of-Experts (MoE) architecture, Multi-head Latent Attention (MLA), and the GRPO algorithm in reinforcement learning, all of which outperform the PPO algorithm used by OpenAI. Additionally, DeepSeek developed Multi-Token Prediction (MTP) to further optimize performance. These technologies not only revealed OpenAI's technical approach but also built upon it with core optimizations.

I believe the biggest reason for DeepSeek's success is not simply matching OpenAI's performance or having lower costs, but rather its public disclosure of these technologies through open source. If DeepSeek had not open sourced, it might not have attracted such widespread global attention. Open source not only makes technology more transparent but also drives technological progress across the entire industry.

Some companies focus on open source, while others choose closed source. In my view, open source for large language models differs significantly from traditional open source projects. Traditional open source is essentially a collaboration mechanism among engineers, but large language model open source is different. First, the core of large language model open source is the model weights. Second, open source content includes technical papers, training details, and some engineering code that allow developers to reproduce the model. During model development, large language models are typically dominated by a single company without collaborative mechanisms. Only after open sourcing does the community participate in inference, retraining, and fine-tuning. Therefore, the nature of large language model open source differs substantially from traditional open source, and this difference determines their development trajectories.

Starting from LLaMA's release in 2023, open source models have been catching up to closed source models. Over time, open source model performance has gradually approached that of closed source models. As of July 2024, open source model performance was already very close to closed source models, with the gap narrowing—this gap will become even smaller in the future.

DeepSeek's emergence has thrown other tech giants into anxiety. OpenAI urgently released O3 mini and announced roadmaps for GPT 4.5 and GPT 5, promising GPT 5 in 2025. Meta, which had been wavering on whether to open source LLaMA 4, confirmed it would open source in the first half of 2025 and established four "war rooms" specifically to address challenges from Chinese models. Baidu also announced that its next-generation model would be open source. On February 18, Elon Musk will release Grok 3. Now, major companies are accelerating their development, realizing the competitive pressure that open source brings.

Open source brings numerous benefits to society and developers:

First, open source can rapidly reduce inference costs. Once a model is made available to the public, numerous companies will research how to deploy and optimize it, reducing labor costs, improving model performance, and quickly driving down processing costs.

Second, open source gives developers greater flexibility. Developers can choose to deploy models on public clouds, dedicated servers, or internal networks without worrying about performance limitations or data security issues, enabling more confident usage.

Third, open source is highly "playable." Developers can use their own distinctive data for fine-tuning or retraining to create personalized models.

Fourth, community contributions cannot be overlooked. After an open source project is released, it quickly attracts large numbers of developers who use various datasets for fine-tuning or model distillation, creating models suited to different scenarios for others to choose from.

The greatest value of open source is that it democratizes technology that was previously accessible only to leading companies like OpenAI, allowing more people to participate. Open source large models drive technological democratization. As more people participate, more needs are met, and continuous iterative optimization occurs, open source projects gradually form a positive feedback loop with growing influence. The core advantage of open source projects lies not in technical barriers but in ecosystem openness and inclusivity. This openness attracts large numbers of participants, building powerful ecosystem moats. Therefore, I predict that in 2025, more and better open source models will emerge.

The success of open source projects depends on their openness and ecosystem building. The open source large models that ultimately win will be those that are extremely open and inclusive, and capable of building powerful ecosystem moats. In the end, there may only be a few open source large models remaining, perhaps just 1-2, like Linux for server operating systems or Android for mobile operating systems—because ecosystem moats cannot accommodate many players.

DeepSeek's viral rise has had a very significant impact on AI infrastructure. On January 17, NVIDIA's stock experienced its largest single-day drop of 17%. At the time, information from DeepSeek's public disclosures showed extremely small numbers of GPUs used for training and extremely low costs. This made investors realize that training large models doesn't actually require hoarding massive numbers of GPUs—this realization instantly changed market expectations for NVIDIA's future.

Beyond breakthroughs in model training algorithms and engineering, DeepSeek has also made important innovations in AI infrastructure. For example, DeepSeek uses PTX (Parallel Thread Execution, essentially GPU assembly language) directly in certain operators to improve performance. Some online articles claimed that DeepSeek bypassed CUDA, but this isn't accurate — PTX is part of the CUDA ecosystem. This fully demonstrates how DeepSeek pushed performance to the extreme. Additionally, DeepSeek made extensive use of FP8 precision floating-point numbers during training, which greatly accelerated training speed and reduced GPU requirements. This efficient training approach brings new ideas to the AI infrastructure space.

The emergence of open-source models enables many AI infrastructure companies to explore ways to reduce costs and improve performance. Take my company, PPIO — by studying open-source model weights, code, and papers, we can experiment with various inference optimization schemes, run all kinds of optimization experiments, and ultimately find lossless, effective solutions. With closed-source projects, only the model company itself can optimize performance.

Under this model, different companies choose different deployment strategies based on their needs: some prioritize high performance, using expensive GPUs with smaller batch sizes at higher prices; others prioritize low cost, using cheaper GPUs with larger batch sizes and relatively lower performance. This diversity of choices gives developers flexibility and drives competition among companies, further reducing inference costs. Closed-source companies may lack this incentive, which is one advantage of the open-source ecosystem.

Using PPIO as an example: we've launched a full-power DeepSeek API using complete parameters without INT8 quantization to ensure lossless performance. We've also introduced dedicated DeepSeek container services — users can quickly launch GPUs and deploy dedicated instances with one click, getting their own developer API endpoints. For ordinary users and low-code developers, we've integrated with multiple applications (such as Dify, FastGPT, Chatbox, CherryStudio, etc.), so users can select PPIO's API service when configuring model parameters. Recently, we also launched a referral program where new users receive 50 million tokens (use my referral code MWMLW8) — enough for developers to enjoy our API service for quite a while.

Recently, application trends around DeepSeek have been shifting. WeChat is currently running gray-scale tests to integrate DeepSeek, and Baidu Maps has launched location-based deep-thinking search. The core reason behind these applications proactively adopting DeepSeek is the dramatic drop in inference costs.

I've previously mentioned the first principles of AI inference: when the per-unit inference cost of AI demand achieves 10x/100x/1000x optimization, it triggers an explosion of AI inference applications. Lower inference costs inevitably unlock more AI application scenarios without cost concerns. From an economics perspective, the eternal rule is "Affordability is all you need." Just as in the mobile internet era, most apps were free — this attracted massive user bases, and the companies developing these apps profited through advertising models. As AI inference costs decline, more AI applications will adopt free models rather than subscription models. This model will generate revenue through users viewing ads at scale, which is what the internet should look like. I believe the era of free AI is coming. As user numbers surge and application scenarios expand, inference usage will soon surpass training. According to TIRISA Research projections, by 2026 or 2027, the inference market could reach 20 times the size of the training market. The combination of open-source technology and widespread private deployment will bring tremendous advancement to the application market.

To summarize, let me review all my points:

• DeepSeek's success stems from the combination of performance, cost, and open-source.
• The gap between open-source and closed-source is narrowing and may shrink further.
• Open-source not only accelerates AI infrastructure technology development but also drives performance improvements and cost reductions.
• When inference costs drop low enough, AI applications will enter the free era.
• Inference compute usage will far exceed training compute spending.

The following is an edited transcript of the conversation:

InfoQ: How do current mainstream open-source models perform in inference, especially on key metrics like latency, throughput, and accuracy? Compared to closed-source models, are the differences significant?

Wang Wenyu: Model performance differences don't depend entirely on whether a model is open-source or closed-source. They're more determined by the GPU selection, concurrency parameters, and inference optimization techniques used together. By concurrency parameters, I mean things like batch size. When deploying inference, you often need to find balance between batch size and performance metrics (latency, throughput). If batch size is too high, total token throughput increases and per-token cost drops, but individual user experience degrades and inference speed slows. Conversely, if batch size is too low, user experience improves but total token throughput slows, causing per-token costs to rise. Closed-source models face similar trade-offs, so this isn't what distinguishes open-source from closed-source.

The real difference lies in deployment approaches and choices of inference optimization techniques. First, inference optimization techniques are critically important for model performance. This is especially true for open-source models — anyone can study them. Whether it's earlier models like LLaMA or recent ones like DeepSeek, without optimization, performance won't reach its potential. By adopting lossless optimization techniques, PD separation, speculative sampling, and parallel approaches like EP, DP, and PP pipeline parallelism, model performance can improve dramatically, with up to 10x optimization potential.

Taking DeepSeek as an example, the key to its performance optimization lies in several technical points. First is PD separation. Specifically, without PD separation, the model's Prefill phase and Decode phase take different amounts of time. After extensive Prefill operations complete, they need to queue and wait for Decode, causing inefficient inference. According to official recommendations, in this case the Prefill and Decode configuration on H800 should be around 1:10. In other words, if using one GPU for Prefill, pairing it with ten GPUs for Decode is recommended. This is the H800 recommendation; with different GPUs, our experience shows 1:10 isn't always optimal.

Second, DeepSeek employs MLA (Multi-head Latent Attention) technology, and MTP (Multi-token Prediction) is also key to performance gains. If these optimization measures aren't properly implemented, model throughput and performance suffer severely. Therefore, final model performance depends on the foundation and methods of optimization. Also, doing DP (Data Parallelism), EP (Expert Parallelism), and PP (Pipeline Parallelism) well provides considerable improvement.

For closed-source models, optimization may be limited to within the model company. But for open-source models, developers worldwide can participate in optimization, explore optimization schemes, reduce costs and thus token prices, and drive the entire industry forward.

InfoQ: We've discussed hardware and software limitations affecting open-source model inference efficiency. At the hardware level (GPUs) and software level (inference frameworks, compilers, etc.), what factors specifically constrain open-source model inference efficiency? Meanwhile, how do we resolve the tension between model scale and inference resources?

Wang Wenyu: From the hardware perspective, we need to look at GPUs and TPUs separately, and compilers are closely tied to hardware.

Taking DeepSeek as an example: to deploy the full-power DeepSeek model with 671 billion parameters, using a single H100 8-GPU configuration or single H20 8-GPU configuration, without any lossy optimization (like compression or quantization), a single machine cannot run it — two machines in parallel are needed. This is because the massive parameter count exceeds what a single machine's memory and compute speed can support. But with H200 or MI300, a single 8-GPU machine can run it. So what constrains model operation isn't whether it's open-source, but model parameter count and optimization techniques. If you preserve parameters without losing precision and leave space for context and caching, you do need stronger compute to support it.

However, some scenarios are better suited to specialized hardware like TPUs, whose design principles differ from GPUs. For example, Groq uses large amounts of SRAM (Static Random-Access Memory) to replace HBM (High Bandwidth Memory), which significantly increases cost but also dramatically improves throughput speed. This hardware suits scenarios where cost is less sensitive but performance requirements are extremely high — Groq-class TPUs are more appropriate. Yet the biggest problem with specialized hardware is that as models iterate rapidly (the AI field changes quickly, model architectures constantly update), hardware's fixed design may not adapt to new model architectures. For instance, if Transformer algorithms undergo major iteration in the future, it might not adapt.

I believe that for general-purpose scenarios, GPUs will remain the mainstream choice because their flexibility and generality can adapt to rapidly changing model demands. For certain specific, vertically-oriented scenarios, specialized hardware like NPUs/TPUs will gradually capture certain market share.

InfoQ: We've previously discussed hardware and software limitations affecting open-source model inference efficiency. You've accumulated substantial experience in the Infra space — could you introduce some currently mature cost optimization techniques?

Wang Wenyu: Currently, GPU-centric hardware faces three main bottlenecks: compute power, memory bandwidth, and memory capacity. Three categories of technologies address these constraints.

Lossless Acceleration Techniques

One category focuses on optimizing the computation process itself — reducing unnecessary computation and I/O to improve compute utilization. A representative example is FlashAttention, which tiles Q/K/V (query, key, value) matrices and applies mathematical optimizations to compress what originally required three loop passes into a single pass, effectively improving both compute and memory access efficiency. FlashAttention also employs operator fusion, integrating rotary positional encoding, masking, and other logic into a single kernel, further reducing unnecessary GPU memory accesses and optimizing performance. Beyond FlashAttention, PageAttention and Chunked Prefill also improve inference performance without affecting model accuracy.

Lossy Acceleration Techniques

This category trades some precision for performance gains, encompassing quantization, sparsification, KV Cache compression, and similar methods. In large model inference, the Decode phase is typically memory-bandwidth-bound, specifically in data exchange between global and shared GPU memory. Quantization and KV compression techniques significantly alleviate this I/O pressure. For instance, KV Cache commonly stores data in BF16 format at 16 bits per value. Compressing to FP8 at 8 bits per value not only reduces GPU I/O overhead during Decode but also cuts GPU memory usage and increases processing parallelism, further boosting inference performance.

System Architecture Optimization

At the system level, architectural optimization reduces wasted overhead and improves hardware resource utilization through intelligent scheduling, caching, and parallel computing. Common techniques include PD separation, speculative decoding, constrained decoding, and prefix caching. The inference process roughly divides into Prefill and Decode phases — Prefill is compute-bound, while Decode is memory-access-bound. In practice, it's difficult to address both bottlenecks simultaneously on the same hardware, so specialized optimizations have emerged accordingly. PD separation places Prefill and Decode on different machines, maximizing compute utilization through distributed processing. Speculative decoding improves Decode parallelism using draft models, effectively reducing memory access pressure. Constrained decoding and prefix caching reduce redundant computation and cut wasted token processing. Additionally, queue scheduling, prioritization strategies, and network transmission optimizations in the inference engine all contribute to performance gains. These optimization techniques are widely adopted in both academia and industry, with new research emerging continuously. There's substantial room for LLM inference cost reduction — even with identical models and hardware, optimization alone can significantly lower costs. This is the core value proposition of infrastructure companies.

InfoQ: A livestream viewer raised an interesting question — will DeepSeek's API prices go up in the future?

Wang Wenyu: There have indeed been recent reports of DeepSeek's API prices increasing threefold, but this isn't a straightforward price hike. DeepSeek clearly published its pricing strategy at launch and adjusted prices on February 8. From day one, the team stated that early pricing would follow V2 promotional rates to drive adoption, with a return to standard pricing after February 8. So this adjustment follows a pre-announced pricing strategy, not a sudden increase. DeepSeek has a strong technical team with extensive quantitative trading experience, particularly in millisecond-level latency optimization. They're highly skilled at hardware optimization, using PTX and CUDA for deep performance tuning. Their pricing reflects comprehensive cost accounting and market strategy considerations. Additionally, DeepSeek employs NSA (Native Sparse Attention) technology, which uses sparse attention algorithms to achieve an 11.6x speedup on 64k long-context inference. This demonstrates how architectural optimization can dramatically reduce inference costs. Compared to traditional Softmax Attention, techniques like Sparse Attention, Linear Attention, and Tensor Product Attention offer clear computational cost advantages during inference. DeepSeek's open-source nature also allows other companies and developers to explore alternative algorithms for further cost reduction. While official pricing may create some pressure for certain users, inference costs are likely to decrease further as technology advances and new compute solutions emerge (such as the B100 and subsequent chip releases). So rather than increasing, DeepSeek's prices will likely trend downward with technological progress and intensifying market competition.

InfoQ: PPIO's DeepSeek large model ranked first in accuracy among third-party evaluations. How did you achieve this?

Wang Wenyu: This evaluation was conducted by SuperClue, a fairly well-known independent third-party benchmarking organization. Their evaluation准入 page notes that testing uses their internal closed datasets. Some online sources suggest they have extensive data holdings, but since these datasets aren't public, we don't know their specific contents. The evaluation process has models answer questions and judges response correctness. I believe our top ranking stems from two main factors. First, our model is a true "full-power" version retaining all parameters without INT8/INT4 quantization — we run inference at original FP8 precision. FP8 provides greater dynamic range and better preserves original numerical information compared to INT8 and INT4, avoiding precision loss from quantization. Industry-wide, many companies use INT8 and lower-precision quantization because domestic GPUs lack native FP8 hardware support — this likely explains why others underperformed in the evaluation. Second, our model deployment process is extremely rigorous. Having done extensive model hosting services for our international expansion, we've developed strict commercial procedures. Before launching any model, we evaluate it against multiple datasets including proprietary internal datasets and public benchmarks like GSM8K. We also conduct human evaluation to ensure model performance and quality. We only deploy when evaluation results align with official or third-party benchmarks. Our strict standards and lossless approach yielded exceptional results on the SuperCLUE datasets.

InfoQ: Do you think the DeepSeek wave represents an inflection point for AIGC application and adoption?

Wang Wenyu: In China, DeepSeek's emergence is indeed a significant inflection point. From a market penetration perspective, beyond DeepSeek, many companies haven't truly open-sourced their core capabilities — instead using small open-source project models to attract attention and customers before promoting their closed-source large models. This strategy treats open source more as a marketing tool than genuine technology sharing. DeepSeek is the only company that has truly open-sourced its core capabilities, particularly the V3 version, which not only went open source but achieved OpenAI-comparable results. For the domestic market, DeepSeek's open source also addresses data governance concerns. Given China's strict content control requirements, many international open-source models like LLaMA produce uncontrollable outputs vulnerable to takedown. DeepSeek's open source eliminates the need for VPN circumvention, dramatically lowering barriers to adoption. Additionally, DeepSeek's costs are far below OpenAI's, making it affordable for more enterprises and driving AIGC application adoption. From a capital markets perspective, DeepSeek's success has transformed global confidence in Chinese AI technology. Previously, global capital was pessimistic about Chinese AI, believing China could only chase international leaders like OpenAI. DeepSeek's emergence proves Chinese companies can develop internationally competitive AI models — this not only elevates China's global AI standing but attracts greater overseas capital attention. This confidence boost also reflects in equity markets, particularly the overall rise in Hong Kong stocks, partly attributable to DeepSeek's positive impact. Overseas investors, especially capital from the Middle East, Singapore, and Europe, are showing increased interest in Chinese AI technology, providing domestic entrepreneurs with greater funding access. Furthermore, I believe DeepSeek's emergence not only drives technology adoption but may open a new wave of consumer-facing startup opportunities — much like the mobile internet era. I recently returned from the Bay Area, where that consumer startup window has already opened, and I believe China's will follow soon. Thus, DeepSeek may lead us into a new golden age of entrepreneurship — positive news for developers and profoundly significant for the industry's overall development.

PPIO's Wang Wenyu: AIGC Triggers Compute Demand Revolution, Edge Computing Will Profoundly Impact Audio-Video Generation

PPIO Launches New Compute Cloud Product, Slashing LLM Inference Costs by 1,000x | BlueRun Ventures Family Headlines

Multimodal DeepSeek Arrives! Yaodong Yang's Team and HKUST Release Align-DS-V, an Extended Alignment Version for Lingchu's DS-VLA | BlueRun Ventures Family Headlines