Melhor que o GPT-5? Tentamos Ernie X1.1, o mais recente modelo de AI do Baidu -itstec.com.br. All rights reserved.

Entre muita expectativa, o Baidu anunciou seu Ernie X1.1 na Wave Summit em Pequim na noite passada. Parecia um pivô de demos chamativos à confiabilidade prática, pois o Baidu posicionou a nova variante Ernie como um modelo de raciocínio que se comporta. Como alguém que escreve, codifica e envia fluxos de trabalho Agentic diariamente, esse tom importava. A promessa é simples – menos alucinações, seguintes a seguir mais limpas e melhor uso da ferramenta. Essas três características decidem se um modelo vive na minha pilha ou se torna um experimento de fim de semana. Os primeiros sinais sugerem que Ernie x1.1 pode ficar.

Ernie x1.1: O que há de novo

Como mencionado, Ernie x1.1 é o mais recente modelo de raciocínio de Baidu, que herda o Ernie 4.5 base. Em seguida, ele empilha no meio do treinamento e pós-treinamento com uma receita ITERATIVE HYBRID RL. O foco é a cadeia de pensamento estável, não apenas mais pensamentos. Isso importa, como no trabalho diário, você deseja um modelo que respeite as restrições e use as ferramentas corretamente.

O Baidu relata três Deltas da manchete sobre Ernie X1. A factualidade aumentou 34,8%. Instrução a seguir aumenta 12,5%. Os recursos agênticos melhoram 9,6%. A empresa também afirma que o Benchmark Wins sobre o Deepseek R1-0528. Diz paridade com GPT-5 e Gemini 2.5 Professional no desempenho geral. Os cheques independentes levarão tempo. Mas a receita de treinamento sinaliza um impulso de confiabilidade.

Como acessar Ernie x1.1

Você tem três caminhos limpos para experimentar o novo modelo Ernie hoje.

Ernie Bot (Net)

Use o Ernie Bot Web site para conversar com Ernie X1.1. Baidu diz que Ernie X1.1 agora está acessível lá. As contas são diretas para os usuários da China. Os usuários internacionais ainda podem entrar, embora a interface do usuário se incline para a chinês.

Wenxiaoyan Cellular App

O aplicativo de consumo é a experiência renomeada Ernie na China. Ele suporta recursos de texto, pesquisa e imagem em um só lugar. A disponibilidade é através de lojas de aplicativos chinesas. Uma conta da App Retailer chinesa pode ajudar com o iOS. O Baidu lista o aplicativo como uma superfície de lançamento para Ernie X1.1.

Qianfan API (Baidu Ai Cloud)

As equipes podem implantar Ernie X1.1 através da Qianfan, a plataforma Maas do Baidu. O comunicado à imprensa confirma que o novo modelo Ernie está implantado no Qianfan para empreendimentos e desenvolvedores. Você pode integrar rapidamente os pontos de extremidade SDKs e Langchain. Este é o caminho que prefiro para agentes, ferramentas e orquestração.

Observação: O Baidu tornou Ernie Bot gratuito para os consumidores este ano. Esse movimento aprimorou o quantity de alcance e teste. Também sugere otimizações constantes de custos.

Prática com Ernie x1.1

Mantei os testes próximos ao trabalho diário e pressionei o modelo de IA em questão sobre estrutura, structure e código. Cada tarefa reflete uma entrega actual com um valor especial atribuído a obedecer primeiro a restrições.

Geração de texto: rascunho prd pesado de restrição

Meta: Produza um PRD com seções rigorosas e um limite de palavras duras.
Por que isso importa: Muitos modelos flutuam em comprimento e títulos. Ernie x1.1 reivindica controle mais rígido.

Incitar:
“Rascunha um PRD para um recurso móvel que sinaliza pagamentos de risco de risco.

Saída:

Pegar: A estrutura parece arrumada. Os títulos permanecem disciplinados. A formatação da tabela se mantém.

Geração de imagens: structure guiado por raciocínio e controle de variantes

Meta: Projete um pôster de eventos de 1080 × 1350 e crie uma variante limpa.
Por que isso importa: Espero que Ernie X1.1 planeje antes de renderizar. O raciocínio deve orientar as chamadas da ferramenta.

Incitar:

“Projete um pôster de 1080 × 1350 para ‘Dados + Dharma 2025’. Misture um horizonte, uma silhueta do templo e um padrão de placa de circuito. Coloque o título do herói no topo.

Immediate de acompanhamento:

“Crie uma segunda variante. Altere o subtítulo para ‘idéias antigas. Inteligência moderna’. Mantenha o structure idêntico.

Saída:

Geração de texto Ernie X1.1 — Geração de imagem Ernie X1.1

Pegar: Ernie x1.1 falhou claramente aqui. Parece que o modelo não conseguiu gerenciar os detalhes do immediate e demorou muito para criar uma saída absolutamente de lixo.

Geração de código: serviço fastapi para risco de alucinação

Meta: Envie um pequeno serviço que obtém risco de alucinação. Inclua testes de unidade.
Por que isso importa: Eu quero andaimes que correm na primeira tentativa. Ernie x1.1 deve fornecer uma estrutura limpa.

Incitar:

“Escreva um serviço /risco Python FASTAPI que aceite {textual content, fontes ()} e retorna hallucination_risk em (0,1). Use sobreposição lexical e uma simples verificação de contradição.

Saída:

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()
        
        # Examine 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):
    """Foremost endpoint for hallucination threat calculation"""
    if not request.sources:
        increase HTTPException(status_code=400, element="Sources record 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 exams
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("hi there world", 
                ("hi there", "world")), 3) == 0.500

def test_contradiction_detection():
    assert calculate_contradiction("the sky will not 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 exams if executed immediately
if __name__ == "__main__":
    pytest.foremost((__file__))