w-cluster 1.0.19 → 1.0.21

package/g-cluster-kMeans-large.mjs

@@ -0,0 +1,83 @@
+import WCluster from './src/WCluster.mjs'
+
+
+//針對「較大的數值數據」以 k-means 分群, 並記錄耗時
+//k-means以算術平均更新中心, 適用數值(歐氏)資料; 給定seed使結果可重現
+
+
+//確定性PRNG(mulberry32), 使資料可重現
+function mulberry32(a) {
+    return function() {
+        a |= 0
+        a = a + 0x6D2B79F5 | 0
+        let t = Math.imul(a ^ a >>> 15, 1 | a)
+        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t
+        return ((t ^ t >>> 14) >>> 0) / 4294967296
+    }
+}
+
+//產生G個分離良好的數值blob(交錯排列), 回傳{data, truth}
+function genBlobs(G, m, D, sep, jit, seed) {
+    let rnd = mulberry32(seed)
+    let centers = []
+    for (let g = 0; g < G; g++) {
+        centers.push(Array.from({ length: D }, (_, d) => g * sep + d * 3))
+    }
+    let data = []
+    let truth = []
+    for (let i = 0; i < m; i++) {
+        for (let g = 0; g < G; g++) {
+            data.push(centers[g].map((c) => c + (rnd() * 2 - 1) * jit))
+            truth.push(g)
+        }
+    }
+    return { data, truth }
+}
+
+//cluster purity(各分群以多數ground-truth標籤計, 全對為1)
+function purity(ginds, truth) {
+    let correct = 0
+    let n = truth.length
+    for (let g of ginds) {
+        let cnt = {}
+        for (let i of g) {
+            cnt[truth[i]] = (cnt[truth[i]] || 0) + 1
+        }
+        correct += Math.max(...Object.values(cnt))
+    }
+    return correct / n
+}
+
+
+async function testClusterLarge() {
+
+    let G = 8      //群數
+    let m = 125    //每群點數
+    let D = 8      //向量維度
+    let n = G * m
+    let seed = 0   //k-means隨機初始化種子, 使結果可重現
+
+    let { data, truth } = genBlobs(G, m, D, 100, 5, 42)
+    console.log(`資料: n=${n}, 維度D=${D}, 群數G=${G} (數值向量, 歐氏)`)
+
+    let t0 = performance.now()
+    let r = await WCluster.cluster(data, { mode: 'k-means', kNumber: G, usePCA: false, seed })
+    let dt = performance.now() - t0
+
+    console.log(`耗時: ${dt.toFixed(0)} ms (k-means, seed=${seed})`)
+    console.log(`分群數: ${r.ginds.length}, 涵蓋點數: ${r.ginds.flat().length}/${n}`)
+    console.log(`purity: ${purity(r.ginds, truth).toFixed(3)} (1.000表示完全還原ground-truth)`)
+    // => 耗時為機器相關; k-means複雜度O(n·k·iter), 遠快於k-medoids, 故n可放大。
+    //    結構大致為:
+    //    資料: n=1000, 維度D=8, 群數G=8 (數值向量, 歐氏)
+    //    耗時: 數十~數百 ms (k-means, seed=0)
+    //    分群數: 8, 涵蓋點數: 1000/1000
+    //    purity: 1.000
+
+}
+testClusterLarge()
+    .catch((err) => {
+        console.log(err)
+    })
+
+//node g-cluster-kMeans-large.mjs

package/g-cluster-kMeans-nodeworker.mjs

