¿Mejor que GPT-5? Probamos Ernie X1.1, el extremo maniquí de IA de Baidu

Aguantar: La estructura se ve ordenada. Los encabezados permanecen disciplinados. CONSTRUCTAS DE FORMATIÓN DE TABLA.

Concepción de imágenes: diseño guiado por el razonamiento y control de transformación

• Meta: Diseñe un póster de evento 1080 × 1350, luego cree una transformación limpia.
• Por qué esto importa: Espero que Ernie X1.1 planifique ayer de renderizar. El razonamiento debe pilotar las llamadas de la utensilio.

Inmediato:

«Diseñe un póster de 1080 × 1350 para ‘Datos + Dharma 2025’. Mezcle un horizonte, una silueta de templo y un patrón de placa de circuito. Coloque el título del título de héroe.

Aviso de seguimiento:

«Cree una segunda transformación. Cambie el subtítulo a ‘ideas antiguas. Inteligencia moderna’. Mantenga el diseño idéntico.

Producción:

Aguantar: Ernie X1.1 claramente falló aquí. Parece que el maniquí no pudo manejar los decisos del aviso, y tardó mucho en conservarse a una salida absolutamente basura.

Concepción de código: servicio FastAPI para riesgos de deslumbramiento

• Meta: Envíe un pequeño servicio que calienta el aventura de deslumbramiento. Incluir pruebas unitarias.
• Por qué esto importa: Quiero andamios que se ejecutan en el primer intento. Ernie X1.1 debe entregar una estructura limpia.

Inmediato:

«Escriba un servicio /aventura de Python Fastapi que acepte {texto, fuentes ()} y devuelva alucination_risk en (0,1). Use una superposición léxica y una simple comprobación de contradicción. Incluya pruebas unitarias de Pytest. Sin llamadas de SaaS externos. Mantenga la producción de producción».

Producción:

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

app = FastAPI()

class RiskRequest(BaseModel):
    text: str
    sources: List(str)

class RiskResponse(BaseModel):
    hallucination_risk: float

def calculate_lexical_overlap(text: str, sources: List(str)) -> float:
    """Calculate Jaccard similarity between text and sources"""
    text_words = set(text.lower().split())
    total_similarity = 0.0
    valid_sources = (s for s in sources if s.strip())
    
    if not valid_sources:
        return 0.0
    
    for source in valid_sources:
        source_words = set(source.lower().split())
        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(text: str, sources: List(str)) -> float:
    """Simple NLI-inspired contradiction detection"""
    if not sources:
        return 0.0
    
    negation_words = {'not', 'no', 'never', 'none', 'without'}
    contradiction_count = 0
    
    for source in sources:
        source_tokens = source.lower().split()
        text_tokens = text.lower().split()
        
        # Check for direct contradictions
        for i, token in enumerate(text_tokens):
            if token in negation_words and 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.post("/risk", response_model=RiskResponse)
def risk_endpoint(request: RiskRequest):
    """Main endpoint for hallucination risk calculation"""
    if not request.sources:
        raise HTTPException(status_code=400, detail="Sources list cannot be empty")
    
    lexical_overlap = calculate_lexical_overlap(request.text, request.sources)
    contradiction = calculate_contradiction(request.text, request.sources)
    hallucination_risk = 0.7 * lexical_overlap + 0.3 * contradiction
    
    return RiskResponse(hallucination_risk=round(min(max(hallucination_risk, 0.0), 1.0), 4))

# Unit tests
import pytest

def test_lexical_overlap():
    assert round(calculate_lexical_overlap("the quick brown fox", 
                ("the quick fox", "a slow fox")), 3) == 0.458
    assert calculate_lexical_overlap("test", ()) == 0.0
    assert round(calculate_lexical_overlap("hello world", 
                ("hello", "world")), 3) == 0.500

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

def test_endpoint_validation():
    try:
        RiskRequest(text="test", sources=())
        assert False, "Expected validation error"
    except HTTPException as e:
        assert e.status_code == 400

# Run tests if executed directly
if __name__ == "__main__":
    pytest.main((__file__))

Impresiones tempranas

Aquí está mi toma honesta hasta ahora: Ernie X1.1 piensa mucho. Se dura muchos pasos. Las tareas simples a veces desencadenan un razonamiento interno grande, ralentizando panorama directas que demora que sea rápido.

Según algunas indicaciones, Ernie X1.1 se siente excesivo. Insiste en la planificación más allá de la tarea. El pensamiento adicional a veces duele la coherencia. Las respuestas cortas se vuelven serpenteantes e inseguras, al igual que un pensamiento humano demasiado.

Cuando Ernie X1.1 golpea el surco, se comporta acertadamente. Respeta el formato y el orden de sección, y puede sostener las tablas apretadas y los códigos ordenados. Sin requisa, el «tiempo de pensamiento» a menudo se siente pesado.

En mi uso futuro, sintonizaré las indicaciones para frenar esto reduciendo la equívoco de la instrucción y agregando restricciones más estrictas. Para los borradores cotidianos, el pensamiento adicional necesita moderación. Ernie X1.1 se muestra prometedor, pero debe suceder el ritmo.

Limitaciones y preguntas abiertas

El acercamiento fuera de China todavía implica fricción en los dispositivos móviles. Ernie X1.1 funciona mejor a través de la interfaz web o API. Los detalles de los precios siguen sin estar claro en el emanación. Todavía quiero cheques de remisión externos, ya que el proveedor afirma en el momento del emanación suena demasiado audaz para ser preciso.

La profundidad de «pensar» necesita control del heredero. Una perilla visible posiblemente ayudaría a este respecto. Si fuera para mí, agregaría un modo rápido al maniquí para todos esos borradores y correos electrónicos rápidos. Por otra parte, un modo profundo para agentes y herramientas igualmente sería útil. Ernie X1.1 puede beneficiarse de distinciones claras.

Conclusión

Ernie X1.1 apunta a la confiabilidad, no al flash. El propaganda es menos alucinaciones y un mejor cumplimiento. Mis carreras muestran una estructura resistente y un código limpio. Sin requisa, el maniquí a menudo piensa demasiado. Eso duele la velocidad y la coherencia en las solicitudes simples.

Seguiré probando con indicaciones más estrictas. Me apoyaré en los caminos API para los agentes. Si Baidu expone el control de «pensar», la acogida aumentará. Hasta entonces, Ernie X1.1 permanece en mi coyuntura de herramientas para borradores estrictos y andamios limpios. Solo necesita respirar entre pensamientos.