Besser als GPT-5? Wir versuchen Ernie X1.1, Baidus neuestes KI -Modell

Nehmen: Die Struktur sieht ordentlich aus. Überschriften bleiben diszipliniert. Tischformatierung hält.

Bildgenerierung: argumentationsgeführte Format und Variantensteuerung

• Ziel: Entwerfen Sie ein 1080 × 1350 -Occasion -Poster und erstellen Sie dann eine saubere Variante.
• Warum das zählt: Ich erwarte, dass Ernie X1.1 vor dem Rendern planen soll. Argumentation sollte Software -Anrufe leiten.

Immediate:

„Entwerfen Sie ein 1080 × 1350-Poster für ‚Knowledge + Dharma 2025‘. Mischen Sie eine Skyline, eine Tempelsilhouette und ein Leiterplattenmuster. Platzieren Sie den Heldentitel oberster Zentrum. Stellen Sie den Untertitel unterunter hyperlinks ein.

Comply with-up-Eingabeaufforderung:

„Erstellen Sie eine zweite Variante. Ändern Sie den Untertitel in ‚alte Ideen. Moderne Intelligenz‘. Format identisch halten.

Ausgabe:

Nehmen: Ernie x1.1 ist hier eindeutig gescheitert. Es scheint, als könnte das Modell die nachteiligen Grenze der Eingabeaufforderung nicht verwalten, und es dauerte lange, bis eine absolut Müllausgabe erzielt wurde.

Codegenerierung: Fastapi -Service für das Halluzinationsrisiko

• Ziel: Versenden Sie einen winzigen Service, der das Halluzinationsrisiko erzielt. Einbeziehung von Unit -Checks.
• Warum das zählt: Ich möchte Gerüste, die beim ersten Versuch laufen. Ernie x1.1 sollte eine saubere Struktur liefern.

Immediate:

„Schreiben Sie ein Python Fastapi-Dienst /-risiko, das {textual content, Quellen ()} akzeptiert und Hallucination_Risk in (0,1) zurückgibt.

Ausgabe:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Checklist

app = FastAPI()

class RiskRequest(BaseModel):
    textual content: str
    sources: Checklist(str)

class RiskResponse(BaseModel):
    hallucination_risk: float

def calculate_lexical_overlap(textual content: str, sources: Checklist(str)) -> float:
    """Calculate Jaccard similarity between textual content and sources"""
    text_words = set(textual content.decrease().cut up())
    total_similarity = 0.0
    valid_sources = (s for s in sources if s.strip())
    
    if not valid_sources:
        return 0.0
    
    for supply in valid_sources:
        source_words = set(supply.decrease().cut up())
        intersection = text_words & source_words
        union = text_words | source_words
        similarity = len(intersection) / len(union) if union else 0
        total_similarity += similarity
    
    return total_similarity / len(valid_sources)

def calculate_contradiction(textual content: str, sources: Checklist(str)) -> float:
    """Easy NLI-inspired contradiction detection"""
    if not sources:
        return 0.0
    
    negation_words = {'not', 'no', 'by no means', 'none', 'with out'}
    contradiction_count = 0
    
    for supply in sources:
        source_tokens = supply.decrease().cut up()
        text_tokens = textual content.decrease().cut up()
        
        # Test for direct contradictions
        for i, token in enumerate(text_tokens):
            if token in negation_words and that i+1 < len(text_tokens):
                if text_tokens(i+1) in source_tokens:
                    contradiction_count += 1
                    break
    
    return min(contradiction_count / len(sources), 1.0)

@app.submit("/threat", response_model=RiskResponse)
def risk_endpoint(request: RiskRequest):
    """Most important endpoint for hallucination threat calculation"""
    if not request.sources:
        increase HTTPException(status_code=400, element="Sources listing can't be empty")
    
    lexical_overlap = calculate_lexical_overlap(request.textual content, request.sources)
    contradiction = calculate_contradiction(request.textual content, request.sources)
    hallucination_risk = 0.7 * lexical_overlap + 0.3 * contradiction
    
    return RiskResponse(hallucination_risk=spherical(min(max(hallucination_risk, 0.0), 1.0), 4))

