Mistral Large 3 Eğitimi: Çok Modlu Zekâ Değerlendirme Merkezi Oluşturun

Mistral Large 3, karmaşık görsel belgelerden bilgi okumak, muhakeme etmek ve yapılandırmak için geliştirilmiş bir çok modlu MoE modelidir. Grafikleri ve PDF’leri durağan görseller olarak ele almak yerine, bunlardan tablolar ve içgörüler çıkarmak ve akıcı anlatılar üretmek üzere tasarlanmıştır.

Bu eğitimde, Streamlit üzerinde bir Çok Modlu Zekâ Değerlendirme Merkezi oluşturmak için Mistral Large 3 (mistral-large-2512) modelini kullanacağız. Akış şu şekilde işler:

• Grafikler, finansal tablolar veya çok sayfalı PDF’ler gibi girdileri yüklersiniz.
• Mistral, metin ve sayıları doğrudan görselden okur.
• Görünen tabloları CSV dizelerine dönüştürür.
• Ardından Mistral, girdiye göre içgörüler, riskler ve anormallikler üretir.
• Son olarak, birden fazla dilde kısa özetler döndürür.

Tüm bunlar tek bir model (mistral-large-2512), tek bir uç nokta (/v1/chat/completions) ve çıktıları yapılandırılmış ve güvenilir tutmak için katı bir JSON Şeması ile yapılır. 

Yeni modellerin temel özelliklerini tanıtan Mistral 3 makalemizi okumanızı öneririm. Ayrı bir eğitimde Ministral 3’ün ince ayarı hakkında da bilgi edinebilirsiniz.

Mistral Large 3 Nedir?

Mistral Large 3, toplam 675B parametreden 41B etkin parametreli seyrek bir uzman karışımı (MOE) mimarisine ve görsel anlamlandırma için 2,5B parametreli bir görsel kodlayıcıya sahiptir.

Bu modele ilişkin birkaç temel özellik şunlardır:

• Çok modlu: Mistral Large 3 hem metni hem de görselleri (grafikler, ekran görüntüleri, belgeler) işler.
• Uzun bağlam (256k belirteç): Uzun belgeler, RAG boru hatları ve kurumsal iş akışları için geliştirilmiştir.
• Etkenci ve yapılandırılmış çıktı: Sohbet API’si aracılığıyla işlev çağırma ve JSON/JSON Şeması çıktısını destekler.
• Çok dilli: Mistral’in Large 3 modeli yalnızca İngilizce değil, 40+ dilde güçlü performans sunar.

Model kartı ve ekosistem belgeleri ayrıca bazı önemli uyarılardan bahseder:

• Bu model özel bir akıl yürütme modeli değildir; yani, zor mantıkta onu geride bırakabilen belirli uzmanlaşmış akıl yürütme varyantları da vardır.
• Salt görsel görevlerde görsel odaklı modellerin gerisinde kalır; bu nedenle, ön işleme ve iyi istemler önemlidir.
• Görsel için Mistral, en-boy oranlarını 1:1’e yakın tutmayı, aşırı ince veya geniş görsellerden kaçınmayı önerir. Bu nedenle, kırpma, model performansını iyileştirmeye yardımcı olur. 

Mistral 3 Large Örnek Proje: Çok Modlu Zekâ Değerlendirme Merkezi

Bu bölümde, Mistral Large 3’ü bir Streamlit uygulamasına sararak bir Çok Modlu Zekâ Değerlendirme Merkezi oluşturacağız. Üst düzeyde, nihai uygulama şunları yapar:

• Grafik ekran görüntüleri, tek rapor sayfaları veya tablolar ve grafikler içeren çok sayfalı PDF’ler gibi rapor benzeri girdileri kabul eder.
• PDF’leri tek bir yığılmış görsele dönüştürür, ardından yaklaşık 1:1 en-boy oranına göre merkezden kırpar (Mistral Large 3’ün görsel önerisine uygun), yaklaşık 1024×1024 boyutuna yeniden boyutlandırır ve sonucu base64 veri URL’si olarak kodlar.
• Daha sonra, kullanıcının talimatlarını ve görseli mistral-large-2512’ye göndeririz; bu model response_format’ı JSON Şeması modunda kullanarak yapılandırılmış bir JSON yükü döndürür.
• Son olarak, JSON’u indirilebilir CSV’lerle birlikte yeniden oluşturulmuş tabloları DataFrame olarak, madde işaretli içgörü/risk/anormallikleri, sosyal medyaya hazır bir gönderiyi ve açılır alanlarda çok dilli özetleri içeren etkileşimli bir gösterge paneli olarak sunarız.

Bu yaklaşım, durağan bir görsel raporu tamamen Mistral Large 3 tarafından desteklenen etkileşimli bir zekâ asistanına dönüştürür.

Hadi adım adım oluşturalım.

Adım 1: Önkoşullar ve kurulum

Mistral Large 3 üzerine Streamlit demosunu kurmadan önce, Mistral API aracılığıyla modelle konuşmak için temel bir yerel ortama ihtiyacımız var. Arayüzü, belgeleri ve yapılandırmayı yönetmek için birkaç yardımcı kütüphane kurarak başlayın. 

pip install streamlit mistralai pillow pdf2image pandas python-dotenvAltyapı:

Yukarıdaki çekirdek kütüphaneleri kullanacağız: etkileşimli web uygulaması arayüzü için streamlit, Mistral API ile haberleşmek için mistralai, PDF’leri açmak ve görsellere dönüştürmek için pillow ve pdf2image, tablo verileri veya günlükleri işlemek için pandas ve python-dotenv ile MISTRAL_API_KEY gibi ortam değişkenlerini güvenle bir .env dosyasından yüklemek için.

Ardından Mistral AI Platformuna giriş yapın ve API Keys sekmesine gidin.

Varsayılan çalışma alanınızı ayarlayın (istendiğinde) ve Create new key düğmesine tıklayın.

Anahtarınıza anlamlı bir ad verin ve isteğe bağlı olarak bir son kullanma tarihi belirleyin.

Son olarak, oluşturulan anahtarı kopyalayın ve aşağıdaki gibi bir ortam değişkeni olarak dışa aktarın:

export MISTRAL_API_KEY="your_mistral_api_key_here"Altyapı:

Bu noktada, ortamımız artık Mistral API ile kimlik doğrulaması yapmaya hazır.

Adım 2: Mistral istemcisini başlatma

Ortam yapılandırılıp bağımlılıklar kurulduktan sonra, sıradaki adım Mistral Large 3 modeline yapacağımız tüm çağrıları yönetecek Mistral istemcisini başlatmaktır. Bu, Streamlit uygulamamızdan Mistral Large 3’e istemler göndermek için bir giriş noktası sağlar.

MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
MODEL_ID = "mistral-large-2512"  
if MISTRAL_API_KEY is None:
    raise RuntimeError("Please set the MISTRAL_API_KEY environment variable.")
client = MistralClient(api_key=MISTRAL_API_KEY)Altyapı:

Yukarıdaki kod bloğu üç şey yapar:

• Ortamımızdan MISTRAL_API_KEY değerini okur ve model adını uygulama genelinde yeniden kullanabilelim diye MODEL_ID değişkeninde saklar.
• Ardından API anahtarının ayarlı olduğunu doğrular ve eksikse net bir hata verir.
• Ayrıca resmi mistralai SDK’sını kullanarak bir MistralClient örneği oluşturur; modeli yapacağımız tüm isteklere bununla erişeceğiz.

İstemci başlatıldıktan sonra, Streamlit arayüzü içinde istem gönderen ve yanıtları işleyen birkaç yardımcı işlev oluşturacağız.

Adım 3: Görsel ön işleme

Mistral Large 3’e görsel veya PDF göndermeden önce, bunları “model dostu” hale getirmemiz gerekir. Vision API, girdiler kare, makul boyutta ve tutarlı bir formatta kodlandığında en iyi sonucu verir. 

