079project 1.0.0 → 2.0.0

package/main_Study.cjs

@@ -79,6 +79,7 @@ async function batchAddPoints(graph, pointsArr, batchSize = 500) {
         await new Promise(resolve => setImmediate(resolve));
     }
 }
+/*
 // 反触发机制
 async function antiTrigger(onContinue, onExit) {
     const PORT = global.config.emitExitport || 8641;
@@ -145,6 +146,7 @@ async function antiTrigger(onContinue, onExit) {
         }, 10000);
     }
 }
+    */
 function verifySystemConsistency(sourceRuntime, targetRuntime) {
     console.log('[VERIFY] 开始验证系统一致性...');
     console.log(`[VERIFY] 源词表大小: ${sourceRuntime.vocabManager.vocab.length}, 目标: ${targetRuntime.vocabManager.vocab.length}`);
@@ -163,12 +165,104 @@ const readline = require('readline');
 
 app.use(bodyParser.json());
 app.use(bodyParser.urlencoded({ extended: true }));
+// ...existing code...
 app.use(express.static(path.join(__dirname, 'public')));
 
 // 持久化路径
 const SAVE_PATH = path.join(__dirname, 'runtime_data.json');
 
-
+// 新增：会话管理器（以对话为尺度管理记忆）
+class SessionManager {
+    constructor({ idleMs = 10 * 60 * 1000, maxSessions = 200 } = {}) {
+        this.idleMs = idleMs;          // 会话空闲超时，自动切新会话
+        this.maxSessions = maxSessions; // 最近保留的会话数量上限（用于遗忘窗口）
+        this.sessions = new Map();      // sessionId -> { start, lastActivity, messageCount }
+        this.current = null;
+    }
+    now() { return Date.now(); }
+    _newId() { return `S${Date.now()}_${Math.floor(Math.random() * 1e6)}`; }
+
+    startNewSession(meta = {}) {
+        const id = this._newId();
+        const ts = this.now();
+        this.sessions.set(id, {
+            start: ts,
+            lastActivity: ts,
+            messageCount: 0,
+            ...meta
+        });
+        this.current = id;
+        this._truncateIfNeeded();
+        return id;
+    }
+    ensureActive() {
+        const ts = this.now();
+        if (!this.current || !this.sessions.has(this.current)) {
+            return this.startNewSession();
+        }
+        const s = this.sessions.get(this.current);
+        if (ts - s.lastActivity > this.idleMs) {
+            return this.startNewSession({ reason: 'idle-timeout' });
+        }
+        return this.current;
+    }
+    useSession(sessionId) {
+        if (!sessionId) return this.ensureActive();
+        if (!this.sessions.has(sessionId)) {
+            const ts = this.now();
+            this.sessions.set(sessionId, { start: ts, lastActivity: ts, messageCount: 0 });
+        }
+        this.current = sessionId;
+        return sessionId;
+    }
+    touch(sessionId = this.current) {
+        if (!sessionId) return;
+        const s = this.sessions.get(sessionId);
+        if (s) s.lastActivity = this.now();
+    }
+    incMessage(sessionId = this.current) {
+        if (!sessionId) return;
+        const s = this.sessions.get(sessionId);
+        if (s) {
+            s.messageCount = (s.messageCount || 0) + 1;
+            s.lastActivity = this.now();
+        }
+    }
+    getActiveSessionId() {
+        return this.ensureActive();
+    }
+    // 返回最近的会话ID（按 lastActivity 降序）
+    getRecentSessionIds(limit = this.maxSessions) {
+        const entries = Array.from(this.sessions.entries());
+        entries.sort((a, b) => (b[1].lastActivity || 0) - (a[1].lastActivity || 0));
+        return entries.slice(0, limit).map(([id]) => id);
+    }
+    _truncateIfNeeded() {
+        const ids = this.getRecentSessionIds(this.maxSessions);
+        const keep = new Set(ids);
+        for (const id of this.sessions.keys()) {
+            if (!keep.has(id)) this.sessions.delete(id);
+        }
+    }
+    export() {
+        return {
+            config: { idleMs: this.idleMs, maxSessions: this.maxSessions },
+            current: this.current,
+            sessions: Array.from(this.sessions.entries())
+        };
+    }
+    import(obj) {
+        if (!obj) return;
+        const { config, current, sessions } = obj;
+        if (config) {
+            this.idleMs = config.idleMs ?? this.idleMs;
+            this.maxSessions = config.maxSessions ?? this.maxSessions;
+        }
+        this.sessions = new Map(Array.isArray(sessions) ? sessions : []);
+        this.current = current || null;
+    }
+}
+// ...existing code...
 
 
 class SnapshotManager {
@@ -232,7 +326,12 @@ class SnapshotManager {
                 wordGraph: Array.from(this.runtime.wordGraph.points.values()),
                 kvm: Array.from(this.runtime.kvm.memory.entries()),
                 vocab: this.runtime.vocabManager.vocab,
-                wordAccessLog: Array.from(this.runtime.wordAccessLog ? this.runtime.wordAccessLog.entries() : [])
+                // 修正：序列化为 [word, [[sessionId,count], ...]]
+                wordAccessLog: Array.from(this.runtime.wordAccessLog.entries()).map(([w, per]) =>
+                    [w, per instanceof Map ? Array.from(per.entries()) : (Array.isArray(per) ? [['legacy', per.length]] : [])]
+                ),
+                // 新增：保存会话状态
+                sessions: this.runtime.session.export()
             };
 
             // 写入临时文件，然后原子重命名以确保数据完整性
@@ -337,9 +436,25 @@ class SnapshotManager {
             // 恢复词访问日志
             console.log('[SNAPSHOT] 恢复词访问日志...');
             if (data.wordAccessLog) {
-                this.runtime.wordAccessLog = new Map(data.wordAccessLog);
+                const restored = new Map();
+                for (const [word, per] of data.wordAccessLog) {
+                    if (Array.isArray(per) && per.length > 0 && Array.isArray(per[0])) {
+                        restored.set(word, new Map(per));
+                    } else if (Array.isArray(per)) {
+                        restored.set(word, new Map([['legacy', per.length]]));
+                    } else {
+                        restored.set(word, new Map());
+                    }
+                }
+                this.runtime.wordAccessLog = restored;
+            }
+            // 恢复会话信息
+            if (data.sessions) {
+                this.runtime.session.import(data.sessions);
+            } else {
+                // 无会话信息时，创建一个遗留会话
+                this.runtime.session.startNewSession({ reason: 'snapshot-legacy' });
             }
-
             console.timeEnd('snapshotRestore');
             console.log(`[SNAPSHOT] 成功从快照恢复: ${snapshotId}`);
             return true;
@@ -802,15 +917,21 @@ class Runtime {
         this.transformer = null;
         this.vocabManager = global.vocabmanager;
         this.spider = new Spider();
+
+        // 新：以“会话”为尺度的访问日志与会话管理
+        this.session = new SessionManager({
+            idleMs: this.config.sessionIdleMs || 10 * 60 * 1000,
+            maxSessions: this.config.memoryRecentSessions || 200
+        });
+        // Map<word, Map<sessionId, count>>
         this.wordAccessLog = new Map();
+
         this.initWordGraph();
-        this.forgetTimer = setInterval(() => this.forgetWords(), 350 * 1000);        // 3. 判断是否合并到已有模因
-        this.MAX_MEME_WORDS = 100; // 单个模因最大词数
-        this.MIN_OVERLAP = 2;      // 至少有2个词重叠才允许合并
-        // Runtime类内新增
-        this.activationStats = new Map(); // 记录激活关系
+        this.forgetTimer = setInterval(() => this.forgetWords(), 350 * 1000);
+        this.MAX_MEME_WORDS = 100;
+        this.MIN_OVERLAP = 2;
+        this.activationStats = new Map();
         this.isclone = false;
-        // 添加系统资源监控
         this.systemLoad = {
             lastCpuUsage: process.cpuUsage(),
             lastCheckTime: Date.now(),
@@ -926,12 +1047,14 @@ class Runtime {
     }
 
     // 记录词语点被访问
-    logWordAccess(word) {
-        const now = Date.now();
-        if (!this.wordAccessLog.has(word)) {
-            this.wordAccessLog.set(word, []);
+    logWordAccess(word, sessionId) {
+        const sid = sessionId || this.session.getActiveSessionId();
+        let perSession = this.wordAccessLog.get(word);
+        if (!perSession) {
+            perSession = new Map();
+            this.wordAccessLog.set(word, perSession);
         }
-        this.wordAccessLog.get(word).push(now);
+        perSession.set(sid, (perSession.get(sid) || 0) + 1);
     }
     registerClone() {
         Runtime.cloneRegistry.add(this);
@@ -939,62 +1062,65 @@ class Runtime {
         // 不自动销毁
     }
 
-    dispose() {
+dispose() {
         this.graph.points.clear();
         this.wordGraph.points.clear();
         this.kvm.memory.clear();
         if (this.wordAccessLog) this.wordAccessLog.clear();
         if (this.forgetTimer) clearInterval(this.forgetTimer);
-        // 其它属性也可清空
     }
+     // 将遗忘策略改为“最近N个会话窗口”
     forgetWords() {
-        const now = Date.now();
-        const windowMs = 350 * 1000;
-
-        // 只保留窗口内访问
-        for (const [key, times] of this.wordAccessLog.entries()) {
-            const recent = times.filter(t => now - t <= windowMs);
-            this.wordAccessLog.set(key, recent);
-        }
-
         // 保护：收集所有被KVM引用的词
         const protectedWords = new Set();
         for (const [, words] of this.kvm.memory.entries()) {
-            if (Array.isArray(words)) {
-                for (const w of words) protectedWords.add(w);
-            }
+            if (Array.isArray(words)) for (const w of words) protectedWords.add(w);
         }
 
-        // 若词表过小，直接跳过遗忘，避免崩塌
         const vocabSize = this.vocabManager.vocab.length;
         if (vocabSize < 1000) {
             console.log('[FORGET] 词表过小，跳过本轮遗忘');
             return;
         }
 
-        // 仅对“存在于词图且不在保护集”的词做统计
+        const recentSessions = this.session.getRecentSessionIds(this.config.memoryRecentSessions || 200);
+        const recentSet = new Set(recentSessions);
+
         const stats = [];
-        for (const [word, recent] of this.wordAccessLog.entries()) {
+        for (const [word, perSession] of this.wordAccessLog.entries()) {
             if (!this.wordGraph.points.has(word)) continue;
             if (!this.vocabManager.word2idx.has(word)) continue;
             if (protectedWords.has(word)) continue;
-            stats.push({ word, count: recent.length });
+
+            // 统计最近会话窗口内的使用次数
+            let count = 0;
+            if (perSession instanceof Map) {
+                for (const [sid, c] of perSession.entries()) {
+                    if (recentSet.has(sid)) count += c || 0;
+                }
+            } else if (Array.isArray(perSession)) {
+                // 兼容旧格式（时间戳数组），视作一个遗留会话
+                count = perSession.length;
+            }
+            stats.push({ word, count });
         }
         if (stats.length === 0) return;
 
         stats.sort((a, b) => a.count - b.count);
 
-        // 限制每轮上限，避免快速抽干
-        const maxForgetRate = 0.001; // 改为每轮最多0.1%
+        // 每轮最多遗忘 0.1%（更保守）
+        const maxForgetRate = 0.001;
         const n = Math.max(1, Math.floor(stats.length * maxForgetRate));
+        const toForget = stats.slice(0, n).filter(s => s.count === 0).map(s => s.word);
+
+        if (toForget.length === 0) return;
 
-        const toForget = stats.slice(0, n).map(s => s.word);
         for (const word of toForget) {
             this.wordGraph.points.delete(word);
             this.vocabManager.vocab = this.vocabManager.vocab.filter(w => w !== word);
             this.vocabManager.updateMappings();
             this.wordAccessLog.delete(word);
-            console.log(`[FORGET] 淘汰词语点: ${word}`);
+            console.log(`[FORGET] 淘汰词语点(无最近会话使用): ${word}`);
 
             // 同步清理所有模因节点的词表
             for (const [memeID, words] of this.kvm.memory.entries()) {
@@ -1010,9 +1136,6 @@ class Runtime {
                 }
             }
         }
-
-        // 不在这里调用 runMainLoop，避免循环内触发再次遗忘
-        // this.runMainLoop();
     }
     // 修改 initWordGraph 方法
     initWordGraph() {
@@ -2571,10 +2694,10 @@ class controller {
     }
     // 处理用户输入
     async handleInput(text) {
+        const sid = this.runtime.session.ensureActive();
+        this.runtime.session.incMessage(sid);
         const words = text.toLowerCase().split(' ').filter(w => w.length > 0);
         this.runtime.processInput(words, { addNewWords: false });
-        // 用模因网络参与推理
-        //console.log('[DEBUG] 当前所有模因节点:', this.runtime.kvm.memory);
         return await this.runtime.generateResponseWithMemes(words);
     }
     // 启动自主学习
@@ -2648,15 +2771,23 @@ let saveQueued = false;
 
 // 保存所有点、图、词表等到硬盘
 function saveAll(runtime) {
+    // 规范化 wordAccessLog 为 [word, [[sessionId, count], ...]]
+    const serializedWordAccess = Array.from(runtime.wordAccessLog.entries()).map(([w, per]) => {
+        if (per instanceof Map) return [w, Array.from(per.entries())];
+        if (Array.isArray(per)) return [w, [['legacy', per.length]]]; // 兼容旧格式
+        return [w, []];
+    });
+
     // 只更新内存缓存
     latestRuntimeData = {
         memes: runtime.graph.getAllPoints(),
         wordGraph: Array.from(runtime.wordGraph.points.values()),
         kvm: Array.from(runtime.kvm.memory.entries()),
         vocab: runtime.vocabManager.vocab,
-        wordAccessLog: Array.from(runtime.wordAccessLog ? runtime.wordAccessLog.entries() : [])
+        wordAccessLog: serializedWordAccess,
+        // 新增：会话信息持久化
+        sessions: runtime.session.export()
     };
-    // 标记有保存请求
     saveQueued = true;
 }
 // 定时真正写入硬盘，只保存最新的
@@ -2669,6 +2800,7 @@ setInterval(() => {
     }
 }, 10000); // 每10秒最多写盘一次
 // 从硬盘恢复
+// 从硬盘恢复
 function loadAll(runtime) {
     if (!fs.existsSync(SAVE_PATH)) return;
     const data = JSON.parse(fs.readFileSync(SAVE_PATH, 'utf-8'));
@@ -2678,19 +2810,34 @@ function loadAll(runtime) {
             runtime.wordGraph.addPoint(point.pointID, point.connect);
         }
     }
-    // 3. 修改 loadAll 中的数据恢复
     if (data.kvm) {
         for (const [k, v] of data.kvm) {
             runtime.kvm.set(k, Array.isArray(v) ? v : [String(v)]);
-            // 确保一定是数组
         }
     }
     if (data.vocab) {
         runtime.vocabManager.vocab = data.vocab;
         runtime.vocabManager.updateMappings();
     }
+    // 恢复会话
+    if (data.sessions) {
+        runtime.session.import(data.sessions);
+    }
+    // 恢复词访问日志（新格式 Map<word, Map<sessionId, count>>）
     if (data.wordAccessLog && runtime.wordAccessLog) {
-        runtime.wordAccessLog = new Map(data.wordAccessLog);
+        const restored = new Map();
+        for (const [word, per] of data.wordAccessLog) {
+            if (Array.isArray(per) && per.length > 0 && Array.isArray(per[0])) {
+                // 新格式：[[sid, count], ...]
+                restored.set(word, new Map(per));
+            } else if (Array.isArray(per)) {
+                // 旧格式的 timestamps 数组 -> 合并为 legacy 会话
+                restored.set(word, new Map([['legacy', per.length]]));
+            } else {
+                restored.set(word, new Map());
+            }
+        }
+        runtime.wordAccessLog = restored;
     }
     console.log(`[LOAD] 系统状态已从 ${SAVE_PATH} 恢复`);
 }
@@ -3041,17 +3188,28 @@ async function main() {
         ctrlA.runtime.memeBarrier.start();
     }, 1000 * 60 * 12);
     // API路由 - 只做学习，不返回结果
-    app.post('/api/chat', async (req, res) => {
-        try {
-            const { message } = req.body;
-            ctrlA.runtime.processInput(message.toLowerCase().split(' ').filter(w => w.length > 0));
-            ctrlA.runtime.updateAttentionLinks();
-            res.status(204).end(); // 不返回内容
-        } catch (error) {
-            res.status(500).json({ error: error.message });
-            console.error('Error in /api/chat:', error);
-        }
-    });
+app.post('/api/chat', async (req, res) => {
+    try {
+        const { message, sessionId } = req.body || {};
+        // 支持从Header透传会话
+        const headerSid = req.headers['x-session-id'];
+        const sid = sessionId || headerSid || global.ctrlA.runtime.session.ensureActive();
+
+        // 使用/续接会话并计数
+        global.ctrlA.runtime.session.useSession(sid);
+        global.ctrlA.runtime.session.incMessage(sid);
+
+        const words = String(message || '').toLowerCase().split(/\s+/).filter(w => w.length > 0);
+        global.ctrlA.runtime.processInput(words);
+        global.ctrlA.runtime.updateAttentionLinks();
+
+        res.set('X-Session-Id', sid);
+        res.status(204).end();
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+        console.error('Error in /api/chat:', error);
+    }
+});
 
     app.get('/api/status', (req, res) => {
         res.json({ status: 'running', timestamp: new Date().toISOString() });
@@ -3208,16 +3366,7 @@ function applyModelParams(runtime) {
 }
 // 如果直接运行此文件，启动主函数
 if (require.main === module) {
-    /*antiTrigger(
-        () => main().catch(console.error), // onContinue
-        () => {
-            // onExit: 保存数据
-            try {
-                if (global.ctrl && global.ctrl.runtime) saveAll(global.ctrl.runtime);
-            } catch (e) { }
-        }
-    );
-    */
+
     main().catch(console.error)
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "079project",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "a GNN-GA BASED ai that might pass the turing test,which use little resources.its startpoint initialize it and you can start it as ```node mainStarter.cjs```",
   "keywords": [
     "ai",

package/todo-list.txt

@@ -0,0 +1,86 @@
+GitHub Copilot
+
+下面把你提出的 v2.0 需求整理成清晰的 TODO-list（每项附带子任务、优先级、复杂度估算、首要改动点与下一步行动建议）。便于逐步实现与分支/PR 管理。
+
+------------------1) 记忆尺度：从“时间”切换为“对话”----------------  
+- 子任务：  
+  - 定义“对话会话ID”与会话边界（消息计数或换话题检测）。  
+  - 将 KVM/wordAccessLog/快照/遗忘策略改为按会话维度索引与过期。  
+  - 修改 forgetWords、saveAll/loadAll 与 snapshot 逻辑以支持会话分片。  
+- 优先级：高；复杂度：中  
+- main_Study.cjs 中 KVM、forgetWords、SnapshotManager、save/load 函数。  
+- 下一步：设计会话ID格式并写出迁移方案（兼容老快照）。
+
+2) .copy -> 基于 hash 的差量 copy（递归分区哈希）  
+- 子任务：  
+  - 定义对象哈希（图节点、连接、KVM 值、词表段）规则。  
+  - 实现递归分区哈希算法（分层哈希，按子图/词块分区）。  
+  - 实现差量 copy/patch 接口（只拷贝不同分区）。  
+- 优先级：高；复杂度：大  
+- 首要改动：实现新模块 lib/deltaCopy.js，替换 cloneSystem、runtimeToPlain/plainObjToRuntime。  
+- 下一步：写单元测试验证哈希一致性与补丁正确性。
+
+3) 增强轮换学习（减少用户等待）  
+- 子任务：  
+  - 设计三副本轮换协议（leader/worker 与暂停/热替换流程）。  
+  - 将 scheduleCrossLearning 改为更细粒度的 checkpoint/lock-free 切换（差量同步）。  
+  - 添加短暂停机降级策略与快速回滚。  
+- 优先级：高；复杂度：中-大  
+- 首要改动：main_Study 中 scheduleCrossLearning、controller.updateRuntime、Redis 发布逻辑。  
+- 下一步：定义状态机与 API（swap、freeze、apply-delta）。
+
+4) 强化 anti-trigger 与日志系统（崩溃连锁触发定位）  ---------------------
+- 子任务：  
+  - 完善 antiTrigger：崩溃链路检测、重试与安全退出钩子。  
+  - 引入结构化日志（文件+rotating）与异常追踪（stack + context）。  
+  - 在关键路径增加崩溃快照（错误发生时自动 dump 最小快照）。  
+- 优先级：高；复杂度：中  
+- 首要改动：antiTrigger 函数、setupExitHandler、SnapshotManager.createSnapshot、新增 logger 模块（winston 或 pino）。  
+- 下一步：定义日志格式与最小 crash dump 方案。
+
+5) 新增对抗学习网络（人机识别评分器）  
+- 子任务：  
+  - 设计对抗模块接口：判别器（discriminator）输出拟人化评分与训练回路。  
+  - 用现有 KVM/graph 生成“人类样本”与“机器样本”数据集。  
+  - 将判别器输出作为主模型训练/奖励信号的一部分（强化学习回路）。  
+- 优先级：中；复杂度：大  
+- 首要改动：新增模块 lib/adversary.js + Runtime 中训练/评估接入点。  
+- 下一步：先实现轻量判别器（简单特征+小分类器）做 POC。
+
+6) 实现真正的爬虫模块（抓取+清洗）  
+- 子任务：  
+  - 新建爬虫模块（支持并发、robots、速率限制、去重、Pipeline 清洗）。  
+  - 集成 HTML 解析、正文提取、语言检测、去噪与词形归一化。  
+  - 将抓取结果发送到 spider.fetchArticles 的存储/队列。  
+- 优先级：中；复杂度：中-大  
+- 首要改动：新增目录 crawler/（fetcher、parser、cleaner、storage）。修改 Spider 以支持外部数据源。  
+- 下一步：先实现单域抓取与清洗流水线 POC。
+
+7) 硬盘型数据库构型（部分图结构磁盘化、自动加载）  
+- 子任务：  
+  - 研究 LMDB/LevelDB/rocksdb 方案，设计图分片策略（按节点度、热度、hash-range）。  
+  - 实现图分片接口（swap-in/out）、接近边界时触发预加载侦测。  
+  - 修改 GraphDB/KVM 支持异步加载与缓存回退策略。  
+- 优先级：高（随着图变大必须）；复杂度：大  
+- 首要改动：KVM 类扩展、GraphDB 重构为内存+持久层混合（lib/storage-adapter.js）。  
+- 下一步：选定数据库（建议 LMDB 或 RocksDB），实现最小存储适配层。
+
+8) 探索硬件加速（FPGA / 模拟运算）  
+- 子任务：  
+  - 梳理热点（哪些计算最耗时：信号扩散、多源比对、距离计算）。  
+  - 制定可被加速的计算接口（向量化、批处理、FPGA-friendly 格式）。  
+  - 建立 POC：把最小工作负载移到 GPU/FPGA 模拟（或借助 SIMD/Native addon）。  
+- 优先级：低（研究/POC）；复杂度：非常大（外部依赖）  
+- 首要改动：抽象计算层（lib/computeAdapter），便于未来替换为硬件实现。  
+- 下一步：先做性能分析与热点剖析，确定优先加速模块。
+
+交付建议（短期优先级）  
+- 阶段 1（2–4 周）：1、3、4（最小破坏性改造） + 日志模块 + 单元测试覆盖关键函数。  
+- 阶段 2（4–8 周）：2（差量 copy 实现）+ 7（存储适配 POC）+ 6（爬虫基础）。  
+- 阶段 3（8–16 周）：5（对抗学习）+ 8（硬件加速 POC）+ 全面整合与回归测试。
+
+我可以马上开始：  
+- A) 生成分解后的 issue 列表与每项具体 code-change patch（推荐先做阶段1）。  
+- B) 直接在工作区创建 logger 模块并改造 antiTrigger + setupExitHandler（优先级高）。  
+
+请选择要我现在执行的下一步（A / B / 或 指定某个任务编号）。

package/wikitext/.gitattributes

@@ -1,27 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bin.* filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zstandard filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text