A avaliação de benchmark chinesa atualizada do Claude 3.5 Sonnet foi lançada! A capacidade de codificação excede o GPT-4o, mas o raciocínio de ordem superior não é tão bom quanto o o1

Os resultados dessa avaliação serão usados apenas para pesquisa acadêmica.

Em 22 de outubro, a Anthropic lançou oficialmente o modelo grande atualizado Claude 3.5 Sonnet, bem como o novo modelo Claude 3.5 Haiku.

Claude

De acordo com os funcionários da Anthropic, o Claude 3.5 Sonnet supera a versão anterior em todas as capacidades, com melhorias significativas de desempenho, especialmente em tarefas de codificação de corpos inteligentes e uso de ferramentas.No SWE-bench Verified, seu desempenho de codificação melhora de 33,41 TP3T para 49,01 TP3T, superando todos os modelos disponíveis publicamente, inclusive o OpenAI o1-preview.

O Anthropic também está introduzindo um novo recurso inovador: o uso do computador. Os desenvolvedores podem controlar o Claude para usar o computador da mesma forma que um humano por meio de uma API, mas o recurso está atualmente em fase experimental.

Em resposta às preocupações do público sobre o desempenho da atualização do Claude 3.5 Sonnet, em termos de raciocínio e código em cenários chineses, a SuperCLUE, uma organização profissional de avaliação terceirizada, realizou uma avaliação aprofundada da atualização do Claude 3.5 Sonnet.

ambiente de avaliação

Padrões de referência: SuperCLUE-Reasoning Chinese Higher Order Reasoning Assessment Benchmark, SuperCLUE-Code3 Chinese Code Assessment Benchmark.

Modelos de avaliação Claude 3.5 Sonnet (1022, POE último modelo instantâneo)

Configuração do Model GenerationConfig:

• Consulte o documento Instruções detalhadas do Claude: https://www.anthropic.com/news/3-5-models-and-computer-use

Episódio de revisão:

1. conjunto de revisão de raciocínio de ordem superior do SuperCLUE-Reasoning Chinese Complex Tasks. Um total de 302 questões, incluindo raciocínio em várias etapas, raciocínio numérico, cálculos de raciocínio, análise de mercado e problemas de otimização, cinco tarefas difíceis de raciocínio.

2. conjunto de avaliação de código nativo chinês SuperCLUE-Code3. versão atualizada em chinês do HumanEval, um total de 195 perguntas, incluindo 1.560 casos de teste, divididos em três categorias de nível de dificuldade: primária, intermediária e avançada.

Metodologia::

1) Raciocínio de ordem superior: para cada pergunta de raciocínio, fornecemos respostas de referência e processos de raciocínio após calibração e verificação manuais; em seguida, o modelo de árbitro avalia as respostas dos modelos candidatos de acordo com o processo de avaliação definido, os critérios de avaliação e as regras de pontuação (de 1 a 5 pontos). Os critérios de avaliação definidos incluem: conformidade com os requisitos básicos, precisão do raciocínio e razoabilidade das conclusões.

2. código SC-Code3: projetado especificamente para avaliar e aprimorar os principais recursos do Chinese Big Model na geração de código por meio de testes de unidades funcionais.

SuperCLUE-Code3: referências de proficiência em código com nível nativo chinês

Vamos começar com as conclusões

Conclusão 1: Cláudio 3.5 O Soneto (1022) tem bom desempenho em termos de capacidade de código chinês (SC-Code3). A pontuação total alcançou 84,85, 1,52 pontos a mais do que o GPT-4o-0513 que é 4,54 pontos menor que o o1-preview. Em particular, ele teve um desempenho incrivelmente bom nas tarefas de código avançado, com pontuação de 69,23, empatando com o o1-preview.

Conclusão 2: Claude 3.5 Sonnet (1022) obteve 74,54 pontos na tarefa chinesa de raciocínio de ordem superior. Próximo ao ChatGPT-4o-latest, com uma grande diferença em relação ao o1-preview (-10,73 pontos) . Entre elas, a capacidade de raciocínio em várias etapas é relativamente notável, com desempenho superior ao do ChatGPT-4o-latest.

**Conclusão 3:** Em comparação com a versão anterior Claude 3.5 Sonnet (0621). Claude 3.5 Sonnet (1022) melhorou em 4,57 pontos na tarefa de raciocínio e progresso significativo em tarefas secundárias, como raciocínio numérico e raciocínio computacional.

Resultados da avaliação

análise comparativa

Exemplo de medição de código

Exemplo 1

Prompt.

from typing import List