Adım 3.1: Merkezden kırpma

Yüklenen görseli açıp kare bir kırpıma dönüştürerek başlıyoruz. 

def load_image_from_upload(uploaded_file) -> Image.Image:
    return Image.open(io.BytesIO(uploaded_file.read())).convert("RGB")
def center_crop_to_square(img: Image.Image) -> Image.Image:
    width, height = img.size
    if width == height:
        return img
    if width > height:
        offset = (width - height) // 2
        box = (offset, 0, offset + height, height)
    else:
        offset = (height - width) // 2
        box = (0, offset, width, offset + width)
    return img.crop(box)Altyapı:

Yukarıdaki kod bloğu, yüklediğimiz grafik veya tabloların modele gitmeden önce kare bir kırpıma dönüştürülmesini sağlar ve Mistral’in görsel yönergeleriyle hizalanır.

Adım 3.2: Yeniden boyutlandırma 

Sonraki adımda, kalite, gecikme ve belirteç maliyetini dengelemek için görseli en fazla 1024×1024 boyutuna yeniden boyutlandırıyoruz.

def resize_for_vlm(img: Image.Image, max_size: int = 1024) -> Image.Image:
    width, height = img.size
    scale = min(max_size / width, max_size / height, 1.0)
    if scale == 1.0:
        return img
    new_w = int(width * scale)
    new_h = int(height * scale)
    return img.resize((new_w, new_h), Image.LANCZOS)Altyapı:

Burada, her iki boyutu da max_size’ın altında tutarken en-boy oranını koruyan bir scale faktörü hesaplarız. Görsel zaten yeterince küçükse aynı şekilde döndürürüz. Aksi halde yeni boyutları hesaplar ve yüksek kaliteli küçültme için LANCZOS örnekleme kullanırız.

Bu adım, görsellerin bağlam penceresini şişirmesini veya gereksiz yere yanıtları yavaşlatmasını engeller.

Adım 3.3: PDF’lerden yığılmış görsele

PDF’lerde, modele tek bir sayfadan fazlasını göstermek isteyebiliriz. Basit bir yöntem, tüm sayfaları işleyip dikey olarak tek bir uzun görselde yığmaktır. 

def stack_images_vertically(images: List[Image.Image]) -> Image.Image:
    if not images:
        raise ValueError("No images to stack")
    target_width = images[0].size[0]
    resized_images = []
    for img in images:
        if img.size[0] != target_width:
            aspect_ratio = img.size[1] / img.size[0]
            new_height = int(target_width * aspect_ratio)
            img = img.resize((target_width, new_height), Image.LANCZOS)
        resized_images.append(img)
    total_height = sum(img.size[1] for img in resized_images)
    stacked = Image.new('RGB', (target_width, total_height))
    y_offset = 0
    for img in resized_images:
        stacked.paste(img, (0, y_offset))
        y_offset += img.size[1] 
    return stacked
def uploaded_file_to_square_base64(uploaded_file) -> Tuple[str, str]:
    mime_type = uploaded_file.type
    raw_bytes = uploaded_file.getvalue()
    if mime_type == "application/pdf":
        pages = convert_from_bytes(raw_bytes)
        pages_rgb = [page.convert("RGB") for page in pages]
        img = stack_images_vertically(pages_rgb)
        img = resize_for_vlm(img, max_size=1024)
        mime_type = "image/png"  
    else:
        img = Image.open(io.BytesIO(raw_bytes)).convert("RGB")
        img = center_crop_to_square(img)
        img = resize_for_vlm(img, max_size=1024)
    return mime_type, image_to_base64_data_url(img, mime_type=mime_type)Altyapı:

stack_images_vertically() işlevi bir PIL görseli listesini alır, en-boy oranını koruyarak ortak bir genişliğe normalleştirir, toplam yüksekliği hesaplar ve onları tek bir RGB tuvale alt alta yapıştırır. uploaded_file_to_square_base64() işlevi ise MIME türüne göre ne yapılacağına karar verir:

• PDF’lerde her sayfayı görsele dönüştürür, dikey olarak yığar ve sonucu yeniden boyutlandırır.
• Normal görsel yüklemelerinde görseli yükler, merkezden kare olarak kırpar ve yeniden boyutlandırır.

Her iki durumda da, son kodlama adımı için bir MIME türüyle birlikte normalize edilmiş bir görsel döndürür.

Adım 3.4: Base64’e kodlama 

Mistral’in Vision API’si, image_url nesneleri olarak görselleri kabul eder; bunlar gerçek URL’ler veya data: URL’leri olabilir.

def image_to_base64_data_url(img: Image.Image, mime_type: str = "image/png") -> str:
    buffer = io.BytesIO()
    if mime_type == "image/jpeg":
        img.save(buffer, format="JPEG", quality=90)
    else:
        img.save(buffer, format="PNG")
        mime_type = "image/png"
    b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
    return f"data:{mime_type};base64,{b64}"Altyapı:

Önce görseli bellekte bir arabelleğe yazar ve uygun bir format (JPEG veya PNG gibi) seçeriz, ardından baytları base64 olarak kodlarız. 

Son olarak, kodlanmış dizeyi data:{mime_type};base64 URL’sine sararız ve bunu image_url olarak doğrudan Mistral Vision API’sine geçebiliriz.

Bu adımın sonunda, tek bir PNG, geniş bir pano veya çok sayfalı bir PDF olsun, yüklenen her dosya merkezden kırpma, yeniden boyutlandırma, PDF yığma ve base64 veri URL’sine dönüştürme boru hattından geçer.

Adım 4: Çok modlu çıkarım çağrısı 

Bu adımda, görsel + metin isteği gönderen ve modelin JSON formatında yanıt vermesini zorunlu kılan tek bir yardımcı işlevde her şeyi toplarız. Bunu şu şekilde birleştirerek yapıyoruz:

• Modelin rolünü Çok Modlu Zekâ Değerlendiricisi olarak tanımlayan bir sistem istemi,
• Talimatlarla görsel içeriği birleştiren bir kullanıcı iletisi ve
• Çıktının yapılandırılmış ve kolayca ayrıştırılabilir olması için response_format aracılığıyla gönderilen bir JSON Şeması.

def call_mistral_large_multimodal(
    mime_type: str,
    image_data_url: str,
    user_instruction: str,
    languages: List[str],
) -> Dict[str, Any]:
    json_schema = {
        "type": "object",
        "properties": {
            "csv_tables": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Each item is a CSV string representing one table found in the image."
            },
            "insights": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Up to 5 key insights about the content."
            },
            "risks": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Up to 5 key risks or red flags."
            },
            "anomalies": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Any anomalies, outliers, or surprising patterns you detect."
            },
            "translations": {
                "type": "object",
                "properties": {
                    lang: {"type": "string"} for lang in languages
                },
                "description": "Short high-level summaries in the selected languages."
            },
        },
        "required": ["csv_tables", "insights", "risks"],
        "additionalProperties": False,
    }
    system_prompt = (
        "You are a Multimodal Intelligence Evaluator using Mistral Large 3.\n"
        "You are given a single document-like image (e.g. chart + table, financial report page).\n\n"
        "Your tasks:\n"
        "1. Read all visible text and numbers directly from the image.\n"
        "2. Reconstruct any clearly visible tables into valid CSV strings.\n"
        "   - Use the first row as headers when possible.\n"
        "   - Use commas as separators and newline per row.\n"
        "3. Derive up to 5 concise INSIGHTS about trends, patterns, or takeaways.\n"
        "4. Derive up to 5 concise RISKS or red flags (business, financial, operational, etc.).\n"
        "5. Detect any anomalies or surprising patterns if present (else return an empty list).\n"
        "6. Provide short summaries in the requested languages.\n\n"
        "You MUST respond ONLY with a JSON object that matches the provided JSON schema.\n"
        "Do not include any extra commentary outside of the JSON."
    )
    messages = [
        {
            "role": "system",
            "content": [
                {"type": "text", "text": system_prompt},
            ],
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": user_instruction or "Analyze this financial report page.",
                },
                {
                    "type": "image_url",
                    "image_url": image_data_url,
                },
            ],
        },
    ]
    response = client.chat(
        model=MODEL_ID,
        messages=messages,
        temperature=0.2,
        max_tokens=2048,
        response_format={
            "type": "json_schema",
            "json_schema": {
                "name": "multimodal_intel_eval",
                "schema": json_schema,
                "strict": True,
            },
        },
    )
    content = response.choices[0].message.content
    try:
        parsed = json.loads(content)
    except json.JSONDecodeError:
        try:
            start = content.index("{")
            end = content.rindex("}") + 1
            parsed = json.loads(content[start:end])
        except Exception:
            raise ValueError(f"Model did not return valid JSON. Raw content:\n{content}")
    return parsedAltyapı:

