Die aktualisierte Claude 3.5 Sonnet Chinese Benchmark Auswertung ist da! Code-Fähigkeit übertrifft GPT-4o, logisches Denken höherer Ordnung ist nicht so gut wie o1

Die Ergebnisse dieser Bewertung werden ausschließlich für die akademische Forschung verwendet.

Am 22. Oktober stellte Anthropic offiziell das aktualisierte große Modell Claude 3.5 Sonnet sowie das neue Modell Claude 3.5 Haiku vor.

Claude

Nach Angaben von Anthropic übertrifft Claude 3.5 Sonnet die Vorgängerversion in jeder Hinsicht, insbesondere bei der Codierung von intelligenten Körpern und der Nutzung von Werkzeugen.Im SWE-Bench Verified verbessert sich die Codierleistung von 33,41 TP3T auf 49,01 TP3T und übertrifft damit alle öffentlich verfügbaren Modelle, einschließlich OpenAI o1-preview.

Anthropic führt auch eine bahnbrechende neue Funktion ein: die Computernutzung. Entwickler können Claude über eine API so steuern, dass er den Computer auf die gleiche Weise wie ein Mensch benutzt, aber die Funktion befindet sich derzeit noch in der Experimentierphase.

Als Reaktion auf die öffentliche Besorgnis über die Leistung des Claude 3.5 Sonnet-Upgrades in Bezug auf Argumentation und Code in chinesischen Szenarien hat SuperCLUE, ein professionelles externes Bewertungsunternehmen, eine eingehende Bewertung des Claude 3.5 Sonnet-Upgrades durchgeführt.

Bewertungsumfeld

Referenzstandards: SuperCLUE-Reasoning Chinese Higher Order Reasoning Assessment Benchmark, SuperCLUE-Code3 Chinese Code Assessment Benchmark.

Bewertungsmodelle Claude 3.5 Sonnet (1022, POE letztes Modell Snapshot)

Modell GenerationConfig-Konfiguration:

• Siehe das Dokument Claude Detailed Instructions: https://www.anthropic.com/news/3-5-models-and-computer-use

Rückblick auf die Episode:

1. SuperCLUE-Reasoning Chinese Complex Tasks Higher Order Reasoning Review Set. Insgesamt 302 Fragen, darunter mehrstufiges Denken, numerisches Denken, logische Berechnungen, Marktanalyse und Optimierungsprobleme - fünf schwierige logische Aufgaben.

2.SuperCLUE-Code3 Chinese native code evaluation set.HumanEval's Chinese upgraded version, insgesamt 195 Fragen, darunter 1.560 Testfälle, unterteilt in primären, mittleren und fortgeschrittenen drei Kategorien von Schwierigkeitsgrad.

Methodik::

1. übergeordnete Argumentation: Für jede Argumentationsfrage stellen wir Referenzantworten und Argumentationsprozesse nach manueller Kalibrierung und Überprüfung bereit; dann bewertet das Schiedsrichtermodell die Antworten der Kandidatenmodelle gemäß dem festgelegten Bewertungsprozess, den Bewertungskriterien und den Bewertungsregeln (1-5 Punkte). Zu den festgelegten Bewertungskriterien gehören: Einhaltung der grundlegenden Anforderungen, Genauigkeit der Argumentation und Angemessenheit der Schlussfolgerungen.

2. code SC-Code3: speziell entwickelt, um die Kernfähigkeiten von Chinese Big Model bei der Codegenerierung durch funktionale Einheitstests zu bewerten und zu verbessern.

SuperCLUE-Code3: Benchmarks für die Code-Kenntnisse chinesischer Muttersprachler

Beginnen wir mit den Schlussfolgerungen

Schlussfolgerung 1: Claude 3.5 Sonnet (1022) schneidet in Bezug auf die chinesische Codefähigkeit (SC-Code3) gut ab. Die Gesamtpunktzahl erreichte 84,85, 1,52 Punkte mehr als GPT-4o-0513 das sind 4,54 Punkte weniger als o1-preview. Vor allem bei den fortgeschrittenen Code-Aufgaben schnitt es mit 69,23 Punkten erstaunlich gut ab und lag damit gleichauf mit o1-preview.