@@ -0,0 +1,181 @@
+// import WCluster from './src/WCluster.mjs'
+import WCluster from './dist/w-cluster.wk.umd.js'
+
+
+//k-means受初始隨機群中心影響, 給定seed使結果可重現
+//注意: 本檔走 dist 建置版(WebWorker bundle)。seed/usePCA/funDist 為近期 src 新增,
+//      須先重新 build dist 後, 此處 seed 才會生效; 否則 dist 舊版 k-means 仍為隨機, 下列輸出僅供參考
+
+
+async function testCluster() {
+    let mode = 'k-means'
+    let seed = 0
+
+    let mat = [
+        [40, 50, 60],
+        [50, 70, 60],
+        [80, 70, 90],
+        [50, 60, 80]
+    ]
+    console.log('mat', mat)
+    // => mat [ [ 40, 50, 60 ], [ 50, 70, 60 ], [ 80, 70, 90 ], [ 50, 60, 80 ] ]
+
+    let resMat = await WCluster.cluster(mat, { mode, kNumber: 2, nCompNIPALS: 2, seed })
+    console.log(JSON.stringify(resMat, null, 2))
+    // => {
+    //   "keys": null,
+    //   "ginds": [
+    //     [ 0, 1, 3 ],
+    //     [ 2 ]
+    //   ],
+    //   "gmat": [
+    //     [
+    //       [ -1.704002697669786, 0.43087564048799354 ],
+    //       [ -0.2509699164590232, -1.1519035967558147 ],
+    //       [ -0.03633718671228592, 0.48858292291798827 ]
+    //     ],
+    //     [
+    //       [ 1.9913098008410954, 0.23244503334983269 ]
+    //     ]
+    //   ],
+    //   "gltdt": [
+    //     [
+    //       [ 40, 50, 60 ],
+    //       [ 50, 70, 60 ],
+    //       [ 50, 60, 80 ]
+    //     ],
+    //     [
+    //       [ 80, 70, 90 ]
+    //     ]
+    //   ]
+    // }
+
+    let mat2 = [
+        [1040, 50, 60],
+        [1050, 70, 60],
+        [1080, 70, 90],
+        [1050, 60, 80]
+    ]
+    console.log('mat2', mat2)
+    // => mat2 [ [ 1040, 50, 60 ], [ 1050, 70, 60 ], [ 1080, 70, 90 ], [ 1050, 60, 80 ] ]
+
+    let resMat2 = await WCluster.cluster(mat2, { mode, kNumber: 2, nCompNIPALS: 2, seed })
+    console.log(JSON.stringify(resMat2, null, 2))
+    // => {
+    //   "keys": null,
+    //   "ginds": [
+    //     [ 0, 1, 3 ],
+    //     [ 2 ]
+    //   ],
+    //   "gmat": [
+    //     [
+    //       [ -1.704002697669786, 0.43087564048799354 ],
+    //       [ -0.2509699164590232, -1.1519035967558147 ],
+    //       [ -0.03633718671228592, 0.48858292291798827 ]
+    //     ],
+    //     [
+    //       [ 1.9913098008410954, 0.23244503334983269 ]
+    //     ]
+    //   ],
+    //   "gltdt": [
+    //     [
+    //       [ 1040, 50, 60 ],
+    //       [ 1050, 70, 60 ],
+    //       [ 1050, 60, 80 ]
+    //     ],
+    //     [
+    //       [ 1080, 70, 90 ]
+    //     ]
+    //   ]
+    // }
+
+    let mat3 = [
+        [11040, 50, 60],
+        [13050, 70, 60],
+        [15080, 70, 90],
+        [17050, 60, 80]
+    ]
+    console.log('mat3', mat3)
+    // => mat3 [ [ 11040, 50, 60 ], [ 13050, 70, 60 ], [ 15080, 70, 90 ], [ 17050, 60, 80 ] ]
+
+    let resMat3 = await WCluster.cluster(mat3, { mode, kNumber: 2, nCompNIPALS: 2, seed })
+    console.log(JSON.stringify(resMat3, null, 2))
+    // => {
+    //   "keys": null,
+    //   "ginds": [
+    //     [ 0 ],
+    //     [ 1, 2, 3 ]
+    //   ],
+    //   "gmat": [
+    //     [
+    //       [ -1.8599655569892897, 0.4908764271508211 ]
+    //     ],
+    //     [
+    //       [ -0.3950941652793108, -1.0977355294143445 ],
+    //       [ 1.3430199944041517, -0.17213692267477554 ],
+    //       [ 0.912039727864449, 0.778996024938299 ]
+    //     ]
+    //   ],
+    //   "gltdt": [
+    //     [
+    //       [ 11040, 50, 60 ]
+    //     ],
+    //     [
+    //       [ 13050, 70, 60 ],
+    //       [ 15080, 70, 90 ],
+    //       [ 17050, 60, 80 ]
+    //     ]
+    //   ]
+    // }
+
+    let ltdt = [
+        { name: 'Cameron', a: 40, b: 50, c: 60 },
+        { name: 'Buckley', a: 50, b: 70, c: 60 },
+        { name: 'Paul', a: 80, b: 70, c: 90 },
+        { name: 'Fawcett', a: 50, b: 60, c: 80 },
+    ]
+    console.log('ltdt', ltdt)
+    // => ltdt [
+    //     { name: 'Cameron', a: 40, b: 50, c: 60 },
+    //     { name: 'Buckley', a: 50, b: 70, c: 60 },
+    //     { name: 'Paul', a: 80, b: 70, c: 90 },
+    //     { name: 'Fawcett', a: 50, b: 60, c: 80 }
+    // ]
+
+    let resLtdt = await WCluster.cluster(ltdt, { mode, kNumber: 2, nCompNIPALS: 2, seed })
+    console.log(JSON.stringify(resLtdt, null, 2))
+    // => {
+    //   "keys": [ "a", "b", "c" ],
+    //   "ginds": [
+    //     [ 0, 1, 3 ],
+    //     [ 2 ]
+    //   ],
+    //   "gmat": [
+    //     [
+    //       [ -1.704002697669786, 0.43087564048799354 ],
+    //       [ -0.2509699164590232, -1.1519035967558147 ],
+    //       [ -0.03633718671228592, 0.48858292291798827 ]
+    //     ],
+    //     [
+    //       [ 1.9913098008410954, 0.23244503334983269 ]
+    //     ]
+    //   ],
+    //   "gltdt": [
+    //     [
+    //       { "name": "Cameron", "a": 40, "b": 50, "c": 60 },
+    //       { "name": "Buckley", "a": 50, "b": 70, "c": 60 },
+    //       { "name": "Fawcett", "a": 50, "b": 60, "c": 80 }
+    //     ],
+    //     [
+    //       { "name": "Paul", "a": 80, "b": 70, "c": 90 }
+    //     ]
+    //   ]
+    // }
+
+}
+testCluster()
+    .catch((err) => {
+        console.log(err)
+    })
+
+//node g-cluster-kMeans-nodeworker.mjs

