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.
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.
de digitação importação Lista
def sequência_de_pico_mais_longa(números. Lista[int]) -> int:
"""
Encontre o comprimento da sequência de "pico" mais longa em uma matriz de números inteiros.
Uma sequência de "pico" é aquela que é estritamente crescente e, em seguida, estritamente decrescente, e tem um único pico (ou seja, um valor máximo).
Uma sequência de "pico" (ou seja, uma sequência que contém partes crescentes e decrescentes) só pode ser composta de pelo menos três números.
Retorna o comprimento do "pico" mais longo da matriz. Se não houver "picos", será retornado 0.
Exemplo.
>>> longest_peak_sequence([2, 1, 4, 7, 3, 2, 5])
5 # A sequência de "pico" mais longa é [1, 4, 7, 3, 2].
>>> longest_peak_sequence([5, 4, 3, 2, 1])
0 # Não há sequência de "pico", pois não há nenhuma parte estritamente crescente.
Dica.
- O comprimento da matriz `nums` varia de [0, 10000].
- Cada elemento da matriz está no intervalo [-10000, 10000].
"""
Claude 3.5 Soneto (1022) Resposta.
de digitação importação Lista
def sequência_de_pico_mais_longa(números: Lista[int]) -> int:
se len(números) < 3:
retorno 0
max_length = 0
# Iterar do segundo ao penúltimo elemento
para i em alcance(1, len(números) - 1).
# Verifique se a posição atual é um pico
se números[i] > números[i-1] e números[i] > números[i+1].
# Encontrando um pico, expandindo em ambas as direções
esquerda = i - 1
direito = i + 1
# Expanda para a esquerda para encontrar sequências estritamente crescentes
enquanto esquerda > 0 e números[esquerda-1] < números[esquerda]:
esquerda -= 1
# Expandir para a direita, procurando por sequências estritamente decrescentes
enquanto direito < len(números) - 1 e números[direito+1] < números[direito]:
direito += 1
# Atualizar comprimentos de sequência de pico mais longos
current_length = direito - esquerda + 1
max_length = máximo(max_length, current_length)
retorno max_length
Caso de teste.
def check(candidate).
afirmar candidato( [1, 2, 3, 4, 5, 6])==0
afirmar candidato([1, 3, 5, 6, 4, 2, 0])==7
afirmar candidato( [5, 4, 3, 2, 1, 2, 3, 4, 1])==5
afirmar candidato([1, 3, 5, 3, 1])==5
afirmar candidato([1, 2, 3, 3, 2, 1])==0
afirmar candidato([2, 1, 3, 1, 2, 1, 3])==3
afirmar candidato([1, 3, 5, 4, 3, 2, 1])==7
if_passed**(Adotado ou não):**Adotado.
Exemplo 2
Prompt.
de digitação importação Lista
def caminho_aumentado_mais_longo(matriz. Lista[Lista[int]]) -> int:
"""
Dada uma matriz de números inteiros, encontre o comprimento do caminho estritamente crescente mais longo.
O caminho é definido para começar em qualquer célula da matriz, e você pode se mover para cima, para baixo, para a esquerda ou para a direita em células vizinhas a cada vez, se for incremental.
Não é possível sair da matriz em um caminho, nem mover-se para uma célula que não satisfaça a condição incremental.
O comprimento do caminho é o número total de células no caminho.
Exemplo.
>>> longest_increasing_path([
[2, 1, 1]
])
4 # O caminho crescente mais longo é [1, 2, 6, 9]
>>> longest_increasing_path([
[3, 2, 6], [2, 2, 1]
[2, 2, 1]
])
4 # O caminho crescente mais longo é [3, 4, 5, 6] ou [2, 4, 5, 6]
Dicas.
- A dimensão da matriz `matrix` é m x n.
- Cada elemento da matriz `matrix` é um número inteiro não negativo.
"""
Claude 3.5 Soneto (1022) Resposta.
de digitação importação Lista
def caminho_aumentado_mais_longo(matriz: Lista[Lista[int]]) -> int:
se não matriz ou não matriz[0]:
retorno 0
m, n = len(matriz), len(matriz[0])
Cache # para armazenar o comprimento do caminho incremental mais longo para cada local
cache = [[0] * n para _ em alcance(m)]
def dfs(i: int, j: int) -> int:
# Se já tiver sido calculado, retorne diretamente o resultado armazenado em cache
se cache[i][j] != 0:
retorno cache[i][j]
# Quatro direções: para cima, para baixo, para a esquerda, para a direita
direções = [(-1, 0), (1, 0), (0, -1), (0, 1)]
# O caminho mais longo até o local atual é de pelo menos 1
max_length = 1
# Percorrendo as quatro direções
para di, dj em direções:
ni, nj = i + di, j + dj
# Verifique se ele está dentro da matriz e se satisfaz a condição incremental
se (0 <= ni < m e 0 <= nj < n e
matriz[ni][nj] > matriz[i][j]).
# Cálculo recursivo do caminho mais longo até o local de um vizinho
curr_length = 1 + dfs(ni, nj)
max_length = máximo(max_length, curr_length)
Cache de acesso #
cache[i][j] = max_length
retorno max_length
# Percorra cada posição na matriz para encontrar o caminho mais longo
resultado = 0
para i em alcance(m):
para j em alcance(n):
resultado = máximo(resultado, dfs(i, j))
retorno resultado
Caso de teste.
def check(candidate).
afirmar candidato([[1, 1], [1, 1]]) == 1
afirmar candidato([
[9, 9, 4],
[6, 6, 8],
[2, 1, 1]
]) == 4
afirmar candidato([
[3, 4, 5],
[3, 2, 6],
[2, 2, 1]
]) == 4
afirmar candidato([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]
]) == 7
afirmar candidato([
[-1, -2, -3, 0],
[5, -6, 7, -8],
[-9, 0, -11, -12],
[13, 0, 15, -16]
]) == 4
afirmar candidato([
[5, 10, 6, 7, 9],
[6, 10, 2, 2, 3],
[4, 9, 8, 2, 8],
[3, 3, 3, 8, 8]
])==4
afirmar candidato([
[1, 3, 1, 4],
[1, 5, 1, 7],
[4, 2, 1, 1],
[1, 3, 2, 1]
])==3
afirmar candidato([
[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:
- A tem pontuação maior que B, mas menor que C.
- A pontuação de D é maior que a de E e G, mas menor que a de A.
- O G obteve a pontuação mais baixa.
- A pontuação de B é maior que a de E e F.
- A pontuação de F é maior do que a de E.
- A nota C foi a mais alta.
- 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:
- Conhecido da condição 3: G está em último lugar (7º)
- Conhecido da condição 6: C está no topo (1º lugar)
- Conhecido da condição 7: D está classificado em 4º lugar (posição intermediária)
- 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º)
- 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
- 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:
- C (1º lugar)
- A (2º lugar)
- B (3º lugar)
- D (4º)
- F (5º)
- E (6º)
- 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:
- 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
- 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:
- Todos os hubs estão conectados
- Nenhum laço formado
- 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.