def longest_peak_sequence(nums: List[int]) -> int:
    """
    在一个整数数组中找出最长的"峰"序列的长度。
    所谓"峰"序列，是指先严格递增然后严格递减的序列，且峰顶（即最大值）唯一。
    至少包括三个数以上才能构成一个"峰"序列（即包含递增和递减的部分）。

    返回数组中最长"峰"序列的长度。如果没有"峰"序列，则返回0。

    示例:
    >>> longest_peak_sequence([2, 1, 4, 7, 3, 2, 5])
    5  # 最长的"峰"序列是 [1, 4, 7, 3, 2]

    >>> longest_peak_sequence([5, 4, 3, 2, 1])
    0  # 不存在"峰"序列，因为没有严格递增的部分

    提示:
    - 数组 `nums` 的长度范围为 [0, 10000]。
    - 数组中的每个元素范围为 [-10000, 10000]。
    """

Claude 3.5 Soneto (1022) Resposta.

from typing import List

def longest_peak_sequence(nums: List[int]) -> int:
    if len(nums) < 3:
        return 0

    max_length = 0

    # 从第二个元素遍历到倒数第二个元素
    for i in range(1, len(nums) - 1):
        # 检查当前位置是否是峰顶
        if nums[i] > nums[i-1] and nums[i] > nums[i+1]:
            # 找到一个峰顶，向两边扩展
            left = i - 1
            right = i + 1

            # 向左扩展，寻找严格递增序列
            while left > 0 and nums[left-1] < nums[left]:
                left -= 1

            # 向右扩展，寻找严格递减序列
            while right < len(nums) - 1 and nums[right+1] < nums[right]:
                right += 1

            # 更新最长峰序列长度
            current_length = right - left + 1
            max_length = max(max_length, current_length)

    return max_length

Caso de teste.

def check(candidate):
    assert candidate( [1, 2, 3, 4, 5, 6])==0
    assert candidate([1, 3, 5, 6, 4, 2, 0])==7
    assert candidate( [5, 4, 3, 2, 1, 2, 3, 4, 1])==5
    assert candidate([1, 3, 5, 3, 1])==5
    assert candidate([1, 2, 3, 3, 2, 1])==0
    assert candidate([2, 1, 3, 1, 2, 1, 3])==3
    assert candidate([1, 3, 5, 4, 3, 2, 1])==7

if_passed**(Adotado ou não):**Adotado.

Exemplo 2

Prompt.

from typing import List

def longest_increasing_path(matrix: List[List[int]]) -> int:
    """
    给定一个整数矩阵，找到最长严格递增路径的长度。
    路径被定义为从矩阵中的任意单元格开始，每次可以向上、下、左、右移动到相邻的单元格上，如果递增的话。
    你不能在路径中移动到矩阵外面，也不能移动到不满足递增条件的单元格上。
    路径的长度是路径上的单元格总数。

    示例:
    >>> longest_increasing_path([
            [9, 9, 4],
            [6, 6, 8],
            [2, 1, 1]
        ])
    4  # 最长递增路径是 [1, 2, 6, 9]

    >>> longest_increasing_path([
            [3, 4, 5],
            [3, 2, 6],
            [2, 2, 1]
        ])
    4  # 最长递增路径是 [3, 4, 5, 6]或 [2, 4, 5, 6]

    提示:
    - 矩阵 `matrix` 的维度为 m x n。
    - 矩阵 `matrix` 的每个元素是一个非负整数。

    """

Claude 3.5 Soneto (1022) Resposta.

from typing import List

def longest_increasing_path(matrix: List[List[int]]) -> int:
    if not matrix or not matrix[0]:
        return 0

    m, n = len(matrix), len(matrix[0])
    # 缓存，用于存储每个位置的最长递增路径长度
    cache = [[0] * n for _ in range(m)]

    def dfs(i: int, j: int) -> int:
        # 如果已经计算过，直接返回缓存结果
        if cache[i][j] != 0:
            return cache[i][j]

        # 四个方向：上、下、左、右
        directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

        # 当前位置的最长路径至少为1
        max_length = 1

        # 遍历四个方向
        for di, dj in directions:
            ni, nj = i + di, j + dj

            # 检查是否在矩阵范围内且满足递增条件
            if (0 <= ni < m and 0 <= nj < n and 
                matrix[ni][nj] > matrix[i][j]):
                # 递归计算邻居位置的最长路径
                curr_length = 1 + dfs(ni, nj)
                max_length = max(max_length, curr_length)

        # 存入缓存
        cache[i][j] = max_length
        return max_length

    # 遍历矩阵中的每个位置，找到最长路径
    result = 0
    for i in range(m):
        for j in range(n):
            result = max(result, dfs(i, j))

    return result

Caso de teste.

def check(candidate):
    assert candidate([[1, 1], [1, 1]]) == 1
    assert candidate([
    [9, 9, 4],
    [6, 6, 8],
    [2, 1, 1]
]) == 4
    assert candidate([
    [3, 4, 5],
    [3, 2, 6],
    [2, 2, 1]
]) == 4
    assert candidate([
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 10, 11, 12],
        [13, 14, 15, 16]
]) == 7
    assert candidate([
        [-1, -2, -3, 0],
        [5, -6, 7, -8],
        [-9, 0, -11, -12],
        [13, 0, 15, -16]
]) == 4
    assert candidate([
    [5, 10, 6, 7, 9],
    [6, 10, 2, 2, 3], 
    [4, 9, 8, 2, 8],
    [3, 3, 3, 8, 8]
])==4
    assert candidate([
    [1, 3, 1, 4],
    [1, 5, 1, 7],
    [4, 2, 1, 1],
    [1, 3, 2, 1]
])==3
    assert candidate([
    [1, 9, 2, 4], 
    [9, 6, 5, 3],
])==4