package/g-cluster-kMeans.mjs

@@ -0,0 +1,178 @@
+import WCluster from './src/WCluster.mjs'
+
+
+//k-means受初始隨機群中心影響, 給定seed使結果可重現
+
+
+async function testCluster() {
+    let mode = 'k-means'
+    let seed = 0
+
+    let mat = [
+        [40, 50, 60],
+        [50, 70, 60],
+        [80, 70, 90],
+        [50, 60, 80]
+    ]
+    console.log('mat', mat)
+    // => mat [ [ 40, 50, 60 ], [ 50, 70, 60 ], [ 80, 70, 90 ], [ 50, 60, 80 ] ]
+
+    let resMat = await WCluster.cluster(mat, { mode, kNumber: 2, nCompNIPALS: 2, seed })
+    console.log(JSON.stringify(resMat, null, 2))
+    // => {
+    //   "keys": null,
+    //   "ginds": [
+    //     [ 0, 1, 3 ],
+    //     [ 2 ]
+    //   ],
+    //   "gmat": [
+    //     [
+    //       [ -1.704002697669786, 0.43087564048799354 ],
+    //       [ -0.2509699164590232, -1.1519035967558147 ],
+    //       [ -0.03633718671228592, 0.48858292291798827 ]
+    //     ],
+    //     [
+    //       [ 1.9913098008410954, 0.23244503334983269 ]
+    //     ]
+    //   ],
+    //   "gltdt": [
+    //     [
+    //       [ 40, 50, 60 ],
+    //       [ 50, 70, 60 ],
+    //       [ 50, 60, 80 ]
+    //     ],
+    //     [
+    //       [ 80, 70, 90 ]
+    //     ]
+    //   ]
+    // }
+
+    let mat2 = [
+        [1040, 50, 60],
+        [1050, 70, 60],
+        [1080, 70, 90],
+        [1050, 60, 80]
+    ]
+    console.log('mat2', mat2)
+    // => mat2 [ [ 1040, 50, 60 ], [ 1050, 70, 60 ], [ 1080, 70, 90 ], [ 1050, 60, 80 ] ]
+
+    let resMat2 = await WCluster.cluster(mat2, { mode, kNumber: 2, nCompNIPALS: 2, seed })
+    console.log(JSON.stringify(resMat2, null, 2))
+    // => {
+    //   "keys": null,
+    //   "ginds": [
+    //     [ 0, 1, 3 ],
+    //     [ 2 ]
+    //   ],
+    //   "gmat": [
+    //     [
+    //       [ -1.704002697669786, 0.43087564048799354 ],
+    //       [ -0.2509699164590232, -1.1519035967558147 ],
+    //       [ -0.03633718671228592, 0.48858292291798827 ]
+    //     ],
+    //     [
+    //       [ 1.9913098008410954, 0.23244503334983269 ]
+    //     ]
+    //   ],
+    //   "gltdt": [
+    //     [
+    //       [ 1040, 50, 60 ],
+    //       [ 1050, 70, 60 ],
+    //       [ 1050, 60, 80 ]
+    //     ],
+    //     [
+    //       [ 1080, 70, 90 ]
+    //     ]
+    //   ]
+    // }
+
+    let mat3 = [
+        [11040, 50, 60],
+        [13050, 70, 60],
+        [15080, 70, 90],
+        [17050, 60, 80]
+    ]
+    console.log('mat3', mat3)
+    // => mat3 [ [ 11040, 50, 60 ], [ 13050, 70, 60 ], [ 15080, 70, 90 ], [ 17050, 60, 80 ] ]
+
+    let resMat3 = await WCluster.cluster(mat3, { mode, kNumber: 2, nCompNIPALS: 2, seed })
+    console.log(JSON.stringify(resMat3, null, 2))
+    // => {
+    //   "keys": null,
+    //   "ginds": [
+    //     [ 0 ],
+    //     [ 1, 2, 3 ]
+    //   ],
+    //   "gmat": [
+    //     [
+    //       [ -1.8599655569892897, 0.4908764271508211 ]
+    //     ],
+    //     [
+    //       [ -0.3950941652793108, -1.0977355294143445 ],
+    //       [ 1.3430199944041517, -0.17213692267477554 ],
+    //       [ 0.912039727864449, 0.778996024938299 ]
+    //     ]
+    //   ],
+    //   "gltdt": [
+    //     [
+    //       [ 11040, 50, 60 ]
+    //     ],
+    //     [
+    //       [ 13050, 70, 60 ],
+    //       [ 15080, 70, 90 ],
+    //       [ 17050, 60, 80 ]
+    //     ]
+    //   ]
+    // }
+
+    let ltdt = [
+        { name: 'Cameron', a: 40, b: 50, c: 60 },
+        { name: 'Buckley', a: 50, b: 70, c: 60 },
+        { name: 'Paul', a: 80, b: 70, c: 90 },
+        { name: 'Fawcett', a: 50, b: 60, c: 80 },
+    ]
+    console.log('ltdt', ltdt)
+    // => ltdt [
+    //     { name: 'Cameron', a: 40, b: 50, c: 60 },
+    //     { name: 'Buckley', a: 50, b: 70, c: 60 },
+    //     { name: 'Paul', a: 80, b: 70, c: 90 },
+    //     { name: 'Fawcett', a: 50, b: 60, c: 80 }
+    // ]
+
+    let resLtdt = await WCluster.cluster(ltdt, { mode, kNumber: 2, nCompNIPALS: 2, seed })
+    console.log(JSON.stringify(resLtdt, null, 2))
+    // => {
+    //   "keys": [ "a", "b", "c" ],
+    //   "ginds": [
+    //     [ 0, 1, 3 ],
+    //     [ 2 ]
+    //   ],
+    //   "gmat": [
+    //     [
+    //       [ -1.704002697669786, 0.43087564048799354 ],
+    //       [ -0.2509699164590232, -1.1519035967558147 ],
+    //       [ -0.03633718671228592, 0.48858292291798827 ]
+    //     ],
+    //     [
+    //       [ 1.9913098008410954, 0.23244503334983269 ]
+    //     ]
+    //   ],
+    //   "gltdt": [
+    //     [
+    //       { "name": "Cameron", "a": 40, "b": 50, "c": 60 },
+    //       { "name": "Buckley", "a": 50, "b": 70, "c": 60 },
+    //       { "name": "Fawcett", "a": 50, "b": 60, "c": 80 }
+    //     ],
+    //     [
+    //       { "name": "Paul", "a": 80, "b": 70, "c": 90 }
+    //     ]
+    //   ]
+    // }
+
+}
+testCluster()
+    .catch((err) => {
+        console.log(err)
+    })
+
+//node g-cluster-kMeans.mjs

