在线学习与增量学习实践

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.metrics import accuracy_score

# 生成二分类数据集
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)

# 将数据集转换为数据流
stream = [(X[i], y[i]) for i in range(len(X))]

# 在线学习模型基类
class OnlineModel:
    def __init__(self, input_dim, output_dim, learning_rate=0.01):
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.learning_rate = learning_rate
        self.weights = np.zeros((input_dim, output_dim))
        self.bias = np.zeros(output_dim)
    
    def predict(self, x):
        """预测函数"""
        raise NotImplementedError
    
    def update(self, x, y):
        """更新函数"""
        raise NotImplementedError
    
    def evaluate(self, X_test, y_test):
        """评估函数"""
        y_pred = [np.argmax(self.predict(x)) for x in X_test]
        return accuracy_score(y_test, y_pred)

# 在线逻辑回归模型
class OnlineLogisticRegression(OnlineModel):
    def __init__(self, input_dim, output_dim, learning_rate=0.01):
        super().__init__(input_dim, output_dim, learning_rate)
    
    def sigmoid(self, z):
        """sigmoid激活函数"""
        return 1 / (1 + np.exp(-z))
    
    def predict(self, x):
        """预测函数"""
        x = np.array(x).reshape(-1, self.input_dim)
        logits = np.dot(x, self.weights) + self.bias
        return self.sigmoid(logits)
    
    def update(self, x, y):
        """更新函数"""
        x = np.array(x).reshape(-1, self.input_dim)
        y_onehot = np.zeros(self.output_dim)
        y_onehot[y] = 1
        y_onehot = y_onehot.reshape(1, -1)
        
        # 前向传播
        y_pred = self.predict(x)
        
        # 计算损失梯度
        gradient = y_pred - y_onehot
        
        # 更新权重和偏置
        self.weights -= self.learning_rate * np.dot(x.T, gradient)
        self.bias -= self.learning_rate * np.sum(gradient, axis=0)

# 自适应学习率的在线逻辑回归模型
class AdaptiveOnlineLogisticRegression(OnlineLogisticRegression):
    def __init__(self, input_dim, output_dim, initial_learning_rate=0.01, decay_rate=0.999):
        super().__init__(input_dim, output_dim, initial_learning_rate)
        self.initial_learning_rate = initial_learning_rate
        self.decay_rate = decay_rate
        self.step = 0
    
    def update(self, x, y):
        """自适应学习率更新"""
        # 动态调整学习率
        self.learning_rate = self.initial_learning_rate * (self.decay_rate ** self.step)
        
        # 调用父类的更新方法
        super().update(x, y)
        
        # 增加步数
        self.step += 1

# 测试在线学习模型
print("=== 测试在线学习模型 ===")

# 划分训练集和测试集
train_size = 800
test_size = 200
X_train, y_train = X[:train_size], y[:train_size]
X_test, y_test = X[train_size:], y[train_size:]

# 创建数据流
train_stream = [(X_train[i], y_train[i]) for i in range(len(X_train))]

# 初始化模型
input_dim = X.shape[1]
output_dim = len(np.unique(y))

# 固定学习率模型
fixed_lr_model = OnlineLogisticRegression(input_dim, output_dim, learning_rate=0.01)

# 自适应学习率模型
adaptive_lr_model = AdaptiveOnlineLogisticRegression(input_dim, output_dim, initial_learning_rate=0.1)

# 训练模型
fixed_lr_accuracies = []
adaptive_lr_accuracies = []

for i, (x, y) in enumerate(train_stream):
    # 更新固定学习率模型
    fixed_lr_model.update(x, y)
    
    # 更新自适应学习率模型
    adaptive_lr_model.update(x, y)
    
    # 每100步评估一次
    if (i+1) % 100 == 0:
        fixed_acc = fixed_lr_model.evaluate(X_test, y_test)
        adaptive_acc = adaptive_lr_model.evaluate(X_test, y_test)
        fixed_lr_accuracies.append(fixed_acc)
        adaptive_lr_accuracies.append(adaptive_acc)
        print(f"Step {i+1}: Fixed LR Accuracy = {fixed_acc:.4f}, Adaptive LR Accuracy = {adaptive_acc:.4f}")

# 最终评估
fixed_final_acc = fixed_lr_model.evaluate(X_test, y_test)
adaptive_final_acc = adaptive_lr_model.evaluate(X_test, y_test)
print(f"\n最终结果:")
print(f"固定学习率模型准确率: {fixed_final_acc:.4f}")
print(f"自适应学习率模型准确率: {adaptive_final_acc:.4f}")

