Tutorial Lengkap Transformers.js: Menjalankan Model AI Langsung di Browser dan Node.js

# Tutorial Lengkap Transformers.js: Menjalankan Model AI Langsung di Browser dan Node.js Transformers.js adalah library open-source yang memungkinkan Anda menjalankan model-model Hugging Face langsun...

By Ruby Abdullah · · tutorial
Transformers.jsHugging FaceWebGPUJavaScriptBrowser AI

Tutorial Lengkap Transformers.js: Menjalankan Model AI Langsung di Browser dan Node.js

Transformers.js adalah library open-source yang memungkinkan Anda menjalankan model-model Hugging Face langsung di browser atau Node.js tanpa membutuhkan server GPU. Library ini menggunakan ONNX Runtime sebagai backend, sehingga model dapat berjalan efisien di CPU maupun WebGPU. Dalam tutorial ini, kita akan mempelajari cara menggunakan Transformers.js mulai dari instalasi hingga implementasi fitur-fitur canggih seperti text generation, image classification, dan speech recognition.

Mengapa Transformers.js?

Sebelum kita mulai, ada beberapa alasan mengapa Transformers.js layak dipertimbangkan dalam proyek Anda:

  • Privasi Data: Semua inferensi dilakukan secara lokal, data pengguna tidak perlu dikirim ke server eksternal
  • Tanpa Biaya Server GPU: Tidak perlu menyewa GPU cloud untuk menjalankan model AI
  • Latensi Rendah: Tidak ada network round-trip karena model berjalan di perangkat pengguna
  • Offline Capable: Setelah model di-download, aplikasi bisa berjalan tanpa koneksi internet
  • Kompatibilitas Luas: Mendukung lebih dari 1000 model dari Hugging Face Hub dalam format ONNX
  • Instalasi

    Instalasi untuk Node.js

    npm install @huggingface/transformers
    

    Instalasi untuk Deno

    import { pipeline } from "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3";
    

    Penggunaan di Browser via CDN

    Penggunaan dengan Bundler (Webpack/Vite)

    npm install @huggingface/transformers
    

    import { pipeline } from "@huggingface/transformers";
    

    Basic Usage: Pipeline API

    Pipeline API adalah cara termudah untuk menggunakan Transformers.js. Pipeline menyederhanakan proses loading model dan tokenizer menjadi satu fungsi yang mudah digunakan.

    Text Classification (Analisis Sentimen)

    import { pipeline } from "@huggingface/transformers";
    
    

    const classifier = await pipeline("sentiment-analysis");

    const result = await classifier("Produk ini sangat bagus dan berkualitas!");

    console.log(result);

    // Output: [{ label: 'POSITIVE', score: 0.9998 }]

    const results = await classifier([

    "Saya sangat senang dengan layanan ini",

    "Pengiriman sangat lambat dan mengecewakan"

    ]);

    console.log(results);

    // Output: [

    // { label: 'POSITIVE', score: 0.9995 },

    // { label: 'NEGATIVE', score: 0.9987 }

    // ]

    Text Generation

    import { pipeline } from "@huggingface/transformers";
    
    

    const generator = await pipeline("text-generation", "Xenova/gpt2");

    const output = await generator("Machine learning adalah", {

    maxnewtokens: 50,

    temperature: 0.7,

    topk: 50,

    });

    console.log(output[0].generatedtext);

    Question Answering

    import { pipeline } from "@huggingface/transformers";
    
    

    const qa = await pipeline("question-answering");

    const answer = await qa({

    question: "Siapa penemu machine learning?",

    context: "Arthur Samuel adalah ilmuwan Amerika yang pada tahun 1959 menciptakan istilah machine learning. Ia mendefinisikannya sebagai bidang studi yang memberikan komputer kemampuan untuk belajar tanpa diprogram secara eksplisit."

    });

    console.log(answer);

    // Output: { answer: 'Arthur Samuel', score: 0.95, start: 0, end: 14 }

    Translation

    import { pipeline } from "@huggingface/transformers";
    
    

    const translator = await pipeline(

    "translation",

    "Xenova/nllb-200-distilled-600M"

    );

    const result = await translator("Artificial intelligence is transforming the world.", {

    srclang: "engLatn",

    tgtlang: "indLatn",

    });

    console.log(result[0].translationtext);

    // Output: "Kecerdasan buatan mengubah dunia."

    Summarization

    import { pipeline } from "@huggingface/transformers";
    
    

    const summarizer = await pipeline("summarization", "Xenova/distilbart-cnn-6-6");

    const article =

    Machine learning telah menjadi teknologi yang sangat penting dalam berbagai industri.

    Dari kesehatan hingga keuangan, model-model AI digunakan untuk menganalisis data,

    membuat prediksi, dan mengotomatisasi proses bisnis. Pertumbuhan adopsi machine learning

    didorong oleh ketersediaan data yang melimpah, peningkatan daya komputasi, dan kemajuan

    dalam algoritma deep learning. Perusahaan-perusahaan besar seperti Google, Meta, dan

    Microsoft terus berinvestasi dalam riset AI untuk mengembangkan model yang lebih canggih.

    ;

    const summary = await summarizer(article, {

    maxlength: 50,

    minlength: 20,

    });

    console.log(summary[0].summarytext);

    Fitur Computer Vision

    Transformers.js tidak hanya mendukung NLP, tetapi juga berbagai task computer vision.

    Image Classification

    import { pipeline } from "@huggingface/transformers";
    
    

    const classifier = await pipeline(

    "image-classification",

    "Xenova/vit-base-patch16-224"

    );

    const result = await classifier("https://example.com/cat.jpg");

    console.log(result);

    // Output: [{ label: 'Egyptian cat', score: 0.89 }, ...]

    Object Detection

    import { pipeline } from "@huggingface/transformers";
    
    

    const detector = await pipeline(

    "object-detection",

    "Xenova/detr-resnet-50"

    );

    const result = await detector("https://example.com/street.jpg");

    console.log(result);

    // Output: [

    // { label: 'car', score: 0.95, box: { xmin: 10, ymin: 20, xmax: 200, ymax: 150 } },

    // { label: 'person', score: 0.92, box: { xmin: 250, ymin: 30, xmax: 350, ymax: 200 } }

    // ]

    Image Segmentation

    import { pipeline } from "@huggingface/transformers";
    
    

    const segmenter = await pipeline(

    "image-segmentation",

    "Xenova/detr-resnet-50-panoptic"

    );

    const result = await segmenter("https://example.com/room.jpg");

    console.log(result);

    // Output: Array of segments with labels and masks

    Fitur Audio

    Speech Recognition (Automatic Speech Recognition)

    import { pipeline } from "@huggingface/transformers";
    
    

    const transcriber = await pipeline(

    "automatic-speech-recognition",

    "Xenova/whisper-small"

    );

    const result = await transcriber("audiosample.wav");

    console.log(result.text);

    // Output: "Halo, selamat datang di tutorial Transformers.js"

    Audio Classification

    import { pipeline } from "@huggingface/transformers";
    
    

    const audioClassifier = await pipeline(

    "audio-classification",

    "Xenova/wav2vec2-large-xlsr-53-gender-recognition-librispeech"

    );

    const result = await audioClassifier("audiosample.wav");

    console.log(result);

    // Output: [{ label: 'male', score: 0.95 }, { label: 'female', score: 0.05 }]

    Salah satu penggunaan paling populer dari Transformers.js adalah menghasilkan embeddings untuk semantic search.

    Feature Extraction (Embeddings)

    import { pipeline } from "@huggingface/transformers";
    
    

    const extractor = await pipeline(

    "feature-extraction",

    "Xenova/all-MiniLM-L6-v2"

    );

    const embedding = await extractor("Tutorial machine learning untuk pemula", {

    pooling: "mean",

    normalize: true,

    });

    console.log(embedding.dims); // [1, 384]

    import { pipeline, cossim } from "@huggingface/transformers";
    
    

    const extractor = await pipeline(

    "feature-extraction",

    "Xenova/all-MiniLM-L6-v2"

    );

    const documents = [

    "Python adalah bahasa pemrograman yang populer untuk data science",

    "JavaScript digunakan untuk pengembangan web frontend dan backend",

    "Machine learning membutuhkan dataset yang besar untuk training",

    "Docker memudahkan deployment aplikasi dalam container",

    "Neural network terinspirasi dari cara kerja otak manusia"

    ];

    const query = "Bagaimana cara melatih model AI?";

    async function semanticSearch(query, documents) {

    const queryEmbedding = await extractor(query, {

    pooling: "mean",

    normalize: true,

    });

    const docEmbeddings = await Promise.all(

    documents.map(doc =>

    extractor(doc, { pooling: "mean", normalize: true })

    )

    );

    const scores = docEmbeddings.map((docEmb, i) => ({

    document: documents[i],

    score: cossim(queryEmbedding.data, docEmb.data),

    }));

    return scores.sort((a, b) => b.score - a.score);

    }

    const results = await semanticSearch(query, documents);

    console.log("Hasil pencarian semantik:");

    results.forEach((r, i) => {

    console.log(${i + 1}. [${r.score.toFixed(4)}] ${r.document});

    });

    Advanced Usage

    Konfigurasi Model dan Quantization

    Transformers.js mendukung model quantized untuk ukuran yang lebih kecil dan inferensi yang lebih cepat.

    import { pipeline, env } from "@huggingface/transformers";
    
    

    env.allowLocalModels = false;

    const classifier = await pipeline("sentiment-analysis", "Xenova/distilbert-base-uncased-finetuned-sst-2-english", {

    dtype: "q8", // gunakan quantized 8-bit

    device: "webgpu", // gunakan WebGPU jika tersedia

    });

    Konfigurasi Cache

    import { env } from "@huggingface/transformers";
    
    

    env.cacheDir = "./modelscache";

    env.useBrowserCache = true;

    Menggunakan WebGPU untuk Akselerasi

    WebGPU memberikan akselerasi signifikan untuk inferensi model. Berikut cara mengaktifkannya:

    import { pipeline } from "@huggingface/transformers";
    
    

    const classifier = await pipeline("sentiment-analysis", "model-name", {

    device: "webgpu",

    });

    const result = await classifier("Teks untuk dianalisis");

    console.log(result);

    Untuk mengecek apakah WebGPU tersedia:

    if (navigator.gpu) {
    

    console.log("WebGPU tersedia, menggunakan akselerasi GPU");

    } else {

    console.log("WebGPU tidak tersedia, fallback ke CPU");

    }

    Streaming Text Generation

    import { pipeline, TextStreamer } from "@huggingface/transformers";
    
    

    const generator = await pipeline(

    "text-generation",

    "Xenova/Phi-3-mini-4k-instruct",

    { dtype: "q4" }

    );

    const streamer = new TextStreamer(generator.tokenizer, {

    skipprompt: true,

    callbackfunction: (text) => {

    process.stdout.write(text);

    },

    });

    await generator("Jelaskan apa itu machine learning dalam 3 kalimat:", {

    maxnewtokens: 128,

    streamer,

    });

    Custom Model Loading

    import {
    

    AutoTokenizer,

    AutoModelForSequenceClassification,

    } from "@huggingface/transformers";

    const tokenizer = await AutoTokenizer.frompretrained("Xenova/bert-base-uncased");

    const model = await AutoModelForSequenceClassification.frompretrained(

    "Xenova/bert-base-uncased",

    { dtype: "q8" }

    );

    const inputs = tokenizer("Transformers.js sangat mudah digunakan!");

    const { logits } = await model(inputs);

    console.log("Logits:", logits.data);

    Integrasi dengan Framework Web

    React + Transformers.js

    import { useState, useEffect, useRef } from "react";
    

    import { pipeline } from "@huggingface/transformers";

    function SentimentAnalyzer() {

    const [result, setResult] = useState(null);

    const [loading, setLoading] = useState(true);

    const classifierRef = useRef(null);

    useEffect(() => {

    async function loadModel() {

    classifierRef.current = await pipeline("sentiment-analysis");

    setLoading(false);

    }

    loadModel();

    }, []);

    async function analyze(text) {

    if (!classifierRef.current) return;

    const output = await classifierRef.current(text);

    setResult(output[0]);

    }

    if (loading) return

    Loading model...

    ;

    return (

    onChange={(e) => analyze(e.target.value)}

    placeholder="Ketik teks untuk dianalisis..."

    />

    {result && (

    Sentimen: {result.label} (Confidence: {(result.score * 100).toFixed(1)}%)

    )}

    );

    }

    Next.js + Web Worker

    Untuk performa yang lebih baik, jalankan model di Web Worker agar tidak memblokir UI thread:

    // worker.js
    

    import { pipeline } from "@huggingface/transformers";

    let classifier = null;

    self.onmessage = async (event) => {

    if (!classifier) {

    self.postMessage({ status: "loading" });

    classifier = await pipeline("sentiment-analysis");

    self.postMessage({ status: "ready" });

    }

    if (event.data.type === "classify") {

    const result = await classifier(event.data.text);

    self.postMessage({ status: "result", data: result });

    }

    };

    // component.jsx
    

    import { useEffect, useRef, useState } from "react";

    export default function ClassifierComponent() {

    const workerRef = useRef(null);

    const [status, setStatus] = useState("initializing");

    useEffect(() => {

    workerRef.current = new Worker(

    new URL("./worker.js", import.meta.url),

    { type: "module" }

    );

    workerRef.current.onmessage = (event) => {

    if (event.data.status === "ready") setStatus("ready");

    if (event.data.status === "result") {

    console.log("Result:", event.data.data);

    }

    };

    return () => workerRef.current?.terminate();

    }, []);

    function classify(text) {

    workerRef.current?.postMessage({ type: "classify", text });

    }

    return (

    Status: {status}

    );

    }

    Proyek Praktis: Chatbot Lokal dengan RAG

    Berikut contoh membangun chatbot sederhana yang berjalan sepenuhnya di browser menggunakan RAG (Retrieval-Augmented Generation):

    import { pipeline, cossim } from "@huggingface/transformers";
    
    

    class LocalRAGChatbot {

    constructor() {

    this.embedder = null;

    this.generator = null;

    this.knowledgeBase = [];

    this.embeddings = [];

    }

    async initialize() {

    console.log("Loading embedding model...");

    this.embedder = await pipeline(

    "feature-extraction",

    "Xenova/all-MiniLM-L6-v2"

    );

    console.log("Loading text generation model...");

    this.generator = await pipeline(

    "text2text-generation",

    "Xenova/flan-t5-small"

    );

    console.log("Chatbot siap digunakan!");

    }

    async addDocument(text) {

    const embedding = await this.embedder(text, {

    pooling: "mean",

    normalize: true,

    });

    this.knowledgeBase.push(text);

    this.embeddings.push(embedding);

    }

    async findRelevantDocs(query, topK = 3) {

    const queryEmbedding = await this.embedder(query, {

    pooling: "mean",

    normalize: true,

    });

    const scores = this.embeddings.map((emb, i) => ({

    index: i,

    score: cossim(queryEmbedding.data, emb.data),

    }));

    return scores

    .sort((a, b) => b.score - a.score)

    .slice(0, topK)

    .map((s) => this.knowledgeBase[s.index]);

    }

    async chat(query) {

    const relevantDocs = await this.findRelevantDocs(query);

    const context = relevantDocs.join("\n");

    const prompt = Based on the following context, answer the question.

    Context: ${context}

    Question: ${query}

    Answer:;

    const response = await this.generator(prompt, {

    maxnewtokens: 100,

    });

    return response[0].generatedtext;

    }

    }

    // Penggunaan

    const chatbot = new LocalRAGChatbot();

    await chatbot.initialize();

    await chatbot.addDocument("Transformers.js mendukung lebih dari 1000 model dari Hugging Face.");

    await chatbot.addDocument("WebGPU memberikan akselerasi GPU untuk inferensi di browser.");

    await chatbot.addDocument("Model quantized 4-bit memiliki ukuran 75% lebih kecil dari model asli.");

    const answer = await chatbot.chat("Berapa banyak model yang didukung?");

    console.log(answer);

    Best Practices

    1. Optimasi Ukuran Model

    Selalu gunakan model quantized untuk aplikasi production di browser:

    const pipe = await pipeline("task", "model-name", {
    

    dtype: "q4",

    });

    Perbandingan ukuran model:

    • fp32: Ukuran penuh (baseline)
    • fp16: 50% dari fp32
    • q8: 25% dari fp32
    • q4: 12.5% dari fp32

    2. Lazy Loading dan Caching

    let classifierInstance = null;
    
    

    async function getClassifier() {

    if (!classifierInstance) {

    classifierInstance = await pipeline("sentiment-analysis");

    }

    return classifierInstance;

    }

    3. Gunakan Web Worker untuk Task Berat

    Selalu jalankan inferensi model di Web Worker untuk menjaga responsivitas UI. Jangan pernah menjalankan model di main thread untuk aplikasi production.

    4. Progress Callback untuk UX

    const classifier = await pipeline("sentiment-analysis", "model-name", {
    

    progress_callback: (progress) => {

    if (progress.status === "downloading") {

    console.log(Downloading: ${(progress.progress).toFixed(1)}%);

    }

    if (progress.status === "ready") {

    console.log("Model loaded!");

    }

    },

    });

    5. Error Handling

    async function safeInference(text) {
    

    try {

    const classifier = await pipeline("sentiment-analysis");

    return await classifier(text);

    } catch (error) {

    if (error.message.includes("WebGPU")) {

    console.warn("WebGPU tidak tersedia, menggunakan CPU");

    const classifier = await pipeline("sentiment-analysis", null, {

    device: "cpu",

    });

    return await classifier(text);

    }

    throw error;

    }

    }

    6. Batasi Panjang Input

    function truncateInput(text, maxLength = 512) {
    

    const words = text.split(" ");

    if (words.length > maxLength) {

    return words.slice(0, maxLength).join(" ");

    }

    return text;

    }

    Perbandingan dengan Solusi Cloud API

    | Aspek | Transformers.js (Lokal) | Cloud API |

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

    | Privasi | Data tetap di perangkat | Data dikirim ke server |

    | Biaya | Gratis | Bayar per request |

    | Latensi | Rendah (tanpa network) | Tergantung jaringan |

    | Ukuran Model | Terbatas (~2GB max) | Tidak terbatas |

    | Akurasi | Model lebih kecil | Model besar dan akurat |

    | Offline | Bisa | Tidak bisa |

    Troubleshooting

    Model Tidak Bisa Di-download

    import { env } from "@huggingface/transformers";
    

    env.useBrowserCache = false;

    env.useCustomCache = false;

    Out of Memory di Browser

    Gunakan model yang lebih kecil atau quantized:

    const pipe = await pipeline("task", "model-kecil", {
    

    dtype: "q4",

    });

    WebGPU Tidak Tersedia

    Pastikan browser mendukung WebGPU (Chrome 113+, Edge 113+). Untuk browser yang tidak mendukung, Transformers.js otomatis fallback ke WASM/CPU.

    Kesimpulan

    Transformers.js membuka kemungkinan baru untuk menjalankan model AI langsung di browser dan Node.js tanpa ketergantungan pada server GPU. Dengan dukungan lebih dari 1000 model dari Hugging Face Hub, quantization untuk efisiensi, dan akselerasi WebGPU, library ini menjadi pilihan yang sangat baik untuk membangun aplikasi AI yang mengutamakan privasi dan performa.

    Beberapa poin penting yang perlu diingat:

    • Gunakan Pipeline API untuk kemudahan penggunaan
    • Selalu gunakan model quantized untuk aplikasi browser
    • Jalankan inferensi di Web Worker untuk menjaga responsivitas UI
    • Manfaatkan WebGPU untuk akselerasi jika tersedia
    • Pertimbangkan trade-off antara ukuran model dan akurasi

    Dengan Transformers.js, Anda dapat membangun aplikasi AI yang powerful sepenuhnya di sisi client, mulai dari analisis sentimen, semantic search, hingga chatbot dengan RAG, semua berjalan di browser pengguna.

    Artikel Terkait

    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 Hugging Face AutoTrain: Fine-Tuning Model AI Tanpa Ribet

    Tutorial Lengkap Hugging Face AutoTrain: Fine-Tuning Model AI Tanpa Ribet Hugging Face AutoTrain adalah platform dan lib...

    Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom

    Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom Model bahasa besar (LLM) open-source terus berk...

    Tutorial Text Generation Inference (TGI): Serving LLM untuk Produksi

    Menyajikan LLM di Produksi dengan Text Generation Inference (TGI) Text Generation Inference (TGI) adalah toolkit buatan ...