package/g-cluster-kMedoids-large-suggest.mjs

@@ -0,0 +1,95 @@
+import WCluster from './src/WCluster.mjs'
+import { jaccardBitset } from './src/jaccardBitset.mjs'
+
+
+//與 g-cluster-kMedoids-large.mjs 同資料、同 fasterPAM 後端(矩陣式FasterPAM), 唯一差別:
+//  距離函數改用 bitset+popcount 版(jaccardBitset helper) 取代逐維 Jaccard。
+//  fasterPAM 後端下「建距離矩陣」為主成本, bitset 把 D 個位元打包成 ceil(D/32) 個 word、
+//  以 popcount 一次算 32 維 → 建矩陣加速 ~一個數量級(高維 14–23x), 直接反映在總時間;
+//  分群結果(ginds/purity)與逐維版完全相同。
+
+
+//確定性PRNG(mulberry32), 使資料可重現
+function mulberry32(a) {
+    return function() {
+        a |= 0
+        a = a + 0x6D2B79F5 | 0
+        let t = Math.imul(a ^ a >>> 15, 1 | a)
+        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t
+        return ((t ^ t >>> 14) >>> 0) / 4294967296
+    }
+}
+
+//產生G個二元blob(交錯排列), 各blob一組base活躍位 + 小幅翻轉, 回傳{data, truth}
+function genBinaryBlobs(G, m, D, active, flips, seed) {
+    let rnd = mulberry32(seed)
+    let bases = []
+    for (let g = 0; g < G; g++) {
+        let base = new Array(D).fill(0)
+        let s = new Set()
+        while (s.size < active) {
+            s.add(Math.floor(rnd() * D))
+        }
+        s.forEach((i) => {
+            base[i] = 1
+        })
+        bases.push(base)
+    }
+    let data = []
+    let truth = []
+    for (let i = 0; i < m; i++) {
+        for (let g = 0; g < G; g++) {
+            let v = bases[g].slice()
+            for (let f = 0; f < flips; f++) {
+                let p = Math.floor(rnd() * D)
+                v[p] = v[p] ? 0 : 1
+            }
+            data.push(v)
+            truth.push(g)
+        }
+    }
+    return { data, truth }
+}
+
+//cluster purity(各分群以多數ground-truth標籤計, 全對為1)
+function purity(ginds, truth) {
+    let correct = 0
+    let n = truth.length
+    for (let g of ginds) {
+        let cnt = {}
+        for (let i of g) {
+            cnt[truth[i]] = (cnt[truth[i]] || 0) + 1
+        }
+        correct += Math.max(...Object.values(cnt))
+    }
+    return correct / n
+}
+
+
+async function testClusterLargeSuggest() {
+
+    let G = 20 //群數
+    let m = 200 //每群點數
+    let D = 1000 //向量維度(bit數)
+    let n = G * m
+
+    let { data: rows, truth } = genBinaryBlobs(G, m, D, Math.floor(D * 0.15), 3, 42)
+    console.log(`資料: n=${n}, 維度D=${D}, 群數G=${G} (二元向量, Jaccard)`)
+
+    //bitset 打包 + fasterPAM 後端(計時含打包與建矩陣, 才是公平的端到端比較)
+    let t0 = performance.now()
+    let { data, funDist } = jaccardBitset(rows)
+    let r = await WCluster.cluster(data, { mode: 'k-medoids', kNumber: G, usePCA: false, funDist, useMethod: 'fasterPAM' })
+    let dt = performance.now() - t0
+
+    console.log(`[fasterPAM 後端 + bitset Jaccard(jaccardBitset)]`)
+    console.log(`  耗時: ${dt.toFixed(0)} ms, 分群數: ${r.ginds.length}, 涵蓋: ${r.ginds.flat().length}/${n}, purity: ${purity(r.ginds, truth).toFixed(3)}`)
+    // => 相對 g-cluster-kMedoids-large.mjs(同後端, 逐維Jaccard)明顯更快(維度越高差距越大), ginds/purity 完全相同
+
+}
+testClusterLargeSuggest()
+    .catch((err) => {
+        console.log(err)
+    })
+
+//node g-cluster-kMedoids-large-suggest.mjs