call_mistral_large_multimodal() işlevi, çok modlu zekâ demosunun çekirdek motorudur.

• İşlev önce csv_tables, insights, risks, anomalies dizilerini ve languages listesinden türetilen anahtarlara sahip bir translations nesnesini tanımlayan bir JSON Şeması oluşturur. 
• Ayrıca modeli bir Çok Modlu Zekâ Değerlendiricisi olarak çerçeveleyen ve sayıları okuma, tabloları CSV olarak yeniden kurma, içgörüleri, riskleri, anormallikleri ve çok dilli özetleri çıkarma görevlerini adım adım anlatan ayrıntılı bir sistem istemi tanımlarız.
• call_mistral_large_multimodal() işlevi daha sonra sistem talimatlarını, metin talimatları ve image_url yükünü içeren bir kullanıcı iletisiyle birleştirerek sohbet formatında ileti dizisini oluşturur. MODEL_ID ile client.chat() çağrısı yapar, belirleyici çıktı için sıcaklığı düşük tutar ve yanıtın şemaya uyması için response_format={"type": "json_schema",} kullanır. Son olarak json.loads ile ayrıştırmaya çalışırız.

Bunu kurduğunuzda, ham bir grafik veya rapor görselini yapılandırılmış bir anlatıya dönüştürmek için sağlam bir giriş noktasına sahip olursunuz.

Adım 5: Streamlit arayüzünü oluşturma

Ön işleme hattı ve Mistral istemcisi hazır olduğunda, son adım her şeyi bir Streamlit arayüzüne sarmalamaktır. 

st.set_page_config(
    page_title="Multimodal Intelligence Evaluation Hub - Mistral Large 3",
    layout="wide",
)
st.title("Multimodal Intelligence Evaluation Hub")
st.caption("Powered by **Mistral Large 3**")
col_left, col_right = st.columns([2, 1])
with col_left:
    uploaded_file = st.file_uploader(
        "Upload an image or report (PNG, JPG, WEBP, or PDF)",
        type=["png", "jpg", "jpeg", "webp", "pdf"],
    )
    default_prompt = (
        "Give me 3–5 key insights and risks from this input and export any tables you see as CSV "
        "Also write down the findings for a professional audience."
    )
    user_instruction = st.text_area(
        "Instruction to Mistral Large 3",
        value=default_prompt,
        height=120,
    )
with col_right:
    st.subheader("Multilingual Options")
    languages = st.multiselect(
        "Additional summary languages",
        options=["fr", "de", "es", "hi", "zh", "ja"],
        default=["hi"],
        help="Mistral Large 3 supports dozens of languages; these will receive short summaries.",
        label_visibility="collapsed",
    )
    run_button = st.button("Run Analysis", type="primary")
