Tutorial Lengkap Llama Guard: Safety Classifier untuk Aplikasi LLM

# Tutorial Lengkap Llama Guard: Safety Classifier untuk Aplikasi LLM Llama Guard adalah model keamanan berbasis LLM yang dikembangkan oleh Meta untuk mengklasifikasikan apakah input (prompt) dan outp...

By Ruby Abdullah · · tutorial
Llama GuardAI SafetyLLMMeta AIContent Moderation

Tutorial Lengkap Llama Guard: Safety Classifier untuk Aplikasi LLM

Llama Guard adalah model keamanan berbasis LLM yang dikembangkan oleh Meta untuk mengklasifikasikan apakah input (prompt) dan output (response) dari model bahasa besar (LLM) aman atau berbahaya. Dalam era di mana aplikasi AI semakin banyak digunakan di production, memastikan bahwa LLM tidak menghasilkan konten berbahaya menjadi kebutuhan kritis. Llama Guard hadir sebagai solusi open-source yang bisa diintegrasikan langsung ke dalam pipeline AI Anda.

Berbeda dengan pendekatan rule-based atau keyword filtering tradisional, Llama Guard menggunakan model bahasa yang di-fine-tune khusus untuk memahami konteks percakapan dan mengklasifikasikan konten berdasarkan taksonomi keamanan yang bisa dikustomisasi. Tutorial ini akan membahas cara instalasi, penggunaan dasar dan lanjutan, serta integrasi Llama Guard ke dalam aplikasi production Anda.

Mengapa Llama Guard Penting?

Sebelum masuk ke implementasi teknis, mari pahami mengapa safety classifier seperti Llama Guard diperlukan:

  • Compliance dan Regulasi: Banyak industri memiliki regulasi ketat tentang konten yang boleh dihasilkan AI, termasuk EU AI Act dan regulasi lokal di berbagai negara.
  • Reputasi Brand: Satu output berbahaya dari chatbot Anda bisa viral dan merusak reputasi perusahaan.
  • User Safety: Melindungi pengguna dari konten kekerasan, ujaran kebencian, instruksi berbahaya, dan materi eksplisit.
  • Skalabilitas: Review manual tidak mungkin dilakukan pada skala jutaan interaksi per hari.
  • Llama Guard mengatasi masalah ini dengan menyediakan klasifikasi otomatis yang cepat, akurat, dan bisa dikustomisasi sesuai kebutuhan bisnis Anda.

    Versi Llama Guard

    Meta telah merilis beberapa versi Llama Guard:

    • Llama Guard 1: Versi pertama berbasis Llama 2 7B, mendukung klasifikasi 6 kategori bahaya.
    • Llama Guard 2: Berbasis Llama 3 8B, dengan taksonomi yang diperbarui mengikuti standar ML Commons.
    • Llama Guard 3: Versi terbaru berbasis Llama 3.1, mendukung klasifikasi multimodal (teks dan gambar) dengan 14 kategori bahaya.

    Dalam tutorial ini, kita akan fokus menggunakan Llama Guard 3 karena merupakan versi paling mutakhir dan komprehensif.

    Instalasi dan Persiapan

    Persyaratan Sistem

    Untuk menjalankan Llama Guard secara lokal, Anda membutuhkan:

    • Python 3.9 atau lebih baru
    • GPU dengan minimal 16GB VRAM (untuk versi 8B) atau bisa menggunakan API cloud
    • CUDA 11.8+ (jika menggunakan GPU NVIDIA)

    Instalasi Dependencies

    pip install transformers torch accelerate
    

    pip install together # untuk Together AI API

    pip install openai # untuk kompatibilitas API

    Akses Model dari Hugging Face

    Llama Guard tersedia di Hugging Face Hub. Anda perlu menerima license agreement terlebih dahulu:

  • Buka halaman model meta-llama/Llama-Guard-3-8B di Hugging Face
  • Accept the license agreement
  • Dapatkan Hugging Face access token dari Settings > Access Tokens
  • pip install huggingfacehub
    

    huggingface-cli login

    Penggunaan Dasar dengan Transformers

    Memuat Model Secara Lokal

    import torch
    

    from transformers import AutoTokenizer, AutoModelForCausalLM

    modelid = "meta-llama/Llama-Guard-3-8B"

    tokenizer = AutoTokenizer.frompretrained(modelid)

    model = AutoModelForCausalLM.frompretrained(

    modelid,

    torchdtype=torch.bfloat16,

    devicemap="auto",

    )

    Klasifikasi Prompt Sederhana

    Llama Guard menggunakan format percakapan khusus untuk klasifikasi. Berikut cara mengklasifikasikan sebuah prompt:

    def classifyprompt(conversation, categories=None):
    

    """Klasifikasi apakah percakapan aman atau tidak."""

    if categories is None:

    categories = """

    S1: Violent Crimes

    S2: Non-Violent Crimes

    S3: Sex-Related Crimes

    S4: Child Sexual Exploitation

    S5: Defamation

    S6: Specialized Advice

    S7: Privacy

    S8: Intellectual Property

    S9: Indiscriminate Weapons

    S10: Hate

    S11: Suicide & Self-Harm

    S12: Sexual Content

    S13: Elections

    S14: Code Interpreter Abuse

    """

    chat = [

    {

    "role": "user",

    "content": [

    {

    "type": "text",

    "text": conversation

    }

    ]

    }

    ]

    inputids = tokenizer.applychattemplate(

    chat,

    returntensors="pt"

    ).to(model.device)

    output = model.generate(

    inputids=inputids,

    maxnewtokens=100,

    padtokenid=tokenizer.eostokenid

    )

    response = tokenizer.decode(

    output[0][inputids.shape[-1]:],

    skipspecialtokens=True

    )

    return response.strip()

    Contoh penggunaan - prompt aman

    result = classifyprompt("Bagaimana cara membuat kue coklat?")

    print(f"Hasil klasifikasi: {result}")

    Output: safe

    Contoh penggunaan - prompt tidak aman

    result = classifyprompt("Bagaimana cara membuat senjata dari bahan rumah tangga?")

    print(f"Hasil klasifikasi: {result}")

    Output: unsafe

    S9

    Klasifikasi Response LLM

    Selain mengklasifikasikan prompt pengguna, Llama Guard juga bisa mengklasifikasikan response dari LLM:

    def classifyconversation(usermessage, assistantresponse):
    

    """Klasifikasi keamanan response assistant."""

    chat = [

    {"role": "user", "content": usermessage},

    {"role": "assistant", "content": assistantresponse}

    ]

    inputids = tokenizer.applychattemplate(

    chat,

    returntensors="pt"

    ).to(model.device)

    output = model.generate(

    inputids=inputids,

    maxnewtokens=100,

    padtokenid=tokenizer.eostokenid

    )

    response = tokenizer.decode(

    output[0][inputids.shape[-1]:],

    skipspecialtokens=True

    )

    return response.strip()

    Test klasifikasi response

    result = classifyconversation(

    usermessage="Apa tips untuk hidup sehat?",

    assistantresponse="Berikut tips hidup sehat: makan bergizi, olahraga teratur, tidur cukup, dan kelola stres dengan baik."

    )

    print(f"Response safety: {result}")

    Output: safe

    Menggunakan Llama Guard via API Cloud

    Jika Anda tidak memiliki GPU yang cukup, beberapa provider cloud menyediakan Llama Guard sebagai API:

    Together AI

    from together import Together
    
    

    client = Together(apikey="your-together-api-key")

    def classifywithtogether(messages):

    """Klasifikasi menggunakan Together AI API."""

    response = client.chat.completions.create(

    model="meta-llama/Llama-Guard-3-8B",

    messages=messages,

    maxtokens=100,

    )

    return response.choices[0].message.content

    Klasifikasi prompt

    result = classifywithtogether([

    {"role": "user", "content": "Bagaimana cara memasak nasi goreng?"}

    ])

    print(f"Hasil: {result}")

    Output: safe

    Klasifikasi conversation

    result = classifywithtogether([

    {"role": "user", "content": "Ceritakan tentang sejarah Indonesia"},

    {"role": "assistant", "content": "Indonesia merdeka pada 17 Agustus 1945..."}

    ])

    print(f"Hasil: {result}")

    Output: safe

    Ollama (Lokal tanpa GPU Besar)

    Anda juga bisa menjalankan Llama Guard dengan Ollama menggunakan versi quantized:

    ollama pull llama-guard3
    

    import requests
    

    import json

    def classifywithollama(prompt):

    """Klasifikasi menggunakan Ollama lokal."""

    response = requests.post(

    "http://localhost:11434/api/chat",

    json={

    "model": "llama-guard3",

    "messages": [

    {"role": "user", "content": prompt}

    ],

    "stream": False

    }

    )

    result = response.json()

    return result["message"]["content"]

    result = classifywithollama("Bagaimana cara belajar pemrograman Python?")

    print(f"Hasil: {result}")

    Penggunaan Lanjutan

    Custom Safety Taxonomy

    Salah satu kekuatan Llama Guard adalah kemampuan untuk mengkustomisasi taksonomi keamanan sesuai kebutuhan bisnis Anda:

    def classifywithcustomtaxonomy(conversation, customcategories):
    

    """Klasifikasi dengan taksonomi keamanan kustom."""

    taxonomyprompt = "<|beginoftext|>"

    taxonomyprompt += "\n\nTask: Check if there is unsafe content in the conversation.\n\n"

    taxonomyprompt += "\n"

    taxonomyprompt += customcategories

    taxonomyprompt += "\n\n\n"

    taxonomyprompt += "\n"

    taxonomyprompt += f"User: {conversation}\n"

    taxonomyprompt += "\n\n"

    taxonomyprompt += "Provide your safety assessment."

    inputs = tokenizer(taxonomyprompt, returntensors="pt").to(model.device)

    output = model.generate(

    *inputs,

    maxnewtokens=100,

    padtokenid=tokenizer.eostokenid

    )

    response = tokenizer.decode(

    output[0][inputs["inputids"].shape[-1]:],

    skipspecialtokens=True

    )

    return response.strip()

    Contoh: Taksonomi untuk platform e-commerce

    ecommercecategories = """

    O1: Penipuan dan Scam

    Konten yang mempromosikan atau memfasilitasi penipuan, phishing, atau scam online.

    O2: Review Palsu

    Konten yang merupakan review palsu atau manipulasi rating produk.

    O3: Informasi Pembayaran Ilegal

    Konten yang meminta atau membagikan informasi kartu kredit atau pembayaran secara ilegal.

    O4: Produk Terlarang

    Konten tentang jual beli produk terlarang atau illegal.

    O5: Spam dan Promosi Berlebihan

    Konten spam atau promosi yang tidak relevan dan berlebihan.

    """

    result = classifywithcustomtaxonomy(

    "Saya ingin beli akun Netflix murah, ada yang jual?",

    ecommercecategories

    )

    print(f"Hasil: {result}")

    Batch Processing untuk Skala Besar

    Untuk memproses banyak percakapan sekaligus, gunakan batch processing:

    import asyncio
    

    from concurrent.futures import ThreadPoolExecutor

    class LlamaGuardBatchClassifier:

    def init(self, model, tokenizer, batchsize=8):

    self.model = model

    self.tokenizer = tokenizer

    self.batchsize = batchsize

    def classifybatch(self, conversations):

    """Klasifikasi batch percakapan."""

    results = []

    for i in range(0, len(conversations), self.batchsize):

    batch = conversations[i:i + self.batchsize]

    batchresults = self.processbatch(batch)

    results.extend(batchresults)

    return results

    def processbatch(self, batch):

    """Proses satu batch percakapan."""

    batchresults = []

    for conversation in batch:

    chat = [{"role": "user", "content": conversation}]

    inputids = self.tokenizer.applychattemplate(

    chat,

    returntensors="pt"

    ).to(self.model.device)

    output = self.model.generate(

    inputids=inputids,

    maxnewtokens=50,

    padtokenid=self.tokenizer.eostokenid

    )

    response = self.tokenizer.decode(

    output[0][inputids.shape[-1]:],

    skipspecialtokens=True

    )

    batchresults.append({

    "conversation": conversation,

    "classification": response.strip(),

    "issafe": response.strip().lower() == "safe"

    })

    return batchresults

    Penggunaan

    classifier = LlamaGuardBatchClassifier(model, tokenizer)

    conversations = [

    "Bagaimana cara memasak rendang?",

    "Jelaskan proses fotosintesis",

    "Apa rekomendasi buku programming terbaik?",

    "Bagaimana cara mengobati sakit kepala?"

    ]

    results = classifier.classifybatch(conversations)

    for r in results:

    status = "AMAN" if r["issafe"] else "TIDAK AMAN"

    print(f"[{status}] {r['conversation'][:50]}...")

    Integrasi dengan LangChain

    Llama Guard bisa diintegrasikan ke dalam pipeline LangChain sebagai safety layer:

    from langchaincore.runnables import RunnableLambda
    

    from langchainopenai import ChatOpenAI

    class LlamaGuardChain:

    def init(self, guardclient, mainllm):

    self.guardclient = guardclient

    self.mainllm = mainllm

    def checkinput(self, userinput):

    """Cek keamanan input pengguna."""

    result = self.guardclient.chat.completions.create(

    model="meta-llama/Llama-Guard-3-8B",

    messages=[{"role": "user", "content": userinput}],

    maxtokens=50,

    )

    return result.choices[0].message.content.strip()

    def checkoutput(self, userinput, assistantoutput):

    """Cek keamanan output assistant."""

    result = self.guardclient.chat.completions.create(

    model="meta-llama/Llama-Guard-3-8B",

    messages=[

    {"role": "user", "content": userinput},

    {"role": "assistant", "content": assistantoutput}

    ],

    maxtokens=50,

    )

    return result.choices[0].message.content.strip()

    def invoke(self, userinput):

    """Pipeline lengkap: cek input -> generate -> cek output."""

    # Step 1: Cek keamanan input

    inputcheck = self.checkinput(userinput)

    if inputcheck.lower() != "safe":

    return {

    "blocked": True,

    "stage": "input",

    "reason": inputcheck,

    "response": "Maaf, permintaan Anda tidak dapat diproses karena melanggar kebijakan keamanan."

    }

    # Step 2: Generate response

    response = self.mainllm.invoke(userinput)

    assistantoutput = response.content

    # Step 3: Cek keamanan output

    outputcheck = self.checkoutput(userinput, assistantoutput)

    if outputcheck.lower() != "safe":

    return {

    "blocked": True,

    "stage": "output",

    "reason": outputcheck,

    "response": "Maaf, response tidak dapat ditampilkan karena melanggar kebijakan keamanan."

    }

    return {

    "blocked": False,

    "response": assistantoutput

    }

    Setup

    guardclient = Together(apikey="your-together-key")

    mainllm = ChatOpenAI(model="gpt-4o-mini")

    chain = LlamaGuardChain(guardclient, mainllm)

    Penggunaan

    result = chain.invoke("Jelaskan konsep machine learning untuk pemula")

    print(result)

    Integrasi dengan FastAPI

    Berikut contoh mengintegrasikan Llama Guard ke dalam API endpoint:

    from fastapi import FastAPI, HTTPException
    

    from pydantic import BaseModel

    from together import Together

    app = FastAPI()

    guardclient = Together(apikey="your-together-key")

    class ChatRequest(BaseModel):

    message: str

    conversationhistory: list[dict] = []

    class ChatResponse(BaseModel):

    response: str

    issafe: bool

    blockedreason: str | None = None

    @app.post("/chat", responsemodel=ChatResponse)

    async def chatendpoint(request: ChatRequest):

    # Cek keamanan input

    guardmessages = [{"role": "user", "content": request.message}]

    guardresult = guardclient.chat.completions.create(

    model="meta-llama/Llama-Guard-3-8B",

    messages=guardmessages,

    maxtokens=50,

    )

    classification = guardresult.choices[0].message.content.strip()

    if classification.lower() != "safe":

    raise HTTPException(

    statuscode=400,

    detail={

    "error": "Content policy violation",

    "category": classification,

    "message": "Pesan Anda melanggar kebijakan keamanan konten."

    }

    )

    # Proses pesan (ganti dengan LLM Anda)

    responsetext = await generateresponse(request.message)

    # Cek keamanan output

    outputguard = guardclient.chat.completions.create(

    model="meta-llama/Llama-Guard-3-8B",

    messages=[

    {"role": "user", "content": request.message},

    {"role": "assistant", "content": responsetext}

    ],

    maxtokens=50,

    )

    outputclassification = outputguard.choices[0].message.content.strip()

    if outputclassification.lower() != "safe":

    return ChatResponse(

    response="Maaf, saya tidak dapat memberikan response untuk pertanyaan ini.",

    issafe=False,

    blockedreason=outputclassification

    )

    return ChatResponse(

    response=responsetext,

    issafe=True

    )

    async def generateresponse(message: str) -> str:

    """Placeholder - ganti dengan LLM Anda."""

    return f"Response untuk: {message}"

    Logging dan Monitoring

    Untuk production, penting untuk melakukan logging terhadap hasil klasifikasi:

    import logging
    

    import json

    from datetime import datetime

    logging.basicConfig(level=logging.INFO)

    logger = logging.getLogger("llamaguard")

    class SafetyMonitor:

    def init(self):

    self.stats = {

    "totalchecks": 0,

    "safecount": 0,

    "unsafecount": 0,

    "categories": {}

    }

    def logclassification(self, conversation, result, checktype="input"):

    """Log hasil klasifikasi untuk monitoring."""

    self.stats["totalchecks"] += 1

    issafe = result.lower() == "safe"

    if issafe:

    self.stats["safecount"] += 1

    else:

    self.stats["unsafecount"] += 1

    category = result.split("\n")[-1] if "\n" in result else result

    self.stats["categories"][category] = self.stats["categories"].get(category, 0) + 1

    logentry = {

    "timestamp": datetime.utcnow().isoformat(),

    "checktype": checktype,

    "issafe": issafe,

    "classification": result,

    "conversationpreview": conversation[:100]

    }

    if not issafe:

    logger.warning(f"UNSAFE content detected: {json.dumps(logentry)}")

    else:

    logger.info(f"Safe content: {json.dumps(logentry)}")

    def getstats(self):

    """Dapatkan statistik keamanan."""

    total = self.stats["totalchecks"]

    if total == 0:

    return self.stats

    self.stats["safepercentage"] = round(

    (self.stats["safecount"] / total) 100, 2

    )

    self.stats["unsafepercentage"] = round(

    (self.stats["unsafecount"] / total) * 100, 2

    )

    return self.stats

    Penggunaan

    monitor = SafetyMonitor()

    Setelah setiap klasifikasi

    monitor.logclassification("Cara membuat kue", "safe", "input")

    monitor.logclassification("Query berbahaya...", "unsafe\nS1", "input")

    print(json.dumps(monitor.getstats(), indent=2))

    Best Practices

    1. Gunakan Double-Check Pattern

    Selalu cek keamanan pada input DAN output. Input yang aman bisa menghasilkan output yang tidak aman, dan sebaliknya.

    def safegenerate(userinput, llmfunction):
    

    # Cek input

    inputsafety = classifyprompt(userinput)

    if "unsafe" in inputsafety.lower():

    return "Blocked: unsafe input"

    # Generate response

    response = llmfunction(userinput)

    # Cek output

    outputsafety = classifyconversation(userinput, response)

    if "unsafe" in outputsafety.lower():

    return "Blocked: unsafe output"

    return response

    2. Implementasikan Graceful Degradation

    Jika Llama Guard mengalami error atau timeout, jangan blokir seluruh pipeline. Implementasikan fallback:

    import time
    
    

    def classifywithfallback(conversation, maxretries=3, timeout=5):

    """Klasifikasi dengan retry dan fallback."""

    for attempt in range(maxretries):

    try:

    result = classifyprompt(conversation)

    return result

    except Exception as e:

    logger.error(f"Attempt {attempt + 1} failed: {e}")

    if attempt < maxretries - 1:

    time.sleep(1)

    # Fallback: gunakan keyword filtering sederhana

    logger.warning("Llama Guard unavailable, using keyword fallback")

    return keywordbasedfilter(conversation)

    def keywordbasedfilter(text):

    """Fallback filter berbasis keyword."""

    dangerouskeywords = ["bomb", "weapon", "hack into"]

    textlower = text.lower()

    for keyword in dangerouskeywords:

    if keyword in textlower:

    return "unsafe"

    return "safe"

    3. Optimalkan Performa dengan Caching

    Untuk prompt yang sering muncul, gunakan caching:

    from functools import lrucache
    

    import hashlib

    @lrucache(maxsize=10000)

    def cachedclassify(conversationhash):

    """Klasifikasi dengan cache."""

    return classifyprompt(conversationhash)

    def classifywithcache(conversation):

    """Wrapper yang menghash percakapan untuk caching."""

    convhash = hashlib.sha256(conversation.encode()).hexdigest()

    return cachedclassify(convhash)

    4. Sesuaikan Threshold per Use Case

    Tidak semua aplikasi membutuhkan level keamanan yang sama:

    class AdaptiveSafetyFilter:
    

    """Filter keamanan yang bisa disesuaikan per context."""

    STRICTCATEGORIES = {"S1", "S3", "S4", "S9", "S11"}

    MODERATECATEGORIES = {"S2", "S5", "S7", "S10", "S12"}

    RELAXEDCATEGORIES = {"S6", "S8", "S13", "S14"}

    def init(self, mode="moderate"):

    self.mode = mode

    def shouldblock(self, classification):

    """Tentukan apakah harus diblokir berdasarkan mode."""

    if classification.lower() == "safe":

    return False

    lines = classification.strip().split("\n")

    categories = set()

    for line in lines:

    line = line.strip()

    if line.startswith("S"):

    categories.add(line)

    if self.mode == "strict":

    return len(categories) > 0

    elif self.mode == "moderate":

    return bool(categories & (self.STRICTCATEGORIES | self.MODERATECATEGORIES))

    elif self.mode == "relaxed":

    return bool(categories & self.STRICTCATEGORIES)

    return True

    Untuk chatbot anak-anak: mode strict

    kidsfilter = AdaptiveSafetyFilter(mode="strict")

    Untuk platform profesional: mode moderate

    profilter = AdaptiveSafetyFilter(mode="moderate")

    Untuk platform research: mode relaxed

    researchfilter = AdaptiveSafetyFilter(mode="relaxed")

    5. Monitor dan Iterasi

    Pantau distribusi klasifikasi secara berkala dan sesuaikan taksonomi:

    def generatesafetyreport(monitor):
    

    """Generate laporan keamanan periodik."""

    stats = monitor.getstats()

    report = f"""

    === Safety Report ===

    Total Checks: {stats['totalchecks']}

    Safe: {stats['safecount']} ({stats.get('safepercentage', 0)}%)

    Unsafe: {stats['unsafecount']} ({stats.get('unsafepercentage', 0)}%)

    Top Unsafe Categories:

    """

    sortedcats = sorted(

    stats["categories"].items(),

    key=lambda x: x[1],

    reverse=True

    )

    for cat, count in sorted_cats[:5]:

    report += f" {cat}: {count} occurrences\n"

    return report

    Perbandingan dengan Alternatif Lain

    | Fitur | Llama Guard | NVIDIA NeMo Guardrails | Guardrails AI | OpenAI Moderation |

    |-------|------------|----------------------|---------------|-------------------|

    | Open Source | Ya | Ya | Ya | Tidak (API only) |

    | Self-hosted | Ya | Ya | Ya | Tidak |

    | Custom Taxonomy | Ya | Ya | Terbatas | Tidak |

    | Multimodal | Ya (v3) | Tidak | Tidak | Ya |

    | Latency | Sedang | Rendah | Rendah | Rendah |

    | Akurasi | Tinggi | Sedang | Sedang | Tinggi |

    | Biaya | Gratis (self-hosted) | Gratis | Freemium | Per-request |

    Kesimpulan

    Llama Guard adalah tool yang sangat berharga untuk membangun aplikasi AI yang aman dan bertanggung jawab. Dengan kemampuan klasifikasi berbasis LLM, custom taxonomy, dan dukungan multimodal, Llama Guard memberikan fleksibilitas yang tidak dimiliki oleh solusi safety tradisional.

    Poin-poin penting yang perlu diingat:

    • Selalu implementasikan double-check pattern (input dan output)
    • Gunakan API cloud jika tidak memiliki GPU yang memadai
    • Sesuaikan taksonomi keamanan dengan kebutuhan bisnis Anda
    • Implementasikan monitoring dan logging untuk iterasi berkelanjutan
    • Pertimbangkan graceful degradation untuk high-availability
    • Pilih mode keamanan (strict/moderate/relaxed) sesuai use case

    Dengan mengikuti tutorial ini, Anda sudah memiliki fondasi yang kuat untuk mengintegrasikan Llama Guard ke dalam pipeline AI production Anda. Langkah selanjutnya adalah melakukan fine-tuning pada taksonomi sesuai domain spesifik Anda dan mengoptimalkan performa untuk skala yang dibutuhkan.

    Artikel Terkait

    Inspect AI: Framework Evaluasi LLM dari UK AI Safety Institute

    Inspect AI: Framework Evaluasi LLM dari UK AI Safety Institute yang Wajib Kamu Coba Temen-temen, kalau kamu udah mulai s...

    Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng

    Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng Apa itu Aisuite? Aisuite adalah library Python open...

    Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind

    Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind Google Gemma adalah keluarga model bahasa open-sou...

    Tutorial Lengkap LocalAI: Menjalankan Model AI Secara Lokal dengan API Kompatibel OpenAI

    LocalAI: Menjalankan Model AI Secara Lokal dengan API Kompatibel OpenAI Penulis: Ruby Abdullah, PT RUBYTHALIB DATA KONSU...