package/g-cluster-kMedoids-large.mjs

@@ -0,0 +1,104 @@
+import WCluster from './src/WCluster.mjs'
+
+
+//針對「較大的二元向量數據」以 k-medoids(fasterPAM 後端=矩陣式FasterPAM) + 逐維 Jaccard 分群, 記錄耗時。
+//  作為 g-cluster-kMedoids-large-suggest.mjs(同 fasterPAM 後端, 但距離改用 bitset) 的對照基準:
+//  兩支差別只在距離函數(逐維 vs 位元打包), 後端相同, 故可直接看出 bitset 對建矩陣的加速。
+
+
+//確定性PRNG(mulberry32), 使資料可重現
+function mulberry32(a) {
+    return function() {
+        a |= 0
+        a = a + 0x6D2B79F5 | 0
+        let t = Math.imul(a ^ a >>> 15, 1 | a)
+        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t
+        return ((t ^ t >>> 14) >>> 0) / 4294967296
+    }
+}
+
+//產生G個二元blob(交錯排列), 各blob一組base活躍位 + 小幅翻轉, 回傳{data, truth}
+function genBinaryBlobs(G, m, D, active, flips, seed) {
+    let rnd = mulberry32(seed)
+    let bases = []
+    for (let g = 0; g < G; g++) {
+        let base = new Array(D).fill(0)
+        let s = new Set()
+        while (s.size < active) {
+            s.add(Math.floor(rnd() * D))
+        }
+        s.forEach((i) => {
+            base[i] = 1
+        })
+        bases.push(base)
+    }
+    let data = []
+    let truth = []
+    for (let i = 0; i < m; i++) {
+        for (let g = 0; g < G; g++) {
+            let v = bases[g].slice()
+            for (let f = 0; f < flips; f++) {
+                let p = Math.floor(rnd() * D)
+                v[p] = v[p] ? 0 : 1
+            }
+            data.push(v)
+            truth.push(g)
+        }
+    }
+    return { data, truth }
+}
+
+//Jaccard距離(0/1陣列, 逐維)
+let jaccard = (a, b) => {
+    let inter = 0
+    let uni = 0
+    for (let i = 0; i < a.length; i++) {
+        let x = a[i]
+        let y = b[i]
+        if (x & y) inter++
+        if (x | y) uni++
+    }
+    return uni === 0 ? 0 : 1 - inter / uni
+}
+
+//cluster purity(各分群以多數ground-truth標籤計, 全對為1)
+function purity(ginds, truth) {
+    let correct = 0
+    let n = truth.length
+    for (let g of ginds) {
+        let cnt = {}
+        for (let i of g) {
+            cnt[truth[i]] = (cnt[truth[i]] || 0) + 1
+        }
+        correct += Math.max(...Object.values(cnt))
+    }
+    return correct / n
+}
+
+
+async function testClusterLarge() {
+
+    let G = 20 //群數
+    let m = 200 //每群點數
+    let D = 1000 //向量維度(bit數)
+    let n = G * m
+
+    let { data, truth } = genBinaryBlobs(G, m, D, Math.floor(D * 0.15), 3, 42)
+    console.log(`資料: n=${n}, 維度D=${D}, 群數G=${G} (二元向量, Jaccard)`)
+
+    //fasterPAM 後端(FasterPAM) + 逐維 Jaccard
+    let t0 = performance.now()
+    let r = await WCluster.cluster(data, { mode: 'k-medoids', kNumber: G, usePCA: false, funDist: jaccard, useMethod: 'fasterPAM' })
+    let dt = performance.now() - t0
+
+    console.log(`[fasterPAM 後端 + 逐維 Jaccard]`)
+    console.log(`  耗時: ${dt.toFixed(0)} ms, 分群數: ${r.ginds.length}, 涵蓋: ${r.ginds.flat().length}/${n}, purity: ${purity(r.ginds, truth).toFixed(3)}`)
+    // => 耗時為機器相關; 此為對照基準, 與 -suggest(同後端, bitset距離) 相比可見建矩陣加速, 分群結果應完全相同
+
+}
+testClusterLarge()
+    .catch((err) => {
+        console.log(err)
+    })
+
+//node g-cluster-kMedoids-large.mjs