# 可视化结果
plt.figure(figsize=(10, 6))
steps = list(range(100, train_size+1, 100))
plt.plot(steps, fixed_lr_accuracies, label='固定学习率')
plt.plot(steps, adaptive_lr_accuracies, label='自适应学习率')
plt.xlabel('训练步数')
plt.ylabel('测试准确率')
plt.title('固定学习率 vs 自适应学习率')
plt.legend()
plt.grid(True)
plt.savefig('online_learning_accuracy.png')
print("\n学习曲线已保存为 online_learning_accuracy.png")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier

# 生成二分类数据集
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)

# 增量随机森林类
class IncrementalRandomForest:
    def __init__(self, n_estimators=10, max_depth=None, random_state=42):
        self.n_estimators = n_estimators
        self.max_depth = max_depth
        self.random_state = random_state
        self.forest = []
        self.n_trees = 0
    
    def fit(self, X, y):
        """增量训练"""
        # 如果森林为空，初始化森林
        if not self.forest:
            # 初始训练，创建第一棵树
            tree = RandomForestClassifier(
                n_estimators=1,
                max_depth=self.max_depth,
                random_state=self.random_state
            )
            tree.fit(X, y)
            self.forest.append(tree)
            self.n_trees = 1
        else:
            # 增量训练，添加新树
            if self.n_trees < self.n_estimators:
                # 如果树的数量小于最大数量，添加新树
                new_tree = RandomForestClassifier(
                    n_estimators=1,
                    max_depth=self.max_depth,
                    random_state=self.random_state + self.n_trees
                )
                new_tree.fit(X, y)
                self.forest.append(new_tree)
                self.n_trees += 1
            else:
                # 如果树的数量达到最大数量，替换最旧的树
                # 简单实现：替换第一个树
                new_tree = RandomForestClassifier(
                    n_estimators=1,
                    max_depth=self.max_depth,
                    random_state=self.random_state + self.n_trees
                )
                new_tree.fit(X, y)
                self.forest[0] = new_tree
                self.n_trees += 1
    
    def predict(self, X):
        """预测"""
        if not self.forest:
            raise ValueError("模型尚未训练")
        
        # 收集所有树的预测结果
        predictions = []
        for tree in self.forest:
            tree_preds = tree.predict(X)
            predictions.append(tree_preds)
        
        # 多数投票
        predictions = np.array(predictions)
        final_preds = []
        for i in range(predictions.shape[1]):
            # 计算每个类别的投票数
            counts = np.bincount(predictions[:, i])
            final_preds.append(np.argmax(counts))
        
        return np.array(final_preds)
    
    def evaluate(self, X_test, y_test):
        """评估"""
        y_pred = self.predict(X_test)
        return accuracy_score(y_test, y_pred)

# 测试增量随机森林
print("=== 测试增量随机森林 ===")

# 划分训练集和测试集
train_size = 800
test_size = 200
X_train, y_train = X[:train_size], y[:train_size]
X_test, y_test = X[train_size:], y[train_size:]

# 模拟数据流，分批次到达
batch_size = 100
batches = []
for i in range(0, train_size, batch_size):
    batch_X = X_train[i:i+batch_size]
    batch_y = y_train[i:i+batch_size]
    batches.append((batch_X, batch_y))

# 初始化增量随机森林
incremental_rf = IncrementalRandomForest(n_estimators=5, max_depth=10)

# 训练增量随机森林
accuracies = []
for i, (batch_X, batch_y) in enumerate(batches):
    # 增量训练
    incremental_rf.fit(batch_X, batch_y)
    
    # 评估模型
    acc = incremental_rf.evaluate(X_test, y_test)
    accuracies.append(acc)
    print(f"批次 {i+1}/{len(batches)}: 准确率 = {acc:.4f}")

# 对比传统随机森林
print("\n=== 对比传统随机森林 ===")
traditional_rf = RandomForestClassifier(n_estimators=5, max_depth=10, random_state=42)
traditional_rf.fit(X_train, y_train)
traditional_acc = traditional_rf.score(X_test, y_test)
print(f"传统随机森林准确率: {traditional_acc:.4f}")
print(f"增量随机森林最终准确率: {accuracies[-1]:.4f}")

# 可视化结果
plt.figure(figsize=(10, 6))
batches_range = list(range(1, len(batches)+1))
plt.plot(batches_range, accuracies, label='增量随机森林')
plt.axhline(y=traditional_acc, color='r', linestyle='--', label='传统随机森林')
plt.xlabel('训练批次')
plt.ylabel('测试准确率')
plt.title('增量随机森林 vs 传统随机森林')
plt.legend()
plt.grid(True)
plt.savefig('incremental_rf_accuracy.png')
print("\n学习曲线已保存为 incremental_rf_accuracy.png")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression

# 生成两类不同分布的数据
def generate_data(distribution_type, n_samples=200, random_state=42):
    """生成不同分布的数据"""
    if distribution_type == 'A':
        X, y = make_classification(
            n_samples=n_samples, n_features=10, n_classes=2,
            n_informative=5, n_redundant=3, random_state=random_state
        )
    elif distribution_type == 'B':
        # 不同分布的数据
        X, y = make_classification(
            n_samples=n_samples, n_features=10, n_classes=2,
            n_informative=3, n_redundant=5, random_state=random_state + 100
        )
    return X, y

# 生成数据集
print("=== 生成数据集 ===")

# 分布A的数据（任务1）
X_A, y_A = generate_data('A', n_samples=400, random_state=42)

# 分布B的数据（任务2）
X_B, y_B = generate_data('B', n_samples=400, random_state=42)

# 划分训练集和测试集
X_A_train, X_A_test = X_A[:300], X_A[300:]
y_A_train, y_A_test = y_A[:300], y_A[300:]

X_B_train, X_B_test = X_B[:300], X_B[300:]
y_B_train, y_B_test = y_B[:300], y_B[300:]

# 基础模型类
class BasicModel:
    def __init__(self):
        self.model = LogisticRegression(random_state=42, max_iter=1000)
    
    def fit(self, X, y):
        self.model.fit(X, y)
    
    def predict(self, X):
        return self.model.predict(X)
    
    def score(self, X, y):
        return accuracy_score(y, self.predict(X))

# 带有知识蒸馏的模型类
class KnowledgeDistillationModel:
    def __init__(self, temperature=2.0, alpha=0.5):
        self.model = LogisticRegression(random_state=42, max_iter=1000)
        self.temperature = temperature
        self.alpha = alpha
    
    def softmax_with_temperature(self, logits, temperature):
        """带温度参数的softmax"""
        logits = logits / temperature
        exp_logits = np.exp(logits - np.max(logits, axis=1, keepdims=True))
        return exp_logits / np.sum(exp_logits, axis=1, keepdims=True)
    
    def fit(self, X, y, teacher_model=None):
        if teacher_model is None:
            # 没有教师模型，直接训练
            self.model.fit(X, y)
        else:
            # 使用知识蒸馏训练
            # 1. 训练基本模型
            basic_model = LogisticRegression(random_state=42, max_iter=1000)
            basic_model.fit(X, y)
            
            # 2. 获取教师模型的软标签
            if hasattr(teacher_model.model, 'predict_proba'):
                teacher_logits = teacher_model.model.predict_proba(X)
            else:
                # 如果教师模型没有predict_proba，使用硬标签
                teacher_logits = np.eye(2)[teacher_model.predict(X)]
            
            # 3. 获取基础模型的软标签
            student_logits = basic_model.predict_proba(X)
            
            # 4. 计算知识蒸馏损失
            # 软损失：教师和学生软标签的KL散度
            teacher_soft = self.softmax_with_temperature(teacher_logits, self.temperature)
            student_soft = self.softmax_with_temperature(student_logits, self.temperature)
            kl_div = np.mean(np.sum(teacher_soft * np.log(teacher_soft / (student_soft + 1e-8)), axis=1))
            
            # 硬损失：学生硬标签的交叉熵
            student_hard = basic_model.predict(X)
            ce_loss = np.mean(y != student_hard)
            
            # 总损失
            total_loss = self.alpha * kl_div + (1 - self.alpha) * ce_loss
            print(f"知识蒸馏损失: 软损失 = {kl_div:.4f}, 硬损失 = {ce_loss:.4f}, 总损失 = {total_loss:.4f}")
            
            # 5. 使用基础模型作为最终模型
            self.model = basic_model

# 带有重播机制的模型类
class ReplayModel:
    def __init__(self, replay_size=100):
        self.model = LogisticRegression(random_state=42, max_iter=1000)
        self.replay_buffer = []
        self.replay_size = replay_size
    
    def add_to_replay(self, X, y):
        """添加数据到重播缓冲区"""
        for x_i, y_i in zip(X, y):
            self.replay_buffer.append((x_i, y_i))
            # 保持缓冲区大小
            if len(self.replay_buffer) > self.replay_size:
                self.replay_buffer.pop(0)
    
    def fit(self, X, y):
        """训练模型，使用重播缓冲区"""
        # 添加当前数据到重播缓冲区
        self.add_to_replay(X, y)
        
        # 从重播缓冲区中获取数据
        replay_X = np.array([x for x, y in self.replay_buffer])
        replay_y = np.array([y for x, y in self.replay_buffer])
        
        # 训练模型
        self.model.fit(replay_X, replay_y)
    
    def predict(self, X):
        return self.model.predict(X)
    
    def score(self, X, y):
        return accuracy_score(y, self.predict(X))

