大模型的记忆困境：平衡持续学习与灾难性遗忘 精华

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neural_network import MLPClassifier

# 生成两个简单的二分类数据集
np.random.seed(0)
X1 = np.random.randn(100, 2)
y1 = (X1[:, 0] + X1[:, 1] > 0).astype(int)
X2 = np.random.randn(100, 2) + 3
y2 = (X2[:, 0] - X2[:, 1] > 0).astype(int)

# 创建并训练神经网络
model = MLPClassifier(hidden_layer_sizes=(10,), max_iter=1000)

# 训练任务1
model.fit(X1, y1)
accuracy1_before = model.score(X1, y1)

# 训练任务2
model.fit(X2, y2)
accuracy1_after = model.score(X1, y1)
accuracy2 = model.score(X2, y2)

print(f"Task 1 accuracy before Task 2: {accuracy1_before:.2f}")
print(f"Task 1 accuracy after Task 2: {accuracy1_after:.2f}")
print(f"Task 2 accuracy: {accuracy2:.2f}")

import numpy as np

def generate_data(task, n_samples=100):
    if task == 0:
        return np.random.randn(n_samples, 2), (np.random.randn(n_samples) > 0).astype(int)
    else:
        return np.random.randn(n_samples, 2) + 2, (np.random.randn(n_samples) > 0).astype(int)

# 基于任务的持续学习
for task in [0, 1]:
    X, y = generate_data(task)
    # 训练模型...

# 无任务持续学习
for t in range(1000):
    task_prob = min(1, t / 500)  # 任务概率随时间变化
    task = np.random.choice([0, 1], p=[1-task_prob, task_prob])
    X, y = generate_data(task, n_samples=1)
    # 训练模型...

class ContinualLearningEvaluator:
    def __init__(self):
        self.performance_history = []
        self.backward_transfer = []
        self.forward_transfer = []
        self.memory_usage = []
        self.computation_time = []

    def evaluate(self, model, task_id, X_test, y_test):
        # 评估性能
        performance = model.score(X_test, y_test)
        self.performance_history.append((task_id, performance))

        # 计算向后迁移
        if task_id > 0:
            prev_performance = self.performance_history[task_id-1][1]
            self.backward_transfer.append(performance - prev_performance)

        # 记录资源使用
        self.memory_usage.append(model.get_memory_usage())
        self.computation_time.append(model.get_computation_time())

    def report(self):
        print(f"Average Performance: {np.mean([p for _, p in self.performance_history]):.2f}")
        print(f"Average Backward Transfer: {np.mean(self.backward_transfer):.2f}")
        print(f"Average Memory Usage: {np.mean(self.memory_usage):.2f} MB")
        print(f"Total Computation Time: {sum(self.computation_time):.2f} s")

class ExperienceReplay:
    def __init__(self, buffer_size=1000):
        self.buffer = []
        self.buffer_size = buffer_size

    def add_experience(self, experience):
        if len(self.buffer) >= self.buffer_size:
            self.buffer.pop(0)
        self.buffer.append(experience)

    def sample_batch(self, batch_size):
        return random.sample(self.buffer, min(batch_size, len(self.buffer)))

# 使用示例
replay_buffer = ExperienceReplay()
for epoch in range(num_epochs):
    for x, y in current_task_data:
        # 训练当前任务
        model.train_step(x, y)
        
        # 添加经验到缓冲区
        replay_buffer.add_experience((x, y))
        
        # 回放旧经验
        if len(replay_buffer.buffer) > batch_size:
            replay_batch = replay_buffer.sample_batch(batch_size)
            for old_x, old_y in replay_batch:
                model.train_step(old_x, old_y)

import torch
import torch.nn as nn
import torch.optim as optim

