结构健康监测仿真-主题029-结构健康监测中的迁移学习技术

kkchenkx

178人浏览 · 2026-04-28 22:14:04

kkchenkx · 2026-04-28 22:14:04 发布

结构健康监测仿真-主题029-结构健康监测中的迁移学习技术

1. 迁移学习技术概述

1.1 迁移学习的基本概念

迁移学习（Transfer Learning）是机器学习的一个重要分支，它研究如何将从一个领域（源域）学到的知识应用到另一个不同但相关的领域（目标域）。在结构健康监测中，迁移学习可以帮助解决数据稀缺问题，利用已有的结构监测数据来辅助新结构的监测模型训练。

迁移学习的核心思想是：

知识复用：利用源域的知识来帮助目标域的学习
减少数据需求：在目标域数据有限的情况下仍能建立有效模型
加速模型训练：利用预训练模型加速新模型的训练过程
提高泛化能力：通过多领域学习提高模型的泛化能力

1.2 迁移学习的类型

根据源域和目标域之间的关系，迁移学习可以分为以下几种类型：

1.2.1 基于实例的迁移学习

基于实例的迁移学习通过重新加权源域样本来辅助目标域学习。主要方法包括：

样本重加权：给源域中与目标域相似的样本更高的权重
TrAdaBoost算法：迭代调整样本权重，关注难以分类的样本
重要性采样：根据目标域分布对源域样本进行采样

1.2.2 基于特征的迁移学习

基于特征的迁移学习通过找到源域和目标域之间的共同特征表示来实现知识迁移。主要方法包括：

特征选择：选择源域和目标域共有的重要特征
特征变换：将源域和目标域的特征映射到共同的特征空间
深度特征学习：使用深度神经网络学习领域不变的特征表示

1.2.3 基于模型的迁移学习

基于模型的迁移学习通过共享模型参数来实现知识迁移。主要方法包括：

预训练-微调：在源域上预训练模型，然后在目标域上微调
多任务学习：同时学习源域和目标域的任务
模型蒸馏：将大模型的知识迁移到小模型

1.2.4 基于关系的迁移学习

基于关系的迁移学习通过迁移源域和目标域之间的关系知识。主要方法包括：

关系迁移：迁移源域中的逻辑关系或规则
图迁移：迁移图结构中的知识

1.3 迁移学习的优势

迁移学习相比传统机器学习方法具有以下优势：

减少数据需求：在目标域数据稀缺的情况下仍能建立有效模型
加速训练：利用预训练模型可以显著减少训练时间
提高性能：在目标域数据有限时，迁移学习通常比从头训练效果更好
降低成本：减少对大量标注数据的需求，降低数据标注成本
知识积累：可以持续积累和利用历史知识

2. 迁移学习在结构健康监测中的应用

2.1 应用场景

迁移学习在结构健康监测中的应用场景主要包括：

新结构监测：利用已有结构的监测数据辅助新结构的监测模型建立
损伤识别：将一种损伤类型的识别模型迁移到另一种损伤类型
跨结构类型迁移：将桥梁的监测模型迁移到建筑结构
跨环境迁移：将在实验室环境下训练的模型迁移到实际工程环境
跨传感器迁移：将一种传感器的数据模型迁移到另一种传感器

2.2 技术优势

迁移学习在结构健康监测中的技术优势主要包括：

解决数据稀缺问题：新结构或新型损伤往往缺乏足够的训练数据
提高模型泛化能力：通过多结构学习提高模型的泛化能力
加速模型部署：利用预训练模型快速部署到新结构
降低监测成本：减少对大量历史数据的需求
知识复用：充分利用已有的监测经验和知识

2.3 挑战与解决方案

迁移学习在结构健康监测中面临的挑战主要包括：

领域差异大：不同结构类型、不同环境条件下的数据分布差异较大
负迁移：不恰当的迁移可能导致性能下降
迁移策略选择：如何选择合适的迁移策略是一个难题
可解释性：迁移学习模型的决策过程难以解释

解决方案：

领域自适应：使用领域自适应技术减小源域和目标域之间的分布差异
迁移学习算法选择：根据具体问题选择合适的迁移学习算法
迁移效果评估：建立迁移效果评估机制，避免负迁移
可解释AI：使用注意力机制等技术提高模型的可解释性

3. 迁移学习方法在结构健康监测中的应用

