为什么 Llama 3.3 70B 比 GPT-4o 和 Claude 3.5 Sonnet 更优秀

过去七天的 AI 新闻如狂风暴雨般涌来，AI 世界发生了许多重大变化。在这篇文章中，我们将深入探讨来自 Llama 3.3 70B、GPT-4o 和 Claude 3.5 Sonnet 等主要参与者的最新 AI 动态。

12 月 7 日，Meta 将发布其年度最后一个 AI 模型。而就在昨天（12 月 6 日），Meta 发布了拥有 700 亿参数的 Llama 3.3。尽管参数数量远低于 4050 亿的 Llama 3.1，其性能却不相上下。

Meta 强调，Llama 3.3 模型更高效、成本更低，可运行在标准工作站上，不仅降低运营成本，还能提供高质量的文本 AI 解决方案。

Llama 3.3 优化了多语言支持，支持八种语言：英语、德语、法语、意大利语、葡萄牙语、印地语、西班牙语和泰语。

该模型拥有 128K 的上下文长度，并支持多种工具格式。它可以与外部工具和服务集成，扩展模型的功能。

在这份逐步指南中，我们将介绍 Llama 3.3 的特点、如何本地使用 Llama 3.3，以及为什么它比 GPT-4o 和 Claude 3.5 Sonnet 更强大。

我强烈建议大家观看本文附带的视频，这将彻底改变你的聊天机器人体验，帮助你领略 Llama 3.3 的强大威力！

什么是 Llama 3.3

Llama 3.3 是 Meta AI 推出的一个多语言大规模预训练语言模型，拥有 700 亿参数。其性能可媲美 4050 亿参数的 Llama 3.1，并针对多语言对话进行了优化，支持英语、德语、法语、意大利语、葡萄牙语、印地语、西班牙语和泰语。

Llama 3.3 拥有更长的上下文窗口、多语言输入输出能力，并能集成第三方工具以扩展功能，非常适合商业和研究用途。

Llama 3.3 的关键特性

• 效率与成本：Llama 3.3 更高效、成本更低，可运行在标准工作站上，降低运营成本，同时提供高质量文本 AI 解决方案。

• 多语言支持：支持英语、德语、法语、意大利语、葡萄牙语、印地语、西班牙语和泰语，能够处理这些语言的输入输出。

• 长上下文窗口：支持 128K 上下文长度。

• 集成第三方工具：可与第三方工具和服务集成，扩展功能和应用场景。

Llama 3.3 与 Llama 3.2 的比较

与 Llama 3.2 相比，Llama 3.3 在文本任务上取得了显著性能提升。Llama 3.2 专注于轻量化模型（1B 和 3B 参数），适合边缘设备部署，以及多模态模型（11B Vision 和 90B Vision）。而 Llama 3.3 则缩小到 700 亿参数，聚焦于提高文本生成的质量。

Llama 3.3 的硬件要求

Llama 3.3 使用 Meta 定制开发的训练库、定制 GPU 集群和生产基础设施进行预训练。微调、标注和评估均在相同的生产基础设施上完成。总计耗费 3930 万 GPU 或 700 万 GPU 小时的训练资源，使用 H100–80GB (TDP 700W) 硬件。

如何在本地使用 Llama 3.3

Llama 3.3 使用与 Llama 3.1 相同的提示格式，因此 Llama 3.1 的提示可直接用于 Llama 3.3，这是迁移用户的一大优势。Llama 3.3 支持与 Llama 3.1 相同的代码解释器和工具调用功能，使模型能够利用外部工具和信息。

使用 Ollama 是运行本地语言模型最快的方法。推荐尝试 Llama 3.3 70B，它体积小巧，在大多数硬件上表现出色。

1. 先下载 Ollama

2. 打开终端，运行 ollama run llama3.3

​​​​

Llama 3.3 70B 与Claude 3.5 Sonnet 和 GPT-4o的对比

