DeepSeek in the App Store | Chinese AI Ranks First – OrcaCore

Just weeks ago, DeepSeek, a Chinese AI startup, unveiled its chatbot application. Despite being offered free of charge, it presents a formidable challenge to leading models from OpenAI. The app has swiftly ascended to the top spot on the App Store. This article from OrcaCore delves into the intriguing aspects of DeepSeek in the App Store.

DeepSeek in the App Store has achieved a remarkable feat, surpassing ChatGPT to become the most downloaded free app on the App Store.

The chatbot is powered by the DeepSeek-V3 model, which the developers proudly proclaim as "the number one open-source model and rivals the most advanced closed-source models in the world." Since its release in January, the app has garnered substantial popularity among users.

DeepSeek app tops the App Store

AI models like ChatGPT and DeepSeek necessitate high-performance chips, such as Nvidia’s H100, for training. Since 2021, the US government has broadened the scope of its export bans on these chips to China.

Due to these sanctions, China is restricted from acquiring the H100 and instead imports the H800, which has a reduced data transfer rate. DeepSeek researchers have confirmed that they utilized Nvidia’s H800 chips to train the DeepSeek-V3 model, with the entire process costing less than $6 million.

Despite the hardware constraints faced by the DeepSeek startup, its app has managed to outpace ChatGPT in the App Store. This development has caused concern among major American companies, leading to a decline in futures trading in the US stock index. Conversely, the news of DeepSeek in the App Store‘s success has boosted the shares of Chinese technology companies associated with DeepSeek, such as Iflytek.

Interestingly, despite having fewer financial resources and hardware, DeepSeek recently unveiled the open-source R1 model, which outperformed OpenAI’s o1 reasoning model in certain benchmarks. Furthermore, the costs associated with this model are reportedly 95% lower than those of the OpenAI model.

It remains to be seen how American companies will respond to this Chinese startup and whether they will adjust the pricing strategies of their models.

DeepSeek removed from App Store in Italy

The Italian data protection authority has blocked DeepSeek in the app store due to a lack of information about its use of personal data.

DeepSeek launched a free AI assistant that it claims uses less data and costs much less than its competitors. The app had overtaken ChatGPT in the Apple App Store by Monday, causing concern among investors in the tech stock market.

Pasquale Stanzione, head of the Italian data protection authority, said: "The news of the removal of the app was published a few hours ago, but I cannot say whether this action was the result of our investigation or not." He added: "The authority will launch an in-depth investigation to check whether DeepSeek complies with the European Union’s General Data Protection Regulation (GDPR)."

The Italian watchdog, Garante, said it would investigate what personal data is collected from users, where it comes from, for what purposes it is used, on what legal basis it is processed and whether it is stored in China.

DeepSeek and its affiliates have been given 20 days to respond to the questions.

Stanzione also stressed that the body is seeking guarantees to protect minors, prevent algorithmic bias and prevent electoral interference.

Italy has been active in the field of AI monitoring before, and two years ago temporarily blocked ChatGPT for possible breaches of EU privacy rules.

Also, you may like to read the following articles:

What is DeepSeek AI? Introducing ChatGPT’s Powerful and Free Competitor

DeepSeek vs ChatGPT | Best Comparing 2 AI Giants

Free ChatGPT Alternatives

Alternative Solutions and Elaborations

The article highlights the challenges DeepSeek faces due to US sanctions limiting access to cutting-edge chips like Nvidia’s H100. While DeepSeek successfully trained its model on H800 chips, it raises the question: what other strategies could AI companies employ to overcome hardware limitations and maintain competitiveness? Here are two potential approaches:

1. Federated Learning and Distributed Training

Explanation:

Federated learning and advanced distributed training techniques offer a path to train powerful AI models without relying solely on massive, centralized compute infrastructure. Federated learning allows training to occur directly on user devices or edge servers, with only model updates being aggregated on a central server. This approach reduces the need for expensive hardware in a single location and also improves data privacy. Distributed training involves splitting the training workload across multiple machines, potentially leveraging a combination of readily available hardware, even if individually less powerful than H100s.

Benefits:

• Reduced Hardware Dependence: By distributing the training process, the reliance on a few high-end chips is minimized.
• Improved Data Privacy: Federated learning keeps data on user devices, enhancing privacy and security.
• Scalability: Distributed training allows for scaling the training process across a larger pool of resources.
• Cost-Effectiveness: Utilizing existing or more affordable hardware can significantly reduce training costs.

Code Example (Conceptual – Illustrating Federated Averaging):

This is a simplified example to illustrate the concept. Real-world federated learning involves much more complex infrastructure and security measures.

import numpy as np