Schlussfolgerung 2: Claude 3.5 Sonnet (1022) erzielte 74,54 Punkte bei der chinesischen Aufgabe zum logischen Denken höherer Ordnung. Nahe an ChatGPT-4o-latest, mit einem großen Abstand zu o1-preview (-10,73 Punkte) . Unter ihnen ist die mehrstufige Argumentation Fähigkeit relativ hervorragend, mit einer Leistung, die die ChatGPT-4o-latest.

**Schlussfolgerung 3:** Im Vergleich zur vorherigen Version Claude 3.5 Sonnet (0621). Claude 3.5 Sonnet (1022) verbesserte sich um 4,57 Punkte bei der Argumentationsaufgabe und signifikante Fortschritte bei sekundären Aufgaben, wie z. B. Zahlenverständnis und rechnerisches Denken.

Ergebnisse der Bewertung

vergleichende Analyse

Beispiel für eine Code-Messung

Beispiel 1

Aufforderung.

von Eingabe von importieren Liste

def längste_Spitzenwert_Folge(nums. Liste[int]) -> int:
    """
    Ermitteln Sie die Länge der längsten "Spitzen"-Folge in einer Reihe von ganzen Zahlen.
    Eine "Peak"-Folge ist eine Folge, die erst streng ansteigend und dann streng absteigend ist und einen eindeutigen Peak (d. h. einen Maximalwert) hat.
    Eine "spitze" Folge (d. h. eine, die sowohl steigende als auch fallende Teile enthält) kann nur aus mindestens drei Zahlen bestehen.

    Gibt die Länge des längsten "Peaks" im Array zurück. Wenn es keine "Spitzen" gibt, wird 0 zurückgegeben.

    Beispiel.
    >>> längste_Spitzenwert_Sequenz([2, 1, 4, 7, 3, 2, 5])
    5 # Die längste "Spitzen"-Folge ist [1, 4, 7, 3, 2].

    >>> längste_Spitzenwert_Sequenz([5, 4, 3, 2, 1])
    0 # Es gibt keine "Spitzen"-Folge, da es keinen streng ansteigenden Teil gibt.

    Tipp.
    - Die Länge des Arrays "nums" reicht von [0, 10000].
    - Jedes Element des Arrays liegt im Bereich [-10000, 10000].
    """

Claude 3.5 Sonett (1022) Antwort.

von Eingabe von importieren Liste

def längste_Spitzenwert_Folge(Zahlen: Liste[int]) -> int:
    wenn len(Zahlen) < 3:
        return 0

    max_Länge = 0

    # Iterieren vom zweiten Element zum vorletzten Element
    für i in Bereich(1, len(Zahlen) - 1).
        # Prüfen Sie, ob die aktuelle Position die Spitze ist
        wenn Zahlen[i] > Zahlen[i-1] und Zahlen[i] > Zahlen[i+1].
            # Suche nach einer Spitze, Expandieren in beide Richtungen
            links = i - 1
            rechts = i + 1

            # Erweitern Sie nach links, um streng zunehmende Folgen zu finden
            während links > 0 und Zahlen[links-1] < Zahlen[links]:
                links -= 1

            # Erweitern nach rechts, Suche nach streng abnehmenden Folgen
            während rechts < len(Zahlen) - 1 und Zahlen[rechts+1] < Zahlen[rechts]:
                rechts += 1

            # Aktualisierung der längsten Peak-Sequenzlängen
            aktuelle_Länge = rechts - links + 1
            max_Länge = max(max_Länge, aktuelle_Länge)

    return max_Länge

Testfall.

def check(kandidat).
    behaupten. Kandidaten( [1, 2, 3, 4, 5, 6])==0
    behaupten. Kandidat([1, 3, 5, 6, 4, 2, 0])==7
    behaupten. Kandidaten( [5, 4, 3, 2, 1, 2, 3, 4, 1])==5
    behaupten. Kandidat([1, 3, 5, 3, 1])==5
    behaupten. Kandidat([1, 2, 3, 3, 2, 1])==0
    behaupten. Kandidat([2, 1, 3, 1, 2, 1, 3])==3
    behaupten. Kandidat([1, 3, 5, 4, 3, 2, 1])==7

wenn_bestanden**(Angenommen oder nicht):**Verabschiedet.

Beispiel 2

Aufforderung.

von Eingabe von importieren Liste