我们将对 Claude 3.5 Sonnet 和 GPT-4o 的性能进行比较，验证 Llama 3.3 70B 的表现。此次验证内容包括以下项目：

编程能力

我们使用了一些基于真实场景的复杂 Python 问题。以下是任务示例：

You are given an array nums consisting of positive integers.

Starting with score = 0, apply the following algorithm:

Choose the smallest integer of the array that is not marked. If there is a tie, choose the one with the smallest index.

Add the value of the chosen integer to score.

Mark the chosen element and its two adjacent elements if they exist.

Repeat until all the array elements are marked.

Return the score you get after applying the above algorithm.

Example 1:

Input: nums = [2,1,3,4,5,2]

Output: 7

Explanation: We mark the elements as follows:

• 1 is the smallest unmarked element, so we mark it and its two adjacent elements: [2,1,3,4,5,2].

• 2 is the smallest unmarked element, so we mark it and its left adjacent element: [2,1,3,4,5,2].

• 4 is the only remaining unmarked element, so we mark it: [2,1,3,4,5,2].

Our score is 1 + 2 + 4 = 7.

LLama 3.3

def find_score(nums):

"""

Calculate the score by applying the given algorithm.

Args:

nums (list): A list of positive integers.

Returns:

int: The calculated score.

"""

score = 0

marked = [False] * len(nums)

while False in marked:

min_val = float('inf')

min_idx = -1

Find the smallest unmarked integer

for i, num in enumerate(nums):

if not marked[i] and num < min_val:

min_val = num

min_idx = i

Add the value of the chosen integer to score

score += min_val

Mark the chosen element and its two adjacent elements if they exist

for i in range(max(0, min_idx - 1), min(len(nums), min_idx + 2)):

marked[i] = True

return score

Example usage

nums = [2, 1, 3, 4, 5, 2]

print(find_score(nums)) # Output: 7

GPT-4o

def get_score(nums):

n = len(nums)

marked = [False] * n # Array to track marked elements

score = 0

while True:

Find the smallest unmarked element

smallest_value = float('inf')

smallest_index = -1

for i in range(n):

if not marked[i] and nums[i] < smallest_value:

smallest_value = nums[i]

smallest_index = i

if smallest_index == -1: # If no unmarked elements are left, break

break

Add the value of the chosen element to the score

score += nums[smallest_index]

Mark the chosen element and its two adjacent elements

marked[smallest_index] = True

if smallest_index > 0:

marked[smallest_index - 1] = True

if smallest_index < n - 1:

marked[smallest_index + 1] = True

return score

Example usage

nums = [2, 1, 3, 4, 5, 2]

print(get_score(nums))

Claude 3.5 Sonnet

def markElements(nums):

Create a copy of the input array to track marked elements

marked = [False] * len(nums)

score = 0

while not all(marked):

Find the smallest unmarked element

min_val = float('inf')

min_index = -1

Find the smallest unmarked element with the smallest index

for i in range(len(nums)):

if not marked[i] and nums[i] < min_val:

min_val = nums[i]

min_index = i

Add the chosen element's value to score

score += nums[min_index]

Mark the chosen element

marked[min_index] = True

Mark left adjacent element if it exists

if min_index > 0:

marked[min_index - 1] = True

Mark right adjacent element if it exists

if min_index < len(nums) - 1:

marked[min_index + 1] = True

return score

Test cases

test_cases = [

[2,1,3,4,5,2], # Example from the problem statement

[1,2,3,4,5], # Consecutive increasing numbers

[5,4,3,2,1] # Consecutive decreasing numbers

]

for nums in test_cases:

print(f"Input: {nums}")

print(f"Output: {markElements(nums)}\n")

所有三个解决方案在我使用 Visual Studio Code 运行代码时都正确无误。然而，Llama 3.3 的代码虽然清晰，但使用了 while False in marked 循环，这比 while not all(marked) 更不直观。此外，它在寻找最小未标记元素时重复了逻辑，且未使用辅助函数，使得维护性较差。