if_passed(Adotado ou não):Adotado.

Exemplos de raciocínio de ordem superior

Exemplo 1: Raciocínio em várias etapas

perguntar

Uma empresa tem sete funcionários chamados A, B, C, D, E, F e G. A empresa realizou um exercício de classificação e, com base nas notas dos funcionários e nas condições a seguir, deduza a classificação exata de cada funcionário:

1. A tem pontuação maior que B, mas menor que C.
2. A pontuação de D é maior que a de E e G, mas menor que a de A.
3. O G obteve a pontuação mais baixa.
4. A pontuação de B é maior que a de E e F.
5. A pontuação de F é maior do que a de E.
6. A nota C foi a mais alta.
7. Cada funcionário tem uma pontuação diferente, com D bem no centro.

Determine a pontuação específica de cada funcionário com base nas condições acima.

Claude 3.5 Soneto (1022) responde:

Vamos extrapolar a classificação de cada funcionário por meio de uma análise lógica:

1. Conhecido da condição 3: G está em último lugar (7º)
2. Conhecido da condição 6: C está no topo (1º lugar)
3. Conhecido da condição 7: D está classificado em 4º lugar (posição intermediária)
4. Sabemos pela condição 2: D é mais alto que E e G, mas mais baixo que A. Portanto:
   • E deve ser classificado depois de D (5º ou 6º)
   • A deve ser classificado antes de D (2º ou 3º)
5. Sabemos pela condição 1: A é maior que B, mas menor que C. Combine isso com a análise anterior:
   • 2º lugar na fila A
   • B deve estar em 3º lugar no ranking
6. Sabemos pelas condições 4 e 5: B é maior que E e F, e F é maior que E. Portanto:
   • 5º lugar na linha F
   • E 6º lugar

As classificações finais são as seguintes:

1. C (1º lugar)
2. A (2º lugar)
3. B (3º lugar)
4. D (4º)
5. F (5º)
6. E (6º)
7. G (7º)

Gostaria que eu lhe mostrasse o processo de raciocínio detalhado?

Exemplo 2: Problema de otimização

perguntar

Uma cidade tem cinco grandes centros de transporte e o departamento de planejamento da cidade quer otimizar a cobertura das rotas de ônibus para garantir que cada centro seja conectado por pelo menos uma rota. Os custos de construção entre os hubs são conhecidos e o objetivo é conectar todos os hubs a um custo mínimo.

Dados:

• Custos de conectividade entre hubs (em US$ milhões)
• Hub 1 e Hub 2: US$ 100.000
• Hub 1 e Hub 3: US$ 150.000
• Hub 2 e Hub 4: US$ 200.000
• Hub 3 e Hub 4: US$ 250.000
• Hub 3 e Hub 5: US$ 300.000
• Hub 4 e Hub 5: US$ 180.000

Objetivo: determinar quais hubs devem ser conectados uns aos outros para minimizar o custo total de construção e garantir que todos os hubs estejam interconectados.

Claude 3.5 Soneto (1022) responde:

Esse é um problema de árvore de abrangência mínima que resolverei usando o algoritmo de Kruskal. Vamos analisá-lo passo a passo:

1. Primeiro, classifique todas as conexões do menor para o maior custo:
   • Hub 1-2: US$ 100.000
   • Hubs 1-3: US$ 150.000
   • Hub 4-5: US$ 180.000
   • Hubs 2-4: US$ 200.000
   • Hub 3-4: US$ 250.000
   • Hubs 3-5: US$ 300.000
2. A conexão de menor custo é selecionada para evitar a formação de um anel:
   • Selecione o Hub 1-2 (US$ 100.000)
   • Selecione o Hub 1-3 (US$ 150.000)
   • Select Hub 4-5 (US$ 180.000)
   • Select Hub 2-4 (US$ 200.000)

Programa ideal:

• Conexão do hub 1 e do hub 2
• Conexão do hub 1 e do hub 3
• Conexão do hub 4 e do hub 5
• Conexão do hub 2 e do hub 4

Custo total: 10 + 15 + 18 + 20 = $630.000

Esse programa garante que:

1. Todos os hubs estão conectados
2. Nenhum laço formado
3. Custo total de propriedade mínimo

Gostaria que eu gerasse uma visualização para mostrar essa solução?

# Participe da comunidade

Para obter mais detalhes sobre a análise do último grande modelo Claude 3.5, você pode entrar no grupo de troca SuperCLUE-Claude.