def längster_wachsender_Weg(Matrix. Liste[Liste[int]]) -> int:
    """
    Finde die Länge des längsten streng ansteigenden Pfades in einer Matrix von ganzen Zahlen.
    Der Pfad beginnt an einer beliebigen Zelle in der Matrix, und Sie können sich jedes Mal nach oben, unten, links oder rechts auf benachbarte Zellen bewegen, wenn dies inkrementell ist.
    Ein Pfad kann nicht außerhalb der Matrix verlaufen und auch nicht auf eine Zelle, die die inkrementelle Bedingung nicht erfüllt.
    Die Länge des Pfades entspricht der Gesamtzahl der Zellen im Pfad.

    Beispiel.
    >>> längster_aufsteigender_pfad([
            
            
            [2, 1, 1]
        ])
    4 # längster ansteigender Pfad ist [1, 2, 6, 9]

    >>> längster_aufsteigender_Weg([
            
            [3, 2, 6], [2, 2, 1]
            [2, 2, 1]
        ])
    4 # Der längste ansteigende Pfad ist [3, 4, 5, 6] oder [2, 4, 5, 6]

    Hinweise.
    - Die Dimension der Matrix `Matrix` ist m x n.
    - Jedes Element der Matrix `matrix` ist eine nichtnegative ganze Zahl.

    """

Claude 3.5 Sonett (1022) Antwort.

von Eingabe von importieren Liste

def längster_wachsender_Weg(Matrix: Liste[Liste[int]]) -> int:
    wenn nicht Matrix oder nicht Matrix[0]:
        return 0

    m, n = len(Matrix), len(Matrix[0])
    #-Zwischenspeicher zur Speicherung der längsten inkrementellen Pfadlänge für jeden Ort
    Cache = [[0] * n für _ in Bereich(m)]

    def dfs(i: int, j: int) -> int:
        # Wenn es bereits berechnet wurde, wird das zwischengespeicherte Ergebnis direkt zurückgegeben
        wenn Cache[i][j] != 0:
            return Cache[i][j]

        # Vier Richtungen: oben, unten, links, rechts
        Wegbeschreibung = [(-1, 0), (1, 0), (0, -1), (0, 1)]

        # Der längste Weg zum aktuellen Standort ist mindestens 1
        max_Länge = 1

        # Durchqueren der vier Richtungen
        für di, dj in Wegbeschreibung:
            ni, nj = i + di, j + dj

            # Prüfen, ob sie innerhalb der Matrix liegt und die inkrementelle Bedingung erfüllt
            wenn (0 <= ni < m und 0 <= nj < n und 
                Matrix[ni][nj] > Matrix[i][j]).
                # Rekursive Berechnung des längsten Weges zum Standort eines Nachbarn
                aktuelle_Länge = 1 + dfs(ni, nj)
                max_Länge = max(max_Länge, aktuelle_Länge)

        # Zugriffs-Cache
        Cache[i][j] = max_Länge
        return max_Länge

    # Durchlaufen Sie jede Position in der Matrix, um den längsten Weg zu finden.
    Ergebnis = 0
    für i in Bereich(m):
        für j in Bereich(n):
            Ergebnis = max(Ergebnis, dfs(i, j))

    return Ergebnis

Testfall.

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

wenn_bestanden(Angenommen oder nicht):Verabschiedet.

Beispiele für logisches Denken höherer Ordnung

Beispiel 1: Mehrstufiges Reasoning

fragen Sie

Ein Unternehmen hat sieben Angestellte mit den Namen A, B, C, D, E, F und G. Das Unternehmen hat eine Einstufung vorgenommen und auf der Grundlage der Noten der Angestellten und der folgenden Bedingungen die genaue Rangfolge der einzelnen Angestellten ermittelt:

1. A hat eine höhere Punktzahl als B, aber eine niedrigere als C.
2. D schneidet besser ab als E und G, aber schlechter als A.
3. G erhielt die niedrigste Punktzahl.
4. B hat eine höhere Punktzahl als E und F.
5. F hat eine höhere Punktzahl als E.
6. C erhielt die höchste Punktzahl.
7. Jeder Arbeitnehmer erhält unterschiedliche Noten, wobei D in der Mitte liegt.

Bitte leiten Sie die spezifische Punktzahl für jeden Arbeitnehmer auf der Grundlage der oben genannten Bedingungen ab.

Claude 3.5 Sonnet (1022) antwortet:

Lassen Sie uns die Rangfolge der einzelnen Mitarbeiter durch eine logische Analyse extrapolieren:

1. Bekannt aus Bedingung 3: G ist auf dem letzten Platz (7.)
2. Bekannt aus Bedingung 6: C ist an der Spitze (Platz 1)
3. Bekannt aus Bedingung 7: D ist auf Platz 4 (mittlere Position)
4. Wir wissen aus Bedingung 2: D ist höher als E und G, aber niedriger als A. Also:
   • E muss nach D eingestuft werden (5. oder 6.)
   • A muss vor D platziert sein (2. oder 3.)
5. Wir wissen aus Bedingung 1: A ist höher als B, aber niedriger als C. Kombinieren Sie dies mit der vorherigen Analyse:
   • 2. Platz in Reihe A
   • B muss auf Platz 3 liegen
6. Wir wissen aus den Bedingungen 4 und 5: B ist höher als E und F, und F ist höher als E. Also:
   • 5. Platz in Reihe F
   • E 6. Platz

Die endgültige Rangliste sieht wie folgt aus:

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

Möchten Sie, dass ich Ihnen den detaillierten Argumentationsprozess zeige?

Beispiel 2: Optimierungsproblem

fragen Sie

Eine Stadt hat fünf große Verkehrsknotenpunkte, und die Stadtplanungsabteilung möchte die Abdeckung der Buslinien optimieren, um sicherzustellen, dass jeder Knotenpunkt durch mindestens eine Linie verbunden ist. Die Baukosten zwischen den Knotenpunkten sind bekannt und das Ziel ist es, alle Knotenpunkte zu minimalen Kosten zu verbinden.

Daten:

• Konnektivitätskosten zwischen Knotenpunkten (in Mio. $)
• Drehkreuz 1 und Drehkreuz 2: 100.000 $
• Hub 1 und Hub 3: 150.000 $
• Hub 2 und Hub 4: 200.000 $
• Hub 3 und Hub 4: 250.000 $
• Hub 3 und Hub 5: 300.000 $
• Hub 4 und Hub 5: 180.000 $

Ziel: Ermittlung, welche Knotenpunkte miteinander verbunden werden sollten, um die Gesamtbaukosten zu minimieren und sicherzustellen, dass alle Knotenpunkte miteinander verbunden sind.

Claude 3.5 Sonnet (1022) antwortet:

Es handelt sich um ein minimales Spannbaumproblem, das ich mit dem Algorithmus von Kruskal lösen werde. Analysieren wir es Schritt für Schritt:

1. Sortieren Sie zunächst alle Verbindungen von den kleinsten zu den größten Kosten:
   • Drehscheibe 1-2: 100.000 $
   • Drehkreuze 1-3: 150.000 $
   • Nabe 4-5: 180.000 $
   • Drehkreuze 2-4: 200.000 $
   • Nabe 3-4: 250.000 $
   • Drehkreuze 3-5: 300.000 $
2. Es wird die Verbindung mit den geringsten Kosten gewählt, um eine Ringbildung zu vermeiden:
   • Wählen Sie Hub 1-2 ($100.000)
   • Wählen Sie Hub 1-3 ($150.000)
   • Wählen Sie Hub 4-5 ($180.000)
   • Hub 2-4 auswählen ($200.000)

Optimales Programm:

• Verbinden von Hub 1 und Hub 2
• Verbinden von Hub 1 und Hub 3
• Verbinden von Hub 4 und Hub 5
• Verbinden von Hub 2 und Hub 4

Gesamtkosten: 10 + 15 + 18 + 20 = 630.000 $

Dieses Programm stellt sicher, dass:

1. Alle Hubs sind verbunden
2. Keine Schleife gebildet
3. Minimale Gesamtbetriebskosten

Soll ich Ihnen eine Visualisierung erstellen, die diese Lösung zeigt?

# Mitglied der Gemeinschaft

Für weitere detaillierte Claude 3.5 neuesten großen Modell Überprüfung Details, können Sie sich SuperCLUE-Claude Austausch Gruppe.

Der Leitfaden für Laien zum Einstieg in die KI

Hilft Ihnen, die Nutzung von KI-Tools kostengünstig und von Null an zu erlernen.KI ist, wie Bürosoftware, eine wesentliche Fähigkeit für jeden. Die Beherrschung von KI verschafft Ihnen einen Vorteil bei der Stellensuche und die Hälfte des Aufwands bei Ihrer zukünftigen Arbeit und Ihrem Studium.

Details ansehen>