3.1 预训练-微调方法

预训练-微调是最常用的迁移学习方法，在结构健康监测中可以用于：

跨结构迁移：在一个结构上预训练模型，在另一个结构上微调
跨损伤类型迁移：在一种损伤类型上预训练，在另一种损伤类型上微调
跨环境迁移：在实验室环境下预训练，在实际工程环境下微调

3.1.1 预训练阶段

在源域（已有大量数据的结构）上训练深度学习模型：

使用源域的大量数据训练深度神经网络
学习通用的特征表示
保存预训练模型的参数

3.1.2 微调阶段

在目标域（新结构或数据稀缺的结构）上微调模型：

加载预训练模型的参数
冻结部分层（通常是底层），只微调顶层
使用目标域的数据进行微调训练
根据目标域数据量决定微调的程度

3.2 领域自适应方法

领域自适应（Domain Adaptation）通过减小源域和目标域之间的分布差异来实现迁移。

3.2.1 对抗性领域自适应

对抗性领域自适应使用对抗训练来学习领域不变的特征：

特征提取器：提取领域不变的特征
领域判别器：区分特征来自源域还是目标域
对抗训练：特征提取器试图欺骗领域判别器，学习领域不变的特征

在结构健康监测中的应用：

跨环境适应：适应不同环境条件下的数据分布差异
跨传感器适应：适应不同传感器的数据特征差异
跨结构适应：适应不同结构类型的数据特征差异

3.2.2 基于统计的领域自适应

基于统计的方法通过匹配源域和目标域的统计特征来实现迁移：

最大均值差异（MMD）：最小化源域和目标域特征分布的MMD
相关对齐（CORAL）：对齐源域和目标域的特征协方差
联合分布适应（JDA）：同时适应边缘分布和条件分布

3.3 多任务学习方法

多任务学习通过同时学习多个相关任务来实现知识共享和迁移。

在结构健康监测中的应用：

多结构联合监测：同时监测多个结构，共享特征提取层
多损伤类型识别：同时识别多种损伤类型，共享底层特征
多传感器数据融合：融合多种传感器数据，共享特征表示

3.3.1 硬参数共享

多个任务共享相同的网络层：

共享底层特征提取层
每个任务有独立的输出层
适用于任务之间高度相关的情况

3.3.2 软参数共享

每个任务有独立的网络，但通过正则化约束使参数相似：

每个任务有独立的网络结构
使用L2正则化约束参数相似
适用于任务之间有一定差异的情况

3.4 元学习方法

元学习（Meta-Learning）通过学习如何学习来实现快速适应新任务。

在结构健康监测中的应用：

快速适应新结构：利用少量数据快速适应新结构的监测
快速适应新损伤：利用少量样本快速识别新型损伤
在线学习：实时适应结构状态的变化

3.4.1 基于优化的元学习

MAML（Model-Agnostic Meta-Learning）是一种经典的元学习算法：

学习一个好的模型初始化参数
使得模型能够通过少量梯度下降步骤快速适应新任务
在结构健康监测中可以快速适应新结构或新损伤类型

3.4.2 基于度量的元学习

基于度量的元学习通过学习一个度量空间来实现快速分类：

原型网络（Prototypical Networks）：学习类别的原型表示
匹配网络（Matching Networks）：学习样本之间的匹配关系
在结构健康监测中可以用于小样本损伤识别

4. 迁移学习系统架构

4.1 系统层次结构

迁移学习结构健康监测系统通常分为以下层次：

数据采集层：多源传感器网络，负责多结构数据采集
数据预处理层：对不同结构的数据进行预处理和标准化
特征提取层：使用深度学习提取通用特征表示
迁移学习层：实现源域到目标域的知识迁移
模型推理层：使用迁移后的模型进行预测
应用层：用户界面和应用服务

4.2 关键组件

多源数据采集系统：收集多个结构的监测数据
数据对齐模块：对齐不同结构的数据格式和分布
预训练模型库：存储各种预训练模型
迁移学习引擎：实现各种迁移学习算法
领域自适应模块：减小源域和目标域的分布差异
模型评估模块：评估迁移学习的效果
模型部署模块：将迁移后的模型部署到目标结构

4.3 数据流程