package/{g-cluster-nodeworker.mjs → g-cluster-kMedoids-nodeworker.mjs}

@@ -172,5 +172,4 @@ testCluster()
         console.log(err)
     })
 
-//node --experimental-modules --es-module-specifier-resolution=node g-cluster-nodeworker.mjs
-
+//node g-cluster-kMedoids-nodeworker.mjs

package/{g-cluster.mjs → g-cluster-kMedoids-simple.mjs}

@@ -171,4 +171,4 @@ testCluster()
         console.log(err)
     })
 
-//node --experimental-modules --es-module-specifier-resolution=node g-cluster.mjs
+//node g-cluster-kMedoids-simple.mjs

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "w-cluster",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "main": "dist/w-cluster.umd.js",
   "dependencies": {
-    "lodash-es": "^4.17.21",
-    "k-medoids": "^1.0.7",
-    "ml-kmeans": "^6.0.0",
+    "lodash-es": "^4.18.1",
+    "k-medoids": "^1.0.8",
+    "ml-kmeans": "^7.0.1",
     "ml-pca": "^4.1.1",
-    "wsemi": "^1.7.47"
+    "wsemi": "^1.8.59"
   },
   "devDependencies": {
-    "w-package-tools": "^1.0.73"
+    "w-package-tools": "^1.1.9"
   },
   "scripts": {
-    "test": "mocha --parallel --timeout 60000 --experimental-modules --es-module-specifier-resolution=node",
+    "test": "mocha --parallel --timeout 60000",
     "deploy": "gh-pages -d docs"
   },
   "repository": {