class EWC(nn.Module):
    def __init__(self, model, lambda_reg=0.1):
        super(EWC, self).__init__()
        self.model = model
        self.lambda_reg = lambda_reg
        self.fisher = {}
        self.old_params = {}

    def estimate_fisher(self, data_loader, num_samples=1000):
        self.model.eval()
        for name, param in self.model.named_parameters():
            self.fisher[name] = torch.zeros_like(param.data)
        
        for i, (input, target) in enumerate(data_loader):
            if i >= num_samples:
                break
            self.model.zero_grad()
            output = self.model(input)
            loss = F.cross_entropy(output, target)
            loss.backward()
            
            for name, param in self.model.named_parameters():
                self.fisher[name] += param.grad.data ** 2 / num_samples
        
        for name, param in self.model.named_parameters():
            self.old_params[name] = param.data.clone()

    def ewc_loss(self):
        loss = 0
        for name, param in self.model.named_parameters():
            loss += (self.fisher[name] * (param - self.old_params[name]) ** 2).sum()
        return self.lambda_reg * loss

# 使用示例
model = MyModel()
ewc = EWC(model)

# 估计Fisher信息
ewc.estimate_fisher(old_task_loader)

# 训练新任务
optimizer = optim.SGD(model.parameters(), lr=0.01)
for epoch in range(num_epochs):
    for x, y in new_task_data:
        optimizer.zero_grad()
        output = model(x)
        loss = F.cross_entropy(output, y) + ewc.ewc_loss()
        loss.backward()
        optimizer.step()

import torch
import torch.nn as nn
import torch.nn.functional as F

class FunctionalRegularization(nn.Module):
    def __init__(self, model, num_anchors=100, lambda_reg=0.1):
        super(FunctionalRegularization, self).__init__()
        self.model = model
        self.num_anchors = num_anchors
        self.lambda_reg = lambda_reg
        self.anchors = None
        self.old_outputs = None

    def set_anchors(self, data_loader):
        self.anchors = []
        self.model.eval()
        with torch.no_grad():
            for inputs, _ in data_loader:
                self.anchors.append(inputs[:self.num_anchors])
                if len(self.anchors) * inputs.size(0) >= self.num_anchors:
                    break
        self.anchors = torch.cat(self.anchors)[:self.num_anchors]
        self.old_outputs = self.model(self.anchors)

    def functional_reg_loss(self):
        if self.anchors is None:
            return 0
        new_outputs = self.model(self.anchors)
        return self.lambda_reg * F.mse_loss(new_outputs, self.old_outputs)

# 使用示例
model = MyModel()
func_reg = FunctionalRegularization(model)

# 设置锚点
func_reg.set_anchors(old_task_loader)

# 训练新任务
optimizer = optim.Adam(model.parameters())
for epoch in range(num_epochs):
    for x, y in new_task_data:
        optimizer.zero_grad()
        output = model(x)
        loss = F.cross_entropy(output, y) + func_reg.functional_reg_loss()
        loss.backward()
        optimizer.step()

class AdaptiveLearningRateOptimizer:
    def __init__(self, model, base_lr=0.01, importance_threshold=0.1):
        self.model = model
        self.base_lr = base_lr
        self.importance_threshold = importance_threshold
        self.parameter_importance = {}

    def estimate_importance(self, data_loader):
        self.model.eval()
        for name, param in self.model.named_parameters():
            self.parameter_importance[name] = torch.zeros_like(param.data)

        for inputs, targets in data_loader:
            self.model.zero_grad()
            outputs = self.model(inputs)
            loss = nn.functional.cross_entropy(outputs, targets)
            loss.backward()

            for name, param in self.model.named_parameters():
                self.parameter_importance[name] += torch.abs(param.grad.data)

    def get_adapted_lr(self, name, param):
        importance = self.parameter_importance[name]
        adapted_lr = torch.where(
            importance > self.importance_threshold,
            self.base_lr / importance,
            torch.ones_like(importance) * self.base_lr
        )
        return adapted_lr

    def step(self):
        for name, param in self.model.named_parameters():
            if param.grad is not None:
                adapted_lr = self.get_adapted_lr(name, param)
                param.data -= adapted_lr * param.grad.data