多源数据采集：从多个结构采集监测数据
数据预处理：对不同结构的数据进行清洗、归一化等预处理
源域模型训练：在源域数据上训练深度学习模型
领域自适应：使用领域自适应技术减小分布差异
目标域微调：在目标域数据上微调模型
模型评估：评估迁移学习的效果
模型部署：将迁移后的模型部署到目标结构

5. 案例分析：基于迁移学习的多桥梁健康监测

5.1 案例背景

某地区有多座相似的桥梁需要健康监测，但只有部分桥梁有足够的历史监测数据。目标是利用数据丰富的桥梁（源域）来辅助数据稀缺的桥梁（目标域）建立监测模型。

5.2 系统架构

数据采集层：多座桥梁的加速度传感器网络
数据预处理层：对不同桥梁的数据进行标准化处理
特征提取层：使用一维卷积神经网络提取通用振动特征
迁移学习层：使用领域自适应技术实现知识迁移
分类层：使用全连接网络进行损伤分类
应用层：Web应用，展示多桥梁监测数据和分析结果

5.3 实现方案

数据采集：使用加速度传感器采集多座桥梁的振动数据
数据预处理：对不同桥梁的数据进行滤波、归一化和分段
源域模型训练：在数据丰富的桥梁上训练深度学习模型
领域自适应：使用对抗性领域自适应技术减小桥梁间的分布差异
目标域微调：在数据稀缺的桥梁上微调模型
模型评估：评估迁移学习的效果

5.4 运行效果

迁移效果：迁移学习模型在目标桥梁上的准确率达到了90%以上，比从头训练提高了20%
数据效率：只需要目标桥梁10%的数据就能达到较好的性能
训练加速：迁移学习的训练时间比从头训练减少了50%
泛化能力：模型在不同桥梁之间具有良好的泛化能力

6. Python仿真代码

6.1 迁移学习环境设置

import numpy as np
import matplotlib.pyplot as plt
import imageio
import os
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.decomposition import PCA

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

# 设置matplotlib使用Agg后端，避免弹出窗口
plt.switch_backend('Agg')

6.2 多源数据生成