# Unit assessments
import pytest

def test_lexical_overlap():
    assert spherical(calculate_lexical_overlap("the short brown fox", 
                ("the short fox", "a sluggish fox")), 3) == 0.458
    assert calculate_lexical_overlap("check", ()) == 0.0
    assert spherical(calculate_lexical_overlap("howdy world", 
                ("howdy", "world")), 3) == 0.500

def test_contradiction_detection():
    assert calculate_contradiction("the sky shouldn't be blue", 
                ("the sky is blue")) == 1.0
    assert calculate_contradiction("I like apples", 
                ("I like oranges")) == 0.0

def test_endpoint_validation():
    attempt:
        RiskRequest(textual content="check", sources=())
        assert False, "Anticipated validation error"
    besides HTTPException as e:
        assert e.status_code == 400

# Run assessments if executed straight
if __name__ == "__main__":
    pytest.important((__file__))

Frühe Eindrücke

Hier ist meine ehrliche Einstellung bisher – Ernie X1.1 denkt viel nach. Es beginnt viele Schritte. Einfache Aufgaben auslösen manchmal lange interne Argumentation und verlangsamen unkomplizierte Ausgänge, die Sie schnell erwarten.

Bei einigen Eingabeaufforderungen fühlt sich Ernie X1.1 übertrieben. Es besteht auf der Planung über die Aufgabe hinaus. Das zusätzliche Denken tut manchmal Kohärenz. Kurze Antworten werden mäandernd und unsicher, genau wie ein menschlicher Überdenken.

Wenn Ernie x1.1 die Rille trifft, verhält es sich intestine. Es respektiert die Format- und Abschnittsreihenfolge und kann die Tische fest halten und codiert. Die „Denken Sie die Zeit“ fühlt sich jedoch oft schwer an.

In meiner zukünftigen Verwendung werde ich die Aufforderungen an die Eindämmung des Anweisungsdeutigkeits und das Hinzufügen strengerer Einschränkungen einstellen. Für alltägliche Entwürfe erfordert das zusätzliche Denken Zurückhaltung. Ernie x1.1 zeigt vielversprechend, aber es muss sich selbst überschreiten.

Einschränkungen und offene Fragen

Der Zugang außerhalb Chinas beinhaltet immer noch die Reibung auf dem Useful. Ernie X1.1 funktioniert am besten über die Internet- oder API -Schnittstelle. Preisdetails bleiben beim Begin unklar. Ich möchte auch externe Benchmark -Überprüfungen, wie der Anbieter zum Zeitpunkt des Begins von zu kühner Klang für genau behauptet.

Die „Denktiefe“ muss Benutzersteuerung benötigen. Ein sichtbarer Knopf würde diesbezüglich möglicherweise helfen. Wenn es für mich wäre, würde ich dem Modell einen schnellen Modus für all diese schnellen Entwürfe und E -Mails hinzufügen. Andererseits wäre auch ein tiefer Modus für Agenten und Werkzeuge hilfreich. Ernie x1.1 kann von klaren Unterschieden profitieren.

Abschluss

Ernie x1.1 zielt auf Zuverlässigkeit ab, nicht auf Flash. Die Behauptung ist weniger Halluzinationen und bessere Einhaltung. Meine Läufe zeigen eine robuste Struktur und einen anständigen Code. Doch das Modell überdenkt oft. Das schadet Geschwindigkeit und Kohärenz bei einfachen Bitten.

Ich werde weiterhin mit engeren Eingabeaufforderungen testen. Ich werde mich auf API -Pfade für Agenten stützen. Wenn Baidu die Kontrolle „denken“, wird die Adoption steigen. Bis dahin bleibt Ernie X1.1 in meinem Toolkit für strenge Entwürfe und saubere Gerüste. Es muss nur zwischen Gedanken atmen.