# 使用示例
model = MyModel()
optimizer = AdaptiveLearningRateOptimizer(model)

# 估计参数重要性
optimizer.estimate_importance(old_task_loader)

# 训练新任务
for epoch in range(num_epochs):
    for inputs, targets in new_task_loader:
        model.zero_grad()
        outputs = model(inputs)
        loss = nn.functional.cross_entropy(outputs, targets)
        loss.backward()
        optimizer.step()

import torch
import torch.nn as nn

class MultiHeadNetwork(nn.Module):
    def __init__(self, input_size, hidden_size, num_tasks, task_output_sizes):
        super(MultiHeadNetwork, self).__init__()
        self.shared_layers = nn.Sequential(
            nn.Linear(input_size, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, hidden_size),
            nn.ReLU()
        )
        self.task_heads = nn.ModuleList([
            nn.Linear(hidden_size, output_size) for output_size in task_output_sizes
        ])

    def forward(self, x, task_id):
        shared_output = self.shared_layers(x)
        return self.task_heads[task_id](shared_output)

# 使用示例
input_size = 784  # 例如，对于MNIST数据集
hidden_size = 256
num_tasks = 5
task_output_sizes = [10, 10, 10, 10, 10]  # 假设每个任务都是10类分类

model = MultiHeadNetwork(input_size, hidden_size, num_tasks, task_output_sizes)

# 训练
optimizer = torch.optim.Adam(model.parameters())
for epoch in range(num_epochs):
    for inputs, targets, task_id in mixed_task_loader:
        optimizer.zero_grad()
        outputs = model(inputs, task_id)
        loss = nn.functional.cross_entropy(outputs, targets)
        loss.backward()
        optimizer.step()

import torch
import torch.nn as nn
import torch.nn.functional as F

class PrototypicalNetwork(nn.Module):
    def __init__(self, input_size, embedding_size):
        super(PrototypicalNetwork, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_size, 256),
            nn.ReLU(),
            nn.Linear(256, embedding_size)
        )
        self.prototypes = nn.Parameter(torch.randn(100, embedding_size))  # 假设最多100个类

    def forward(self, x):
        embeddings = self.encoder(x)
        distances = torch.cdist(embeddings, self.prototypes)
        return -distances  # 返回负距离作为相似度得分

    def add_prototype(self, new_data):
        with torch.no_grad():
            new_embedding = self.encoder(new_data).mean(0)
            self.prototypes = nn.Parameter(torch.cat([self.prototypes, new_embedding.unsqueeze(0)]))

# 使用示例
input_size = 784  # 例如，对于MNIST数据集
embedding_size = 64
model = PrototypicalNetwork(input_size, embedding_size)

# 训练
optimizer = torch.optim.Adam(model.parameters())
for epoch in range(num_epochs):
    for inputs, targets in train_loader:
        optimizer.zero_grad()
        similarities = model(inputs)
        loss = F.cross_entropy(-similarities, targets)
        loss.backward()
        optimizer.step()

# 添加新类
for new_class_data, _ in new_class_loader:
    model.add_prototype(new_class_data)

import torch
import torch.nn as nn
import torch.nn.functional as F

def compute_fisher_diag(model, data_loader, num_samples=1000):
    fisher = {}
    for name, param in model.named_parameters():
        fisher[name] = torch.zeros_like(param.data)
    
    model.eval()
    for i, (input, target) in enumerate(data_loader):
        if i >= num_samples:
            break
        model.zero_grad()
        output = model(input)
        loss = F.nll_loss(F.log_softmax(output, dim=1), target)
        loss.backward()
        
        for name, param in model.named_parameters():
            fisher[name] += param.grad.data ** 2 / num_samples
    
    return fisher

# 使用示例
model = YourNeuralNetwork()
fisher_diag = compute_fisher_diag(model, train_loader)

# 在EWC中使用Fisher信息
for name, param in model.named_parameters():
    ewc_loss += 0.5 * fisher_diag[name] * (param - old_params[name]).pow(2).sum()