GPT-4o 的代码最易读，使用了简单明了的 while True 循环和明确的中断条件，注释简洁，逻辑清晰，避免了冗余，成为在可读性和维护性方面的一个优秀选择。

Claude 3.5 Sonnet 的代码也很清晰，并使用了 not all(marked) 作为循环条件，但其风格较为冗长，并且附加的测试用例虽然有帮助，却使代码的重点不如 GPT-4o 的版本集中。

总体而言，GPT-4o 的版本是最佳选择，因为它结构清晰，注释得当，设计直截了当，在可读性、功能性和维护性之间实现了良好的平衡。

数学能力

接下来，我比较和验证数学能力，我们让参与者回答概率问题。很多人害怕进入数据科学领域，因为他们对高中和大学的代数、矩阵和组合数学感到恐惧。

Find the probability of getting exactly two tails in 5-coin flips?

LLama3.3

Step 1: Define the sample space

The sample space consists of all possible outcomes of flipping 5 coins. Each coin can land in one of two ways: Heads (H) or Tails (T). So, the sample space has 2^5 = 32 possible outcomes.

Step 2: Identify the favorable outcomes

We want to find the probability of getting exactly 2 tails. This means we need to count the number of outcomes with 2 tails and 3 heads. We can use the binomial coefficient to calculate this:

Number of ways to choose 2 tails out of 5 flips = C(5, 2) = 5 / (2 × 3!) = 10

So, there are 10 favorable outcomes with exactly 2 tails.

Step 3: Calculate the probability

The probability of getting exactly 2 tails is the number of favorable outcomes divided by the total number of possible outcomes:

P(exactly 2 tails) = Number of favorable outcomes / Total number of outcomes

= 10 / 32

= 5/16

Answer

The probability of getting exactly 2 tails in 5-coin flips is 5/16 or approximately 0.3125 (31.25%).

In mathematical notation, this can be represented as:

P(X = 2) = (5 choose 2) × (1/2)^2 × (1/2)^3 = 10/32 = 5/16

where X is the random variable representing the number of tails, and (5 choose 2) is the binomial coefficient representing the number of ways to choose 2 tails out of 5 flips.

GPT-4o

Claude 3.5 Sonnet

I'll solve this using the binomial probability formula. Here's a step-by-step mathematical approach:

First, let's define our parameters:

Total number of coin flips (n) = 5

Number of desired tails (k) = 2

Probability of getting a tail in a single flip (p) = 1/2

Probability of getting a head in a single flip (q) = 1/2

The binomial probability formula is:

P(X = k) = C(n,k) * p^k * q^(n-k)

Let's break this down:

C(n,k) is the combination formula: 5! / (2! * (5-2)!) = 5! / (2! * 3!)

This calculates how many ways we can choose 2 tails out of 5 flips

Calculating:

C(5,2) = 5! / (2! * 3!) = (5 * 4) / (2 * 1) = 10

(1/2)^2 * (1/2)^(5-2) = (1/2)^2 * (1/2)^3

(1/2)^5 = 1/32

Final calculation:

10 * (1/2)^5 = 10/32 = 5/16

Therefore, the probability of getting exactly two tails in 5 coin flips is 5/16 or approxi

所有三个模型都正确得出了概率为 5/16 的结论。

Llama 3.3 的方法不够直观，缺乏简化步骤。

Claude 3.5 Sonnet 的表达清晰，但增加了一些额外的细节，例如对正面和反面的概率计算，这对于此问题可能并非必要。

GPT-4o 的表现最出色，因为它采用了清晰且结构化的基于公式的方法，直接应用二项式系数并对公式进行了简化，表述清楚易懂，避免了不必要的复杂性。

结论：

Llama 3.3 是 Llama 系列中功能最强大的版本，开源且高度实用。通过利用其开源特性，该模型可以根据每个公司的需求进行改进。