# 测试不同模型的灾难性遗忘情况
print("\n=== 测试灾难性遗忘 ===")

# 1. 基础模型（无任何缓解措施）
print("\n--- 基础模型 ---")
basic_model = BasicModel()
# 训练任务1
basic_model.fit(X_A_train, y_A_train)
# 评估任务1
a1 = basic_model.score(X_A_test, y_A_test)
print(f"基础模型在任务1上的准确率: {a1:.4f}")
# 训练任务2
basic_model.fit(X_B_train, y_B_train)
# 评估任务1和任务2
a1_after = basic_model.score(X_A_test, y_A_test)
a2 = basic_model.score(X_B_test, y_B_test)
print(f"基础模型在任务1上的准确率（训练任务2后）: {a1_after:.4f}")
print(f"基础模型在任务2上的准确率: {a2:.4f}")
print(f"任务1准确率下降: {a1 - a1_after:.4f}")

# 2. 知识蒸馏模型
print("\n--- 知识蒸馏模型 ---")
# 训练任务1的教师模型
teacher_model = BasicModel()
teacher_model.fit(X_A_train, y_A_train)
# 训练任务2的学生模型，使用知识蒸馏
kd_model = KnowledgeDistillationModel(temperature=2.0, alpha=0.5)
kd_model.fit(X_B_train, y_B_train, teacher_model=teacher_model)
# 评估任务1和任务2
a1_kd = kd_model.score(X_A_test, y_A_test)
a2_kd = kd_model.score(X_B_test, y_B_test)
print(f"知识蒸馏模型在任务1上的准确率: {a1_kd:.4f}")
print(f"知识蒸馏模型在任务2上的准确率: {a2_kd:.4f}")
print(f"任务1准确率下降: {a1 - a1_kd:.4f}")

# 3. 重播机制模型
print("\n--- 重播机制模型 ---")
replay_model = ReplayModel(replay_size=200)
# 训练任务1
replay_model.fit(X_A_train, y_A_train)
# 评估任务1
a1_replay = replay_model.score(X_A_test, y_A_test)
print(f"重播模型在任务1上的准确率: {a1_replay:.4f}")
# 训练任务2
replay_model.fit(X_B_train, y_B_train)
# 评估任务1和任务2
a1_replay_after = replay_model.score(X_A_test, y_A_test)
a2_replay = replay_model.score(X_B_test, y_B_test)
print(f"重播模型在任务1上的准确率（训练任务2后）: {a1_replay_after:.4f}")
print(f"重播模型在任务2上的准确率: {a2_replay:.4f}")
print(f"任务1准确率下降: {a1_replay - a1_replay_after:.4f}")

# 可视化结果
plt.figure(figsize=(12, 8))

# 任务1准确率
models = ['基础模型', '知识蒸馏模型', '重播机制模型']
task1_initial = [a1, a1, a1_replay]
task1_after = [a1_after, a1_kd, a1_replay_after]
task2 = [a2, a2_kd, a2_replay]

x = np.arange(len(models))
width = 0.25

plt.subplot(2, 1, 1)
plt.bar(x - width, task1_initial, width, label='任务1初始准确率')
plt.bar(x, task1_after, width, label='任务1准确率（训练任务2后）')
plt.bar(x + width, task2, width, label='任务2准确率')
plt.xlabel('模型类型')
plt.ylabel('准确率')
plt.title('不同模型的准确率对比')
plt.xticks(x, models)
plt.legend()
plt.grid(True)

# 任务1准确率下降
plt.subplot(2, 1, 2)
drop = [a1 - a1_after, a1 - a1_kd, a1_replay - a1_replay_after]
plt.bar(x, drop, width)
plt.xlabel('模型类型')
plt.ylabel('准确率下降')
plt.title('任务1准确率下降对比')
plt.xticks(x, models)
plt.grid(True)

plt.tight_layout()
plt.savefig('catastrophic_forgetting.png')
print("\n灾难性遗忘对比图已保存为 catastrophic_forgetting.png")

# 安装基本依赖
pip install numpy pandas scikit-learn matplotlib seaborn

# 安装在线学习库
pip install river vowpalwabbit

# 安装深度学习框架
pip install torch tensorflow

# 安装流处理库
pip install pyspark

# 安装评估工具
pip install alibi-detect