# Simulate local model updates on different devices
def local_update(data, model):
  """Simulates a local model update on a device."""
  # Simplified: add some random noise to the model based on local data
  noise = np.random.normal(0, 0.1, size=len(model))
  updated_model = model + noise
  return updated_model

# Federated averaging
def federated_averaging(models):
  """Averages model updates from different devices."""
  num_models = len(models)
  averaged_model = np.mean(models, axis=0)
  return averaged_model

# Example usage
# Initialize a global model
global_model = np.array([0.1, 0.2, 0.3])

# Simulate local data and model updates from 3 devices
local_data = [np.random.rand(10), np.random.rand(12), np.random.rand(8)] # Different data sizes
local_models = [local_update(data, global_model) for data in local_data]

# Aggregate the local models using federated averaging
new_global_model = federated_averaging(local_models)

print("Original Global Model:", global_model)
print("Updated Global Model:", new_global_model)

Explanation of Code:

1. local_update(data, model): This function simulates the process of training a model on a local device with its own data. In this simplified example, it adds random noise to the model parameters. In a real scenario, this would involve training the model on the local data using an optimization algorithm (like gradient descent).

2. federated_averaging(models): This function takes a list of model updates from different devices and averages them to create a new global model. This is the core of the federated averaging algorithm.

3. The example initializes a global_model and simulates updates from three devices with different amounts of data. It then uses federated_averaging to combine these updates into a new global_model.

This code demonstrates the fundamental principle of federated learning: distributing training across multiple devices and aggregating the results to improve the global model.

2. Algorithmic Optimization and Model Compression

Explanation:

Instead of focusing solely on hardware, AI companies can invest heavily in algorithmic optimization and model compression techniques. This involves developing more efficient algorithms that require less computational power and memory. Model compression techniques, such as quantization, pruning, and knowledge distillation, can significantly reduce the size and complexity of AI models without sacrificing accuracy. This allows models to run effectively on less powerful hardware. Quantization reduces the precision of the model’s weights, pruning removes unnecessary connections, and knowledge distillation trains a smaller "student" model to mimic the behavior of a larger "teacher" model.

Benefits:

• Reduced Computational Requirements: Optimized algorithms and compressed models require less processing power.
• Lower Memory Footprint: Smaller models can be deployed on devices with limited memory.
• Faster Inference Speed: Compressed models can execute more quickly, improving the user experience.
• Hardware Agnostic: Algorithmic improvements benefit performance across a range of hardware platforms.

Code Example (Illustrating Quantization):

import numpy as np

def quantize_model(model, num_bits=8):
  """Quantizes a model to a specified number of bits."""
  # Determine the range of the model's weights
  min_val = np.min(model)
  max_val = np.max(model)

  # Calculate the quantization scale and zero point
  scale = (max_val - min_val) / (2**num_bits - 1)
  zero_point = -min_val / scale

  # Quantize the model
  quantized_model = np.round(model / scale + zero_point)
  quantized_model = np.clip(quantized_model, 0, 2**num_bits - 1) # Ensure values are within the range
  quantized_model = quantized_model.astype(np.uint8) # Store as integers

  return quantized_model, scale, zero_point

def dequantize_model(quantized_model, scale, zero_point):
  """Dequantizes a quantized model."""
  dequantized_model = (quantized_model - zero_point) * scale
  return dequantized_model

# Example usage
# Create a sample model (weights)
model = np.array([0.1, 0.5, -0.2, 0.8, -0.9])

# Quantize the model to 8 bits
quantized_model, scale, zero_point = quantize_model(model, num_bits=8)

# Dequantize the model
dequantized_model = dequantize_model(quantized_model, scale, zero_point)

print("Original Model:", model)
print("Quantized Model:", quantized_model)
print("Dequantized Model:", dequantized_model)

Explanation of Code:

1. quantize_model(model, num_bits=8): This function takes a model (represented as a NumPy array of weights) and quantizes it to a specified number of bits (default is 8). It calculates the scale and zero point based on the range of the model’s weights. Then, it quantizes the model by mapping the floating-point values to integer values within the range of 0 to 2**num_bits – 1. The np.clip function ensures that the quantized values stay within this range. Finally, the quantized values are stored as unsigned 8-bit integers (np.uint8).

2. dequantize_model(quantized_model, scale, zero_point): This function takes a quantized model, the scale, and the zero point and dequantizes the model by mapping the integer values back to floating-point values.

3. The example creates a sample model, quantizes it to 8 bits, and then dequantizes it. The output shows the original model, the quantized model (as integers), and the dequantized model (which will be an approximation of the original model due to the loss of precision during quantization).

This code demonstrates how quantization can be used to reduce the size and memory footprint of a model. The dequantized model will not be identical to the original, demonstrating the trade-off between model size and accuracy. The impact of DeepSeek in the App Store is a reminder that innovation can overcome obstacles.