def generate_source_data(n_samples=1000, signal_length=100):
    """生成源域数据（数据丰富的结构）"""
    # 生成正常状态数据
    normal_data = []
    for _ in range(n_samples // 2):
        # 生成正常振动信号
        t = np.linspace(0, 1, signal_length)
        signal = np.sin(2 * np.pi * 5 * t) + 0.1 * np.random.randn(signal_length)
        normal_data.append(signal)
    normal_data = np.array(normal_data)
    normal_labels = np.zeros(n_samples // 2)
    
    # 生成损伤状态数据
    damage_data = []
    for _ in range(n_samples // 2):
        # 生成损伤振动信号（增加高频成分）
        t = np.linspace(0, 1, signal_length)
        signal = np.sin(2 * np.pi * 5 * t) + 0.5 * np.sin(2 * np.pi * 20 * t) + 0.1 * np.random.randn(signal_length)
        damage_data.append(signal)
    damage_data = np.array(damage_data)
    damage_labels = np.ones(n_samples // 2)
    
    # 合并数据
    X = np.vstack([normal_data, damage_data])
    y = np.hstack([normal_labels, damage_labels])
    
    # 打乱数据
    indices = np.random.permutation(n_samples)
    X = X[indices]
    y = y[indices]
    
    return X, y

def generate_target_data(n_samples=100, signal_length=100, domain_shift=0.3):
    """生成目标域数据（数据稀缺的结构，有领域偏移）"""
    # 生成正常状态数据（添加领域偏移）
    normal_data = []
    for _ in range(n_samples // 2):
        # 生成正常振动信号（添加偏移）
        t = np.linspace(0, 1, signal_length)
        signal = np.sin(2 * np.pi * 5 * t) + domain_shift * np.sin(2 * np.pi * 3 * t) + 0.15 * np.random.randn(signal_length)
        normal_data.append(signal)
    normal_data = np.array(normal_data)
    normal_labels = np.zeros(n_samples // 2)
    
    # 生成损伤状态数据（添加领域偏移）
    damage_data = []
    for _ in range(n_samples // 2):
        # 生成损伤振动信号（添加偏移）
        t = np.linspace(0, 1, signal_length)
        signal = np.sin(2 * np.pi * 5 * t) + 0.5 * np.sin(2 * np.pi * 20 * t) + domain_shift * np.sin(2 * np.pi * 3 * t) + 0.15 * np.random.randn(signal_length)
        damage_data.append(signal)
    damage_data = np.array(damage_data)
    damage_labels = np.ones(n_samples // 2)
    
    # 合并数据
    X = np.vstack([normal_data, damage_data])
    y = np.hstack([normal_labels, damage_labels])
    
    # 打乱数据
    indices = np.random.permutation(n_samples)
    X = X[indices]
    y = y[indices]
    
    return X, y

6.3 深度学习模型

class NeuralNetwork:
    """神经网络模型"""
    def __init__(self, input_size=100, hidden_size=50, output_size=2):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        
        # 初始化权重
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros(output_size)
    
    def relu(self, x):
        """ReLU激活函数"""
        return np.maximum(0, x)
    
    def softmax(self, x):
        """Softmax激活函数"""
        exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))
        return exp_x / np.sum(exp_x, axis=1, keepdims=True)
    
    def forward(self, X):
        """前向传播"""
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.relu(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.softmax(self.z2)
        return self.a2
    
    def train(self, X_train, y_train, epochs=100, learning_rate=0.01, verbose=True):
        """训练模型"""
        n_samples = X_train.shape[0]
        
        for epoch in range(epochs):
            # 前向传播
            output = self.forward(X_train)
            
            # 计算损失（交叉熵损失）
            y_onehot = np.zeros((n_samples, self.output_size))
            y_onehot[np.arange(n_samples), y_train.astype(int)] = 1
            loss = -np.sum(y_onehot * np.log(output + 1e-8)) / n_samples
            
            # 反向传播
            dz2 = output - y_onehot
            dW2 = np.dot(self.a1.T, dz2) / n_samples
            db2 = np.sum(dz2, axis=0) / n_samples
            
            da1 = np.dot(dz2, self.W2.T)
            dz1 = da1 * (self.z1 > 0)
            dW1 = np.dot(X_train.T, dz1) / n_samples
            db1 = np.sum(dz1, axis=0) / n_samples
            
            # 更新参数
            self.W2 -= learning_rate * dW2
            self.b2 -= learning_rate * db2
            self.W1 -= learning_rate * dW1
            self.b1 -= learning_rate * db1
            
            if verbose and epoch % 20 == 0:
                print(f'Epoch {epoch}, Loss: {loss:.4f}')
    
    def predict(self, X):
        """预测"""
        output = self.forward(X)
        return np.argmax(output, axis=1)
    
    def evaluate(self, X_test, y_test):
        """评估模型"""
        y_pred = self.predict(X_test)
        accuracy = accuracy_score(y_test, y_pred)
        cm = confusion_matrix(y_test, y_pred)
        return accuracy, cm
    
    def get_features(self, X):
        """获取特征表示"""
        z1 = np.dot(X, self.W1) + self.b1
        a1 = self.relu(z1)
        return a1

6.4 迁移学习系统仿真

class TransferLearningSystem:
    def __init__(self):
        self.source_X = None
        self.source_y = None
        self.target_X = None
        self.target_y = None
        self.source_model = None
        self.target_model = None
        self.baseline_model = None
        self.transfer_accuracy = None
        self.baseline_accuracy = None
    
    def run_simulation(self, source_samples=1000, target_samples=100):
        """运行迁移学习系统仿真"""
        print('运行结构健康监测迁移学习系统仿真...')
        
        # 生成源域数据（数据丰富的结构）
        print('1. 生成源域数据（数据丰富的结构）...')
        self.source_X, self.source_y = generate_source_data(source_samples)
        print(f'源域数据量: {source_samples} 条记录')
        
        # 生成目标域数据（数据稀缺的结构）
        print('2. 生成目标域数据（数据稀缺的结构）...')
        self.target_X, self.target_y = generate_target_data(target_samples)
        print(f'目标域数据量: {target_samples} 条记录')
        
        # 划分目标域训练集和测试集
        target_train_size = int(0.8 * target_samples)
        target_X_train, target_X_test = self.target_X[:target_train_size], self.target_X[target_train_size:]
        target_y_train, target_y_test = self.target_y[:target_train_size], self.target_y[target_train_size:]
        
        # 在源域上训练模型（预训练）
        print('3. 在源域上训练模型（预训练）...')
        self.source_model = NeuralNetwork(input_size=self.source_X.shape[1], hidden_size=50, output_size=2)
        self.source_model.train(self.source_X, self.source_y, epochs=100, learning_rate=0.01)
        print('源域模型训练完成')
        
        # 评估源域模型在目标域上的性能（迁移前）
        print('4. 评估源域模型在目标域上的性能（迁移前）...')
        source_on_target_acc, _ = self.source_model.evaluate(target_X_test, target_y_test)
        print(f'源域模型在目标域上的准确率（迁移前）: {source_on_target_acc:.2f}%')
        
        # 迁移学习：在目标域上微调模型
        print('5. 迁移学习：在目标域上微调模型...')
        self.target_model = NeuralNetwork(input_size=self.source_X.shape[1], hidden_size=50, output_size=2)
        # 复制源域模型的参数
        self.target_model.W1 = self.source_model.W1.copy()
        self.target_model.b1 = self.source_model.b1.copy()
        self.target_model.W2 = self.source_model.W2.copy()
        self.target_model.b2 = self.source_model.b2.copy()
        
        # 在目标域上微调
        self.target_model.train(target_X_train, target_y_train, epochs=50, learning_rate=0.005, verbose=True)
        print('目标域模型微调完成')
        
        # 评估迁移学习模型的性能
        print('6. 评估迁移学习模型的性能...')
        self.transfer_accuracy, transfer_cm = self.target_model.evaluate(target_X_test, target_y_test)
        print(f'迁移学习模型准确率: {self.transfer_accuracy:.2f}%')
        print('混淆矩阵:')
        print(transfer_cm)
        
        # 基线：在目标域上从头训练模型
        print('7. 基线：在目标域上从头训练模型...')
        self.baseline_model = NeuralNetwork(input_size=self.target_X.shape[1], hidden_size=50, output_size=2)
        self.baseline_model.train(target_X_train, target_y_train, epochs=100, learning_rate=0.01, verbose=True)
        print('基线模型训练完成')
        
        # 评估基线模型的性能
        print('8. 评估基线模型的性能...')
        self.baseline_accuracy, baseline_cm = self.baseline_model.evaluate(target_X_test, target_y_test)
        print(f'基线模型准确率: {self.baseline_accuracy:.2f}%')
        print('混淆矩阵:')
        print(baseline_cm)
        
        return self.transfer_accuracy, self.baseline_accuracy
    
    def generate_animation(self):
        """生成迁移学习系统运行动画"""
        images = []
        
        # 生成动画
        for i in range(0, len(self.target_X), len(self.target_X) // 10):
            plt.figure(figsize=(12, 6))
            
            # 绘制目标域信号
            plt.subplot(1, 2, 1)
            plt.plot(self.target_X[i])
            plt.title(f'目标域振动信号 (类别: {"正常" if self.target_y[i] == 0 else "损伤"})')
            plt.xlabel('时间')
            plt.ylabel('幅值')
            plt.grid(True)
            
            # 绘制源域信号（对比）
            plt.subplot(1, 2, 2)
            source_idx = i % len(self.source_X)
            plt.plot(self.source_X[source_idx])
            plt.title(f'源域振动信号 (类别: {"正常" if self.source_y[source_idx] == 0 else "损伤"})')
            plt.xlabel('时间')
            plt.ylabel('幅值')
            plt.grid(True)
            
            plt.tight_layout()
            
            # 保存为临时文件
            temp_file = f'temp_{i}.png'
            plt.savefig(temp_file)
            plt.close()
            
            # 读取图像
            images.append(imageio.imread(temp_file))
            
            # 删除临时文件
            os.remove(temp_file)
        
        # 生成动画
        imageio.mimsave('迁移学习系统运行动画.gif', images, fps=2)
        print('动画生成完成: 迁移学习系统运行动画.gif')
    
    def plot_results(self):
        """绘制结果"""
        # 绘制源域和目标域信号对比
        plt.figure(figsize=(12, 6))
        
        # 源域正常信号
        plt.subplot(2, 2, 1)
        source_normal_idx = np.where(self.source_y == 0)[0][0]
        plt.plot(self.source_X[source_normal_idx])
        plt.title('源域正常状态振动信号')
        plt.xlabel('时间')
        plt.ylabel('幅值')
        plt.grid(True)
        
        # 源域损伤信号
        plt.subplot(2, 2, 2)
        source_damage_idx = np.where(self.source_y == 1)[0][0]
        plt.plot(self.source_X[source_damage_idx])
        plt.title('源域损伤状态振动信号')
        plt.xlabel('时间')
        plt.ylabel('幅值')
        plt.grid(True)
        
        # 目标域正常信号
        plt.subplot(2, 2, 3)
        target_normal_idx = np.where(self.target_y == 0)[0][0]
        plt.plot(self.target_X[target_normal_idx])
        plt.title('目标域正常状态振动信号')
        plt.xlabel('时间')
        plt.ylabel('幅值')
        plt.grid(True)
        
        # 目标域损伤信号
        plt.subplot(2, 2, 4)
        target_damage_idx = np.where(self.target_y == 1)[0][0]
        plt.plot(self.target_X[target_damage_idx])
        plt.title('目标域损伤状态振动信号')
        plt.xlabel('时间')
        plt.ylabel('幅值')
        plt.grid(True)
        
        plt.tight_layout()
        plt.savefig('源域目标域信号对比.png')
        plt.close()
        
        # 绘制特征分布对比（使用PCA降维）
        pca = PCA(n_components=2)
        
        # 获取源域和目标域的特征
        source_features = self.source_model.get_features(self.source_X)
        target_features = self.source_model.get_features(self.target_X)
        
        # 合并特征进行PCA
        all_features = np.vstack([source_features, target_features])
        all_features_pca = pca.fit_transform(all_features)
        
        source_features_pca = all_features_pca[:len(source_features)]
        target_features_pca = all_features_pca[len(source_features):]
        
        plt.figure(figsize=(12, 5))
        
        # 源域特征分布
        plt.subplot(1, 2, 1)
        source_normal = source_features_pca[self.source_y == 0]
        source_damage = source_features_pca[self.source_y == 1]
        plt.scatter(source_normal[:, 0], source_normal[:, 1], label='正常', alpha=0.5)
        plt.scatter(source_damage[:, 0], source_damage[:, 1], label='损伤', alpha=0.5)
        plt.title('源域特征分布 (PCA降维)')
        plt.xlabel('主成分1')
        plt.ylabel('主成分2')
        plt.legend()
        plt.grid(True)
        
        # 目标域特征分布
        plt.subplot(1, 2, 2)
        target_normal = target_features_pca[self.target_y == 0]
        target_damage = target_features_pca[self.target_y == 1]
        plt.scatter(target_normal[:, 0], target_normal[:, 1], label='正常', alpha=0.5)
        plt.scatter(target_damage[:, 0], target_damage[:, 1], label='损伤', alpha=0.5)
        plt.title('目标域特征分布 (PCA降维)')
        plt.xlabel('主成分1')
        plt.ylabel('主成分2')
        plt.legend()
        plt.grid(True)
        
        plt.tight_layout()
        plt.savefig('特征分布对比.png')
        plt.close()
        
        # 绘制性能对比
        plt.figure(figsize=(8, 6))
        methods = ['迁移学习', '基线（从头训练）']
        accuracies = [self.transfer_accuracy, self.baseline_accuracy]
        colors = ['#2ecc71', '#e74c3c']
        
        bars = plt.bar(methods, accuracies, color=colors, alpha=0.7)
        plt.title('模型性能对比')
        plt.ylabel('准确率')
        plt.ylim(0, 1.1)
        
        # 在柱状图上添加数值
        for bar, acc in zip(bars, accuracies):
            height = bar.get_height()
            plt.text(bar.get_x() + bar.get_width()/2., height,
                    f'{acc:.2%}',
                    ha='center', va='bottom')
        
        plt.tight_layout()
        plt.savefig('性能对比.png')
        plt.close()

def main():
    """主函数"""
    print('结构健康监测中的迁移学习技术')
    print('=' * 60)
    
    # 初始化系统
    tl_system = TransferLearningSystem()
    
    # 运行仿真
    transfer_acc, baseline_acc = tl_system.run_simulation(source_samples=1000, target_samples=100)
    
    # 生成动画
    tl_system.generate_animation()
    
    # 绘制结果
    tl_system.plot_results()
    
    print(f'\n迁移学习模型准确率: {transfer_acc:.2f}%')
    print(f'基线模型准确率: {baseline_acc:.2f}%')
    print(f'性能提升: {(transfer_acc - baseline_acc) / baseline_acc * 100:.1f}%')
    print('\n' + '=' * 60)
    print('仿真完成！')

if __name__ == '__main__':
    main()