if run_button:
    if uploaded_file is None:
        st.error("Please upload an image or PDF first.")
        st.stop()
    prep_msg = "Preparing PDF (combining all pages)..." if uploaded_file.type == "application/pdf" else "Preparing image..."
    with st.spinner(prep_msg):
        mime_type, data_url = uploaded_file_to_square_base64(uploaded_file)
    mime, b64_part = data_url.split(",", 1)
    img_bytes = base64.b64decode(b64_part)
    st.image(img_bytes, caption="Center-cropped & resized image for the model", width=400)
    with st.spinner("Processing..."):
        try:
            result = call_mistral_large_multimodal(
                mime_type=mime_type,
                image_data_url=data_url,
                user_instruction=user_instruction,
                languages=languages,
            )
        except Exception as e:
            st.error(f"Error calling Mistral Large 3: {e}")
            st.stop()
    st.header("Results")
    csv_tables = result.get("csv_tables", [])
    if csv_tables:
        st.subheader("Reconstructed Tables (CSV)")
        for i, csv_str in enumerate(csv_tables):
            st.markdown(f"**Table {i+1}**")
            try:
                df = pd.read_csv(io.StringIO(csv_str))
                st.dataframe(df, use_container_width=True)
            except Exception:
                st.text_area(f"Raw CSV for Table {i+1}", value=csv_str, height=150)
            st.download_button(
                label=f"Download Table {i+1} as CSV",
                data=csv_str,
                file_name=f"table_{i+1}.csv",
                mime="text/csv",
                key=f"csv_download_{i}",
            )
    else:
        st.info("No tables were detected or reconstructed.")
    insights = result.get("insights", [])
    risks = result.get("risks", [])
    anomalies = result.get("anomalies", [])
    col_ins, col_risk = st.columns(2)
    with col_ins:
        st.subheader("Key Insights")
        if insights:
            for bullet in insights:
                st.markdown(f"- {bullet}")
        else:
            st.write("_No explicit insights returned._")
    with col_risk:
        st.subheader("Risks")
        if risks:
            for bullet in risks:
                st.markdown(f"- {bullet}")
        else:
            st.write("_No explicit risks returned._")
    st.subheader("Anomalies")
    if anomalies:
        for bullet in anomalies:
            st.markdown(f"- {bullet}")
    else:
        st.write("_No anomalies reported._")
    translations = result.get("translations", {}) or {}
    if translations:
        st.subheader(" Multilingual Summaries")
        for lang_code, summary in translations.items():
            with st.expander(f"Summary in {lang_code}"):
                st.write(summary)
    else:
        st.info("No multilingual summaries were requested or returned.")
    # Raw JSON (debug)
    # with st.expander(" Raw JSON (debug)"):
    #     st.json(result)Altyapı:

Yukarıdaki StreamLit arayüz kodu birkaç önemli şey yapar:

st.set_page_config yöntemi düzeni iki sütuna böler. Sol taraf temel girdileri (dosya yükleyici ve varsayılan talimatlarla düzenlenebilir metin alanı) ele alır. Sağ taraf ise st.multiselect ile çok dilli seçenekler ve birincil Run Analysis düğmesini sunar. Düğmeye tıklandığında, uygulama bir dosya olduğuna dair doğrulama yapar, görselleri veya PDF’leri base64 veri URL’sine dönüştürür ve önizleme görselini gösterir. 

Sonuç döndüğünde, yeniden oluşturulmuş CSV tabloları, içgörüler, riskler, anormallikler ve varsa çok dilli özetlerle birlikte veri çerçeveleri olarak sunulur. İsteğe bağlı olarak ham JSON’u incelememizi sağlayan hata ayıklama görünümleri de (yorum satırına alınmış) eklenebilir.

Bu adımı tamamladıktan sonra, her şeyi app.py olarak kaydedebilir ve tam deneyimi şu komutla başlatabilirsiniz:

streamlit run app.pyAltyapı:

Aşağıdaki videoda, hem görsel hem PDF girdileriyle iş akışının kısaltılmış bir sürümünü eylemde görebilirsiniz: