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:
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 }]
Embeddings dan Semantic Search
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]
Implementasi Semantic Search
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: cos
sim(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 (
)}
);
}
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}
Analisis
);
}
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.