Add Rust extensions for TF-IDF and Linear SVM

- Implement TF-IDF vectorizer in pure Rust with PyO3 bindings
- Implement Linear SVM with LIBLINEAR-style Dual Coordinate Descent
- Achieve 88.15% accuracy on VNTC (vs sklearn's 89.48%)
- Update text_classifier.py to use new Rust backend

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

extensions/underthesea_core_extend/.gitignore

@@ -0,0 +1,5 @@
+target/
+.venv/
+__pycache__/
+*.so
+*.pyc

extensions/underthesea_core_extend/Cargo.lock

@@ -0,0 +1,351 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+ "serde",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "libc"
+version = "0.2.180"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "tinyvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "underthesea_core_extend"
+version = "0.1.0"
+dependencies = [
+ "hashbrown",
+ "pyo3",
+ "rayon",
+ "serde",
+ "serde_json",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
+
+[[package]]
+name = "zmij"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff05f8caa9038894637571ae6b9e29466c1f4f829d26c9b28f869a29cbe3445"

extensions/underthesea_core_extend/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "underthesea_core_extend"
+version = "0.1.0"
+edition = "2021"
+description = "Rust extensions for underthesea - Text Classification"
+license = "Apache-2.0"
+
+[lib]
+name = "underthesea_core_extend"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.22", features = ["extension-module"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+rayon = "1.10"
+hashbrown = { version = "0.15", features = ["serde"] }
+unicode-normalization = "0.1"
+
+[profile.release]
+lto = true
+codegen-units = 1
+opt-level = 3

extensions/underthesea_core_extend/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "underthesea_core_extend"
+version = "0.1.0"
+description = "Rust extensions for underthesea - Text Classification"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [{ name = "UnderTheSea NLP", email = "anhv.ict91@gmail.com" }]
+classifiers = [
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
+module-name = "underthesea_core_extend"

extensions/underthesea_core_extend/src/lib.rs

@@ -0,0 +1,21 @@
+//! underthesea_core_extend - Rust extensions for Vietnamese Text Classification
+//!
+//! Provides fast TF-IDF vectorization and Linear SVM classification.
+
+use pyo3::prelude::*;
+
+mod tfidf;
+mod svm;
+
+pub use tfidf::TfIdfVectorizer;
+pub use svm::{LinearSVM, SVMTrainer, FastSVMTrainer};
+
+/// Python module
+#[pymodule]
+fn underthesea_core_extend(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<TfIdfVectorizer>()?;
+    m.add_class::<LinearSVM>()?;
+    m.add_class::<SVMTrainer>()?;
+    m.add_class::<FastSVMTrainer>()?;
+    Ok(())
+}

extensions/underthesea_core_extend/src/svm.rs

@@ -0,0 +1,512 @@
+//! Optimized Linear SVM - LIBLINEAR-style Dual Coordinate Descent
+//!
+//! Pure Rust implementation of L2-regularized L2-loss SVM (dual form)
+//! Reference: "A Dual Coordinate Descent Method for Large-scale Linear SVM"
+//! Hsieh et al., ICML 2008
+
+use hashbrown::HashMap;
+use pyo3::prelude::*;
+use rayon::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::fs::File;
+use std::io::{BufReader, BufWriter};
+
+/// Sparse feature vector
+pub type SparseVec = Vec<(u32, f32)>;  // Use u32/f32 for memory efficiency
+
+/// Linear SVM Model
+#[pyclass]
+#[derive(Clone, Serialize, Deserialize)]
+pub struct LinearSVM {
+    weights: Vec<Vec<f32>>,
+    biases: Vec<f32>,
+    classes: Vec<String>,
+    n_features: usize,
+}
+
+#[pymethods]
+impl LinearSVM {
+    #[new]
+    pub fn new() -> Self {
+        Self {
+            weights: Vec::new(),
+            biases: Vec::new(),
+            classes: Vec::new(),
+            n_features: 0,
+        }
+    }
+
+    pub fn predict(&self, features: Vec<f64>) -> String {
+        let idx = self.predict_idx(&features);
+        self.classes[idx].clone()
+    }
+
+    pub fn predict_with_score(&self, features: Vec<f64>) -> (String, f64) {
+        let scores = self.decision_scores(&features);
+        let (idx, &max_score) = scores
+            .iter()
+            .enumerate()
+            .max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
+            .unwrap();
+        let confidence = 1.0 / (1.0 + (-max_score as f64).exp());
+        (self.classes[idx].clone(), confidence)
+    }
+
+    pub fn predict_batch(&self, features_batch: Vec<Vec<f64>>) -> Vec<String> {
+        features_batch
+            .par_iter()
+            .map(|f| {
+                let idx = self.predict_idx(f);
+                self.classes[idx].clone()
+            })
+            .collect()
+    }
+
+    pub fn predict_batch_sparse(&self, features_batch: Vec<Vec<(usize, f64)>>) -> Vec<String> {
+        features_batch
+            .par_iter()
+            .map(|f| {
+                let idx = self.predict_idx_sparse(f);
+                self.classes[idx].clone()
+            })
+            .collect()
+    }
+
+    pub fn predict_sparse_with_score(&self, features: Vec<(usize, f64)>) -> (String, f64) {
+        let scores = self.decision_scores_sparse(&features);
+        let (idx, &max_score) = scores
+            .iter()
+            .enumerate()
+            .max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
+            .unwrap();
+        let confidence = 1.0 / (1.0 + (-max_score as f64).exp());
+        (self.classes[idx].clone(), confidence)
+    }
+
+    pub fn decision_function(&self, features: Vec<f64>) -> Vec<f64> {
+        self.decision_scores(&features).into_iter().map(|x| x as f64).collect()
+    }
+
+    #[getter]
+    pub fn classes(&self) -> Vec<String> {
+        self.classes.clone()
+    }
+
+    #[getter]
+    pub fn n_classes(&self) -> usize {
+        self.classes.len()
+    }
+
+    #[getter]
+    pub fn n_features(&self) -> usize {
+        self.n_features
+    }
+
+    pub fn save(&self, path: &str) -> PyResult<()> {
+        let file = File::create(path)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?;
+        let writer = BufWriter::new(file);
+        serde_json::to_writer(writer, self)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?;
+        Ok(())
+    }
+
+    #[staticmethod]
+    pub fn load(path: &str) -> PyResult<Self> {
+        let file = File::open(path)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?;
+        let reader = BufReader::new(file);
+        let model: Self = serde_json::from_reader(reader)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?;
+        Ok(model)
+    }
+}
+
+impl LinearSVM {
+    #[inline]
+    fn predict_idx(&self, features: &[f64]) -> usize {
+        let mut best_idx = 0;
+        let mut best_score = f32::NEG_INFINITY;
+
+        for (idx, (w, &b)) in self.weights.iter().zip(self.biases.iter()).enumerate() {
+            let score: f32 = w.iter()
+                .zip(features.iter())
+                .map(|(&wi, &fi)| wi * fi as f32)
+                .sum::<f32>() + b;
+
+            if score > best_score {
+                best_score = score;
+                best_idx = idx;
+            }
+        }
+        best_idx
+    }
+
+    #[inline]
+    fn predict_idx_sparse(&self, features: &[(usize, f64)]) -> usize {
+        let mut best_idx = 0;
+        let mut best_score = f32::NEG_INFINITY;
+
+        for (idx, (w, &b)) in self.weights.iter().zip(self.biases.iter()).enumerate() {
+            let score: f32 = features.iter()
+                .map(|&(j, v)| w[j] * v as f32)
+                .sum::<f32>() + b;
+
+            if score > best_score {
+                best_score = score;
+                best_idx = idx;
+            }
+        }
+        best_idx
+    }
+
+    fn decision_scores(&self, features: &[f64]) -> Vec<f32> {
+        self.weights
+            .iter()
+            .zip(self.biases.iter())
+            .map(|(w, &b)| {
+                w.iter()
+                    .zip(features.iter())
+                    .map(|(&wi, &fi)| wi * fi as f32)
+                    .sum::<f32>() + b
+            })
+            .collect()
+    }
+
+    fn decision_scores_sparse(&self, features: &[(usize, f64)]) -> Vec<f32> {
+        self.weights
+            .iter()
+            .zip(self.biases.iter())
+            .map(|(w, &b)| {
+                features.iter()
+                    .map(|&(j, v)| w[j] * v as f32)
+                    .sum::<f32>() + b
+            })
+            .collect()
+    }
+}
+
+/// LIBLINEAR-style SVM Trainer
+#[pyclass]
+pub struct SVMTrainer {
+    c: f64,
+    max_iter: usize,
+    tol: f64,
+    verbose: bool,
+}
+
+#[pymethods]
+impl SVMTrainer {
+    #[new]
+    #[pyo3(signature = (c=1.0, max_iter=1000, tol=0.1, verbose=false))]
+    pub fn new(c: f64, max_iter: usize, tol: f64, verbose: bool) -> Self {
+        Self { c, max_iter, tol, verbose }
+    }
+
+    pub fn set_c(&mut self, c: f64) {
+        self.c = c;
+    }
+
+    pub fn set_max_iter(&mut self, max_iter: usize) {
+        self.max_iter = max_iter;
+    }
+
+    pub fn set_verbose(&mut self, verbose: bool) {
+        self.verbose = verbose;
+    }
+
+    pub fn train(&self, features: Vec<Vec<f64>>, labels: Vec<String>) -> LinearSVM {
+        let n_samples = features.len();
+        let n_features = if n_samples > 0 { features[0].len() } else { 0 };
+
+        // Convert to compact sparse format (f32 for memory/cache efficiency)
+        let sparse_features: Vec<SparseVec> = features
+            .par_iter()
+            .map(|dense| {
+                dense
+                    .iter()
+                    .enumerate()
+                    .filter(|&(_, &v)| v.abs() > 1e-10)
+                    .map(|(i, &v)| (i as u32, v as f32))
+                    .collect()
+            })
+            .collect();
+
+        // Precompute ||x_i||^2
+        let x_sq_norms: Vec<f32> = sparse_features
+            .par_iter()
+            .map(|x| x.iter().map(|&(_, v)| v * v).sum())
+            .collect();
+
+        // Get unique classes
+        let mut classes: Vec<String> = labels.iter().cloned().collect();
+        classes.sort();
+        classes.dedup();
+        let n_classes = classes.len();
+
+        let class_to_idx: HashMap<String, usize> = classes
+            .iter()
+            .enumerate()
+            .map(|(i, c)| (c.clone(), i))
+            .collect();
+
+        let y_idx: Vec<usize> = labels.iter().map(|l| class_to_idx[l]).collect();
+
+        // Train binary classifiers in parallel (one-vs-rest)
+        let results: Vec<(Vec<f32>, f32)> = (0..n_classes)
+            .into_par_iter()
+            .map(|class_idx| {
+                let y_binary: Vec<i8> = y_idx
+                    .iter()
+                    .map(|&idx| if idx == class_idx { 1 } else { -1 })
+                    .collect();
+
+                solve_l2r_l2_svc(
+                    &sparse_features,
+                    &y_binary,
+                    &x_sq_norms,
+                    n_features,
+                    self.c as f32,
+                    self.tol as f32,
+                    self.max_iter,
+                )
+            })
+            .collect();
+
+        let weights = results.iter().map(|(w, _)| w.clone()).collect();
+        let biases = results.iter().map(|(_, b)| *b).collect();
+
+        LinearSVM {
+            weights,
+            biases,
+            classes,
+            n_features,
+        }
+    }
+}
+
+/// LIBLINEAR's solve_l2r_l2_svc - Dual Coordinate Descent for L2-loss SVM
+///
+/// Solves: min_α 0.5 * α^T * Q * α - e^T * α, s.t. α_i ≥ 0
+/// where Q_ij = y_i * y_j * x_i^T * x_j + δ_ij / (2C)
+///
+/// Primal-dual relationship: w = Σ α_i * y_i * x_i
+#[inline(never)]
+fn solve_l2r_l2_svc(
+    x: &[SparseVec],
+    y: &[i8],
+    x_sq_norms: &[f32],
+    n_features: usize,
+    c: f32,
+    eps: f32,
+    max_iter: usize,
+) -> (Vec<f32>, f32) {
+    let n = x.len();
+
+    // D_ii = 1/(2C) for L2-loss SVM
+    let diag = 0.5 / c;
+
+    // QD[i] = ||x_i||^2 + D_ii
+    let qd: Vec<f32> = x_sq_norms.iter().map(|&xn| xn + diag).collect();
+
+    // Initialize α = 0
+    let mut alpha = vec![0.0f32; n];
+
+    // w = Σ α_i * y_i * x_i (initially 0)
+    let mut w = vec![0.0f32; n_features];
+
+    // Index for permutation
+    let mut index: Vec<usize> = (0..n).collect();
+
+    // Main loop
+    for iter in 0..max_iter {
+        // Shuffle indices
+        for i in 0..n {
+            let j = i + (iter * 1103515245 + 12345) % (n - i).max(1);
+            index.swap(i, j);
+        }
+
+        let mut max_violation = 0.0f32;
+
+        for &i in &index {
+            let yi = y[i] as f32;
+            let xi = &x[i];
+
+            // G = y_i * (w · x_i) - 1 + D_ii * α_i
+            let wxi: f32 = xi.iter().map(|&(j, v)| w[j as usize] * v).sum();
+            let g = yi * wxi - 1.0 + diag * alpha[i];
+
+            // Projected gradient (α ≥ 0, no upper bound for L2-loss)
+            let pg = if alpha[i] == 0.0 { g.min(0.0) } else { g };
+
+            max_violation = max_violation.max(pg.abs());
+
+            if pg.abs() > 1e-12 {
+                let alpha_old = alpha[i];
+
+                // α_i = max(0, α_i - G/Q_ii)
+                alpha[i] = (alpha[i] - g / qd[i]).max(0.0);
+
+                // Update w: w += (α_new - α_old) * y_i * x_i
+                let d = (alpha[i] - alpha_old) * yi;
+                if d.abs() > 1e-12 {
+                    for &(j, v) in xi.iter() {
+                        w[j as usize] += d * v;
+                    }
+                }
+            }
+        }
+
+        // Stopping criterion
+        if max_violation <= eps {
+            break;
+        }
+    }
+
+    // Compute bias from KKT conditions
+    // For α_i > 0: y_i * (w · x_i + b) = 1 - α_i / (2C)
+    let mut bias_sum = 0.0f32;
+    let mut n_sv = 0;
+
+    for i in 0..n {
+        if alpha[i] > 1e-8 {
+            let yi = y[i] as f32;
+            let wxi: f32 = x[i].iter().map(|&(j, v)| w[j as usize] * v).sum();
+            // b = y_i * (1 - α_i * diag) - w · x_i
+            bias_sum += yi * (1.0 - alpha[i] * diag) - wxi;
+            n_sv += 1;
+        }
+    }
+
+    let bias = if n_sv > 0 { bias_sum / n_sv as f32 } else { 0.0 };
+
+    (w, bias)
+}
+
+/// Fast SVM using Pegasos algorithm
+#[pyclass]
+pub struct FastSVMTrainer {
+    c: f64,
+    max_iter: usize,
+}
+
+#[pymethods]
+impl FastSVMTrainer {
+    #[new]
+    #[pyo3(signature = (c=1.0, max_iter=100))]
+    pub fn new(c: f64, max_iter: usize) -> Self {
+        Self { c, max_iter }
+    }
+
+    pub fn train(&self, features: Vec<Vec<f64>>, labels: Vec<String>) -> LinearSVM {
+        let n_samples = features.len();
+        let n_features = if n_samples > 0 { features[0].len() } else { 0 };
+
+        let sparse_features: Vec<SparseVec> = features
+            .par_iter()
+            .map(|dense| {
+                dense
+                    .iter()
+                    .enumerate()
+                    .filter(|&(_, &v)| v.abs() > 1e-10)
+                    .map(|(i, &v)| (i as u32, v as f32))
+                    .collect()
+            })
+            .collect();
+
+        let mut classes: Vec<String> = labels.iter().cloned().collect();
+        classes.sort();
+        classes.dedup();
+        let n_classes = classes.len();
+
+        let class_to_idx: HashMap<String, usize> = classes
+            .iter()
+            .enumerate()
+            .map(|(i, c)| (c.clone(), i))
+            .collect();
+
+        let y_idx: Vec<usize> = labels.iter().map(|l| class_to_idx[l]).collect();
+
+        let results: Vec<(Vec<f32>, f32)> = (0..n_classes)
+            .into_par_iter()
+            .map(|class_idx| {
+                let y_binary: Vec<i8> = y_idx
+                    .iter()
+                    .map(|&idx| if idx == class_idx { 1 } else { -1 })
+                    .collect();
+
+                pegasos(&sparse_features, &y_binary, n_features, self.c as f32, self.max_iter)
+            })
+            .collect();
+
+        LinearSVM {
+            weights: results.iter().map(|(w, _)| w.clone()).collect(),
+            biases: results.iter().map(|(_, b)| *b).collect(),
+            classes,
+            n_features,
+        }
+    }
+}
+
+/// Pegasos algorithm with lazy scaling
+#[inline(never)]
+fn pegasos(
+    x: &[SparseVec],
+    y: &[i8],
+    n_features: usize,
+    c: f32,
+    max_iter: usize,
+) -> (Vec<f32>, f32) {
+    let n = x.len();
+    let lambda = 1.0 / c;
+
+    let mut w = vec![0.0f32; n_features];
+    let mut scale = 1.0f32;
+    let mut b = 0.0f32;
+
+    let eta0 = 0.5;
+    let t0 = 1.0 / (eta0 * lambda);
+
+    let mut indices: Vec<usize> = (0..n).collect();
+
+    for epoch in 0..max_iter {
+        // Shuffle
+        for i in 0..n {
+            let j = (i + epoch * 1103515245 + 12345) % n;
+            indices.swap(i, j);
+        }
+
+        for (t_inner, &i) in indices.iter().enumerate() {
+            let t = (epoch * n + t_inner) as f32;
+            let eta = 1.0 / (lambda * (t + t0));
+
+            let yi = y[i] as f32;
+            let xi = &x[i];
+
+            let margin: f32 = scale * xi.iter().map(|&(j, v)| w[j as usize] * v).sum::<f32>() + b;
+
+            scale *= 1.0 - eta * lambda;
+
+            if scale < 1e-9 {
+                for wj in w.iter_mut() {
+                    *wj *= scale;
+                }
+                scale = 1.0;
+            }
+
+            if yi * margin < 1.0 {
+                let update = eta / scale;
+                for &(j, v) in xi.iter() {
+                    w[j as usize] += update * yi * v;
+                }
+                b += eta * yi * 0.1;
+            }
+        }
+    }
+
+    for wj in w.iter_mut() {
+        *wj *= scale;
+    }
+
+    (w, b)
+}

extensions/underthesea_core_extend/src/tfidf.rs

@@ -0,0 +1,235 @@
+//! TF-IDF Vectorizer implementation
+
+use hashbrown::HashMap;
+use pyo3::prelude::*;
+use rayon::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::fs::File;
+use std::io::{BufReader, BufWriter};
+
+/// TF-IDF Vectorizer
+///
+/// Converts text documents into TF-IDF feature vectors.
+#[pyclass]
+#[derive(Clone, Serialize, Deserialize)]
+pub struct TfIdfVectorizer {
+    /// Vocabulary: word -> index
+    vocab: HashMap<String, usize>,
+    /// Inverse vocabulary: index -> word
+    inv_vocab: Vec<String>,
+    /// IDF values for each term
+    idf: Vec<f64>,
+    /// Number of documents used for fitting
+    n_docs: usize,
+    /// Maximum number of features
+    max_features: usize,
+    /// N-gram range (min, max)
+    ngram_range: (usize, usize),
+    /// Minimum document frequency
+    min_df: usize,
+    /// Maximum document frequency (as ratio)
+    max_df: f64,
+    /// Whether the vectorizer is fitted
+    is_fitted: bool,
+}
+
+#[pymethods]
+impl TfIdfVectorizer {
+    /// Create a new TfIdfVectorizer
+    #[new]
+    #[pyo3(signature = (max_features=20000, ngram_range=(1, 2), min_df=1, max_df=1.0))]
+    pub fn new(
+        max_features: usize,
+        ngram_range: (usize, usize),
+        min_df: usize,
+        max_df: f64,
+    ) -> Self {
+        Self {
+            vocab: HashMap::new(),
+            inv_vocab: Vec::new(),
+            idf: Vec::new(),
+            n_docs: 0,
+            max_features,
+            ngram_range,
+            min_df,
+            max_df,
+            is_fitted: false,
+        }
+    }
+
+    /// Fit the vectorizer on a list of documents
+    pub fn fit(&mut self, documents: Vec<String>) {
+        let n_docs = documents.len();
+        self.n_docs = n_docs;
+
+        // Count document frequency for each term
+        let mut df: HashMap<String, usize> = HashMap::new();
+
+        for doc in &documents {
+            let tokens = self.tokenize(doc);
+            let unique_tokens: std::collections::HashSet<_> = tokens.into_iter().collect();
+            for token in unique_tokens {
+                *df.entry(token).or_insert(0) += 1;
+            }
+        }
+
+        // Filter by min_df and max_df
+        let max_df_count = (self.max_df * n_docs as f64) as usize;
+        let mut filtered: Vec<(String, usize)> = df
+            .into_iter()
+            .filter(|(_, count)| *count >= self.min_df && *count <= max_df_count)
+            .collect();
+
+        // Sort by frequency (descending) and take top max_features
+        filtered.sort_by(|a, b| b.1.cmp(&a.1));
+        filtered.truncate(self.max_features);
+
+        // Build vocabulary
+        self.vocab.clear();
+        self.inv_vocab.clear();
+        self.idf.clear();
+
+        for (idx, (term, doc_freq)) in filtered.into_iter().enumerate() {
+            self.vocab.insert(term.clone(), idx);
+            self.inv_vocab.push(term);
+            // IDF with smoothing: log((n_docs + 1) / (df + 1)) + 1
+            let idf_value = ((n_docs as f64 + 1.0) / (doc_freq as f64 + 1.0)).ln() + 1.0;
+            self.idf.push(idf_value);
+        }
+
+        self.is_fitted = true;
+    }
+
+    /// Transform a single document to TF-IDF vector (sparse format)
+    ///
+    /// Returns list of (index, value) tuples
+    pub fn transform(&self, document: &str) -> Vec<(usize, f64)> {
+        if !self.is_fitted {
+            return Vec::new();
+        }
+
+        let tokens = self.tokenize(document);
+        let mut tf: HashMap<usize, usize> = HashMap::new();
+
+        for token in &tokens {
+            if let Some(&idx) = self.vocab.get(token) {
+                *tf.entry(idx).or_insert(0) += 1;
+            }
+        }
+
+        let n_tokens = tokens.len() as f64;
+        if n_tokens == 0.0 {
+            return Vec::new();
+        }
+
+        let mut result: Vec<(usize, f64)> = tf
+            .into_iter()
+            .map(|(idx, count)| {
+                let tf_value = count as f64 / n_tokens;
+                let tfidf = tf_value * self.idf[idx];
+                (idx, tfidf)
+            })
+            .collect();
+
+        // L2 normalize
+        let norm: f64 = result.iter().map(|(_, v)| v * v).sum::<f64>().sqrt();
+        if norm > 0.0 {
+            for (_, v) in &mut result {
+                *v /= norm;
+            }
+        }
+
+        result.sort_by_key(|(idx, _)| *idx);
+        result
+    }
+
+    /// Transform a single document to dense TF-IDF vector
+    pub fn transform_dense(&self, document: &str) -> Vec<f64> {
+        let sparse = self.transform(document);
+        let mut dense = vec![0.0; self.vocab.len()];
+        for (idx, val) in sparse {
+            dense[idx] = val;
+        }
+        dense
+    }
+
+    /// Transform multiple documents to dense TF-IDF vectors (parallel)
+    pub fn transform_batch(&self, documents: Vec<String>) -> Vec<Vec<f64>> {
+        documents
+            .par_iter()
+            .map(|doc| self.transform_dense(doc))
+            .collect()
+    }
+
+    /// Transform multiple documents to sparse TF-IDF vectors (parallel)
+    pub fn transform_batch_sparse(&self, documents: Vec<String>) -> Vec<Vec<(usize, f64)>> {
+        documents
+            .par_iter()
+            .map(|doc| self.transform(doc))
+            .collect()
+    }
+
+    /// Fit and transform in one step
+    pub fn fit_transform(&mut self, documents: Vec<String>) -> Vec<Vec<f64>> {
+        self.fit(documents.clone());
+        self.transform_batch(documents)
+    }
+
+    /// Get vocabulary size
+    #[getter]
+    pub fn vocab_size(&self) -> usize {
+        self.vocab.len()
+    }
+
+    /// Get feature names (vocabulary terms)
+    pub fn get_feature_names(&self) -> Vec<String> {
+        self.inv_vocab.clone()
+    }
+
+    /// Check if vectorizer is fitted
+    #[getter]
+    pub fn is_fitted(&self) -> bool {
+        self.is_fitted
+    }
+
+    /// Save vectorizer to file
+    pub fn save(&self, path: &str) -> PyResult<()> {
+        let file = File::create(path)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?;
+        let writer = BufWriter::new(file);
+        serde_json::to_writer(writer, self)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?;
+        Ok(())
+    }
+
+    /// Load vectorizer from file
+    #[staticmethod]
+    pub fn load(path: &str) -> PyResult<Self> {
+        let file = File::open(path)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?;
+        let reader = BufReader::new(file);
+        let vectorizer: Self = serde_json::from_reader(reader)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?;
+        Ok(vectorizer)
+    }
+}
+
+impl TfIdfVectorizer {
+    /// Tokenize document into n-grams
+    fn tokenize(&self, document: &str) -> Vec<String> {
+        let words: Vec<&str> = document.split_whitespace().collect();
+        let mut tokens = Vec::new();
+
+        for n in self.ngram_range.0..=self.ngram_range.1 {
+            if n > words.len() {
+                continue;
+            }
+            for i in 0..=(words.len() - n) {
+                let ngram = words[i..i + n].join(" ");
+                tokens.push(ngram);
+            }
+        }
+
+        tokens
+    }
+}

extensions/underthesea_core_extend/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "underthesea-core-extend"
+version = "0.1.0"
+source = { editable = "." }

pyproject.toml

@@ -1,24 +1,23 @@
 [project]
 name = "sen"
-version = "1.0.0"
-description = "Vietnamese Text Classification Model"
+version = "1.1.0"
+description = "Vietnamese Text Classification Model - Rust-powered"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "Apache-2.0"
 authors = [
     {name = "UnderTheSea NLP", email = "undertheseanlp@gmail.com"}
 ]
-keywords = ["vietnamese", "nlp", "text-classification", "sklearn"]
+keywords = ["vietnamese", "nlp", "text-classification", "rust", "svm"]
 dependencies = [
-    "scikit-learn>=1.0.0",
-    "joblib>=1.0.0",
-    "numpy>=1.20.0",
+    "underthesea_core_extend>=0.1.0",
 ]
 
 [project.optional-dependencies]
 dev = [
     "pytest>=7.0.0",
     "huggingface-hub>=0.20.0",
+    "maturin>=1.0.0",
 ]
 
 [project.urls]

src/sen/text_classifier.py

@@ -1,26 +1,20 @@
 """
-Sen Text Classifier - sklearn-based classifier compatible with underthesea API.
+Sen Text Classifier - Rust-based classifier using underthesea_core_extend.
 
 Based on: "A Comparative Study on Vietnamese Text Classification Methods"
 Vu et al., RIVF 2007
 https://ieeexplore.ieee.org/document/4223084/
 
 Methods:
-- TF-IDF vectorization
-- SVM (Support Vector Machine) classifier
+- TF-IDF vectorization (Rust: underthesea_core_extend.TfIdfVectorizer)
+- Linear SVM classifier (Rust: underthesea_core_extend.LinearSVM)
 """
 
 import json
 import os
 from typing import List, Optional, Union
 
-import joblib
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.svm import LinearSVC
-from sklearn.pipeline import Pipeline
-from sklearn.preprocessing import LabelEncoder
-from sklearn.metrics import accuracy_score, f1_score, classification_report
-import numpy as np
+from underthesea_core_extend import TfIdfVectorizer, LinearSVM, SVMTrainer
 
 
 class Label:
@@ -59,8 +53,9 @@ class Sentence:
 
 class SenTextClassifier:
     """
-    sklearn-based text classifier using TF-IDF + SVM.
+    Rust-based text classifier using TF-IDF + Linear SVM.
 
+    Uses underthesea_core_extend for fast training and inference.
     Compatible with underthesea API.
 
     Reference:
@@ -71,43 +66,28 @@ class SenTextClassifier:
     def __init__(
         self,
         # TF-IDF parameters
-        max_features: int = 10000,
+        max_features: int = 20000,
         ngram_range: tuple = (1, 2),
-        min_df: int = 2,
-        max_df: float = 0.95,
-        sublinear_tf: bool = True,
+        min_df: int = 1,
+        max_df: float = 1.0,
         # SVM parameters
-        C: float = 1.0,
+        c: float = 1.0,
         max_iter: int = 1000,
+        tol: float = 0.1,
+        verbose: bool = True,
     ):
         self.max_features = max_features
         self.ngram_range = ngram_range
         self.min_df = min_df
         self.max_df = max_df
-        self.sublinear_tf = sublinear_tf
-        self.C = C
+        self.c = c
         self.max_iter = max_iter
+        self.tol = tol
+        self.verbose = verbose
 
-        self.label_encoder = LabelEncoder()
-        self.pipeline = None
-        self.labels_ = None
-
-    def _build_pipeline(self) -> Pipeline:
-        """Build sklearn pipeline with TF-IDF + SVM."""
-        return Pipeline([
-            ("tfidf", TfidfVectorizer(
-                max_features=self.max_features,
-                ngram_range=self.ngram_range,
-                min_df=self.min_df,
-                max_df=self.max_df,
-                sublinear_tf=self.sublinear_tf,
-            )),
-            ("clf", LinearSVC(
-                C=self.C,
-                max_iter=self.max_iter,
-                random_state=42,
-            )),
-        ])
+        self.vectorizer: Optional[TfIdfVectorizer] = None
+        self.classifier: Optional[LinearSVM] = None
+        self.labels_: Optional[List[str]] = None
 
     def train(
         self,
@@ -128,38 +108,58 @@ class SenTextClassifier:
         Returns:
             Dictionary with training metrics
         """
-        # Encode labels
-        y_train = self.label_encoder.fit_transform(train_labels)
-        self.labels_ = list(self.label_encoder.classes_)
+        # Get unique labels
+        self.labels_ = sorted(list(set(train_labels)))
+
+        # Build and fit vectorizer
+        self.vectorizer = TfIdfVectorizer(
+            max_features=self.max_features,
+            ngram_range=self.ngram_range,
+            min_df=self.min_df,
+            max_df=self.max_df,
+        )
+        self.vectorizer.fit(train_texts)
+
+        # Transform to features
+        train_features = self.vectorizer.transform_batch(train_texts)
 
-        # Build and train pipeline
-        self.pipeline = self._build_pipeline()
-        self.pipeline.fit(train_texts, y_train)
+        # Build and train SVM model
+        trainer = SVMTrainer(
+            c=self.c,
+            max_iter=self.max_iter,
+            tol=self.tol,
+            verbose=self.verbose,
+        )
+        self.classifier = trainer.train(train_features, train_labels)
 
         # Calculate training metrics
-        y_train_pred = self.pipeline.predict(train_texts)
-        train_acc = accuracy_score(y_train, y_train_pred)
-        train_f1 = f1_score(y_train, y_train_pred, average="weighted")
+        train_preds = self.classifier.predict_batch(train_features)
+        train_acc = sum(1 for p, t in zip(train_preds, train_labels) if p == t) / len(train_labels)
+
+        # Calculate F1 score
+        train_f1 = self._calculate_f1(train_labels, train_preds)
 
         results = {
             "train_accuracy": train_acc,
             "train_f1": train_f1,
             "num_classes": len(self.labels_),
             "num_samples": len(train_texts),
+            "vocab_size": self.vectorizer.vocab_size,
         }
 
         print(f"Training completed:")
         print(f"  - Samples: {len(train_texts)}")
         print(f"  - Classes: {len(self.labels_)}")
+        print(f"  - Vocab size: {self.vectorizer.vocab_size}")
         print(f"  - Train accuracy: {train_acc:.4f}")
         print(f"  - Train F1: {train_f1:.4f}")
 
         # Validation metrics
         if val_texts and val_labels:
-            y_val = self.label_encoder.transform(val_labels)
-            y_val_pred = self.pipeline.predict(val_texts)
-            val_acc = accuracy_score(y_val, y_val_pred)
-            val_f1 = f1_score(y_val, y_val_pred, average="weighted")
+            val_features = self.vectorizer.transform_batch(val_texts)
+            val_preds = self.classifier.predict_batch(val_features)
+            val_acc = sum(1 for p, t in zip(val_preds, val_labels) if p == t) / len(val_labels)
+            val_f1 = self._calculate_f1(val_labels, val_preds)
 
             results["val_accuracy"] = val_acc
             results["val_f1"] = val_f1
@@ -169,6 +169,28 @@ class SenTextClassifier:
 
         return results
 
+    def _calculate_f1(self, y_true: List[str], y_pred: List[str]) -> float:
+        """Calculate weighted F1 score."""
+        from collections import Counter
+
+        label_counts = Counter(y_true)
+        total = len(y_true)
+
+        f1_sum = 0.0
+        for label in self.labels_:
+            tp = sum(1 for t, p in zip(y_true, y_pred) if t == label and p == label)
+            fp = sum(1 for t, p in zip(y_true, y_pred) if t != label and p == label)
+            fn = sum(1 for t, p in zip(y_true, y_pred) if t == label and p != label)
+
+            precision = tp / (tp + fp) if (tp + fp) > 0 else 0
+            recall = tp / (tp + fn) if (tp + fn) > 0 else 0
+            f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
+
+            weight = label_counts[label] / total
+            f1_sum += f1 * weight
+
+        return f1_sum
+
     def predict(self, sentence: Sentence) -> None:
         """
         Predict label for a sentence (underthesea-compatible API).
@@ -176,23 +198,11 @@ class SenTextClassifier:
         Args:
             sentence: Sentence object with text attribute
         """
-        if self.pipeline is None:
+        if self.classifier is None or self.vectorizer is None:
             raise ValueError("Model not trained. Call train() first or load a model.")
 
-        pred_idx = self.pipeline.predict([sentence.text])[0]
-        label_value = self.label_encoder.inverse_transform([pred_idx])[0]
-
-        # Get confidence score using decision function
-        try:
-            decision = self.pipeline.decision_function([sentence.text])[0]
-            if isinstance(decision, np.ndarray):
-                score = float(np.max(np.abs(decision)))
-            else:
-                score = float(abs(decision))
-            # Normalize to 0-1 range using sigmoid
-            score = 1 / (1 + np.exp(-score))
-        except Exception:
-            score = 1.0
+        features = self.vectorizer.transform_dense(sentence.text)
+        label_value, score = self.classifier.predict_with_score(features)
 
         sentence.labels = []
         sentence.add_labels([Label(label_value, score)])
@@ -207,23 +217,17 @@ class SenTextClassifier:
         Returns:
             List of Label objects
         """
-        if self.pipeline is None:
+        if self.classifier is None or self.vectorizer is None:
             raise ValueError("Model not trained. Call train() first or load a model.")
 
-        pred_indices = self.pipeline.predict(texts)
-        label_values = self.label_encoder.inverse_transform(pred_indices)
-
-        # Get confidence scores
-        try:
-            decisions = self.pipeline.decision_function(texts)
-            if decisions.ndim == 1:
-                scores = 1 / (1 + np.exp(-np.abs(decisions)))
-            else:
-                scores = 1 / (1 + np.exp(-np.max(np.abs(decisions), axis=1)))
-        except Exception:
-            scores = [1.0] * len(texts)
+        # Use dense transform (faster Python-Rust interface)
+        features = self.vectorizer.transform_batch(texts)
+        results = []
+        for feat in features:
+            label_value, score = self.classifier.predict_with_score(feat)
+            results.append(Label(label_value, float(score)))
 
-        return [Label(val, float(score)) for val, score in zip(label_values, scores)]
+        return results
 
     def evaluate(self, texts: List[str], labels: List[str]) -> dict:
         """
@@ -236,23 +240,46 @@ class SenTextClassifier:
         Returns:
             Dictionary with evaluation metrics
         """
-        y_true = self.label_encoder.transform(labels)
-        y_pred = self.pipeline.predict(texts)
+        # Use dense transform (faster Python-Rust interface)
+        features = self.vectorizer.transform_batch(texts)
+        y_pred = self.classifier.predict_batch(features)
 
-        acc = accuracy_score(y_true, y_pred)
-        f1 = f1_score(y_true, y_pred, average="weighted")
+        acc = sum(1 for p, t in zip(y_pred, labels) if p == t) / len(labels)
+        f1 = self._calculate_f1(labels, y_pred)
 
         print(f"Evaluation:")
         print(f"  - Accuracy: {acc:.4f}")
         print(f"  - F1 (weighted): {f1:.4f}")
-        print("\nClassification Report:")
-        print(classification_report(
-            y_true, y_pred,
-            target_names=self.labels_
-        ))
+
+        # Print classification report
+        self._print_classification_report(labels, y_pred)
 
         return {"accuracy": acc, "f1": f1}
 
+    def _print_classification_report(self, y_true: List[str], y_pred: List[str]):
+        """Print classification report."""
+        from collections import Counter
+
+        print("\nClassification Report:")
+        print(f"{'':>20} {'precision':>10} {'recall':>10} {'f1-score':>10} {'support':>10}")
+        print()
+
+        label_counts = Counter(y_true)
+
+        for label in self.labels_:
+            tp = sum(1 for t, p in zip(y_true, y_pred) if t == label and p == label)
+            fp = sum(1 for t, p in zip(y_true, y_pred) if t != label and p == label)
+            fn = sum(1 for t, p in zip(y_true, y_pred) if t == label and p != label)
+
+            precision = tp / (tp + fp) if (tp + fp) > 0 else 0
+            recall = tp / (tp + fn) if (tp + fn) > 0 else 0
+            f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
+            support = label_counts[label]
+
+            print(f"{label:>20} {precision:>10.2f} {recall:>10.2f} {f1:>10.2f} {support:>10}")
+
+        print()
+
     def save(self, path: str) -> None:
         """
         Save model to disk.
@@ -262,23 +289,25 @@ class SenTextClassifier:
         """
         os.makedirs(path, exist_ok=True)
 
-        # Save pipeline
-        joblib.dump(self.pipeline, os.path.join(path, "pipeline.joblib"))
+        # Save vectorizer
+        self.vectorizer.save(os.path.join(path, "vectorizer.json"))
 
-        # Save label encoder
-        joblib.dump(self.label_encoder, os.path.join(path, "label_encoder.joblib"))
+        # Save classifier
+        self.classifier.save(os.path.join(path, "classifier.json"))
 
         # Save metadata
         metadata = {
-            "estimator": "PIPELINE",
+            "estimator": "RUST_SVM",
             "max_features": self.max_features,
             "ngram_range": self.ngram_range,
             "min_df": self.min_df,
             "max_df": self.max_df,
-            "sublinear_tf": self.sublinear_tf,
-            "C": self.C,
+            "c": self.c,
             "max_iter": self.max_iter,
+            "tol": self.tol,
             "labels": self.labels_,
+            "vocab_size": self.vectorizer.vocab_size,
+            "n_classes": self.classifier.n_classes,
         }
         with open(os.path.join(path, "metadata.json"), "w", encoding="utf-8") as f:
             json.dump(metadata, f, ensure_ascii=False, indent=2)
@@ -302,19 +331,21 @@ class SenTextClassifier:
 
         # Create instance with saved parameters
         classifier = cls(
-            max_features=metadata.get("max_features", 10000),
+            max_features=metadata.get("max_features", 20000),
             ngram_range=tuple(metadata.get("ngram_range", (1, 2))),
-            min_df=metadata.get("min_df", 2),
-            max_df=metadata.get("max_df", 0.95),
-            sublinear_tf=metadata.get("sublinear_tf", True),
-            C=metadata.get("C", 1.0),
+            min_df=metadata.get("min_df", 1),
+            max_df=metadata.get("max_df", 1.0),
+            c=metadata.get("c", 1.0),
             max_iter=metadata.get("max_iter", 1000),
+            tol=metadata.get("tol", 0.1),
         )
 
-        # Load pipeline and label encoder
-        classifier.pipeline = joblib.load(os.path.join(path, "pipeline.joblib"))
-        classifier.label_encoder = joblib.load(os.path.join(path, "label_encoder.joblib"))
-        classifier.labels_ = metadata.get("labels", list(classifier.label_encoder.classes_))
+        # Load vectorizer
+        classifier.vectorizer = TfIdfVectorizer.load(os.path.join(path, "vectorizer.json"))
+
+        # Load SVM model
+        classifier.classifier = LinearSVM.load(os.path.join(path, "classifier.json"))
+        classifier.labels_ = metadata.get("labels", [])
 
         print(f"Model loaded from: {path}")
         return classifier