Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-opus-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

Chandler1748590363387…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with DeepSeekdeepseek-v3-0324’s answer.
  1. User

    Chandler_1748590363387 python:使用智能算法,实现多种通信信号的自适应识别,直观展示出各种信号的识别正确率。数据集已存储在本地,为RML2016.10a_dict.pkl 要求准确率高,至少0.9。添加完整的时间统计,显示总运行时间。三种可视化图表:信噪比准确率曲线、调制类型准确率对比、训练历史

  2. Claude Assistant

    我来帮您实现一个高准确率的通信信号自适应识别系统。这个系统将使用深度学习方法处理RML2016.10a数据集。

    import numpy as np
    import pickle
    import matplotlib.pyplot as plt
    import seaborn as sns
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import LabelEncoder
    from tensorflow.keras.models import Sequential, Model
    from tensorflow.keras.layers import Dense, Dropout, Conv1D, MaxPooling1D, Flatten, BatchNormalization
    from tensorflow.keras.layers import LSTM, GRU, Input, concatenate
    from tensorflow.keras.optimizers import Adam
    from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
    from tensorflow.keras.utils import to_categorical
    import time
    from datetime import datetime
    import warnings
    warnings.filterwarnings('ignore')
    
    # 记录开始时间
    start_time = time.time()
    print(f"程序开始运行时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    
    # 1. 加载数据集
    print("\n正在加载数据集...")
    data_load_start = time.time()
    
    with open('RML2016.10a_dict.pkl', 'rb') as f:
        Xd = pickle.load(f, encoding='latin1')
    
    print(f"数据加载完成,用时: {time.time() - data_load_start:.2f}秒")
    
    # 2. 数据预处理
    print("\n开始数据预处理...")
    preprocess_start = time.time()
    
    # 提取信噪比和调制类型
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X = []  
    lbl = []
    
    for mod in mods:
        for snr in snrs:
            X.append(Xd[(mod, snr)])
            for i in range(Xd[(mod, snr)].shape[0]):
                lbl.append((mod, snr))
    
    X = np.vstack(X)
    
    # 数据标准化
    print("数据形状:", X.shape)
    print("调制类型:", mods)
    print("信噪比范围:", snrs)
    
    # 创建标签编码器
    le = LabelEncoder()
    labels = [item[0] for item in lbl]
    labels_encoded = le.fit_transform(labels)
    labels_onehot = to_categorical(labels_encoded)
    
    # 获取信噪比标签
    snr_labels = np.array([item[1] for item in lbl])
    
    print(f"数据预处理完成,用时: {time.time() - preprocess_start:.2f}秒")
    
    # 3. 划分训练集和测试集
    print("\n划分数据集...")
    split_start = time.time()
    
    X_train, X_test, y_train, y_test, snr_train, snr_test = train_test_split(
        X, labels_onehot, snr_labels, test_size=0.2, random_state=42, stratify=labels_encoded
    )
    
    # 数据形状调整为 (samples, timesteps, features)
    X_train = X_train.transpose((0, 2, 1))
    X_test = X_test.transpose((0, 2, 1))
    
    print(f"训练集形状: {X_train.shape}")
    print(f"测试集形状: {X_test.shape}")
    print(f"数据划分完成,用时: {time.time() - split_start:.2f}秒")
    
    # 4. 构建高性能混合深度学习模型
    print("\n构建深度学习模型...")
    model_build_start = time.time()
    
    def build_advanced_model(input_shape, num_classes):
        """构建高性能的混合深度学习模型"""
        inputs = Input(shape=input_shape)
        
        # CNN分支
        cnn = Conv1D(128, 8, padding='same', activation='relu')(inputs)
        cnn = BatchNormalization()(cnn)
        cnn = Conv1D(128, 8, padding='same', activation='relu')(cnn)
        cnn = BatchNormalization()(cnn)
        cnn = MaxPooling1D(2)(cnn)
        cnn = Dropout(0.2)(cnn)
        
        cnn = Conv1D(64, 4, padding='same', activation='relu')(cnn)
        cnn = BatchNormalization()(cnn)
        cnn = Conv1D(64, 4, padding='same', activation='relu')(cnn)
        cnn = BatchNormalization()(cnn)
        cnn = MaxPooling1D(2)(cnn)
        cnn = Dropout(0.2)(cnn)
        
        cnn = Conv1D(32, 2, padding='same', activation='relu')(cnn)
        cnn = BatchNormalization()(cnn)
        cnn_flat = Flatten()(cnn)
        
        # LSTM分支
        lstm = LSTM(128, return_sequences=True)(inputs)
        lstm = BatchNormalization()(lstm)
        lstm = LSTM(64, return_sequences=False)(lstm)
        lstm = BatchNormalization()(lstm)
        lstm = Dropout(0.2)(lstm)
        
        # 合并两个分支
        merged = concatenate([cnn_flat, lstm])
        
        # 全连接层
        dense = Dense(256, activation='relu')(merged)
        dense = BatchNormalization()(dense)
        dense = Dropout(0.3)(dense)
        
        dense = Dense(128, activation='relu')(dense)
        dense = BatchNormalization()(dense)
        dense = Dropout(0.3)(dense)
        
        outputs = Dense(num_classes, activation='softmax')(dense)
        
        model = Model(inputs=inputs, outputs=outputs)
        return model
    
    # 创建模型
    model = build_advanced_model((X_train.shape[1], X_train.shape[2]), len(mods))
    
    # 编译模型
    model.compile(
        optimizer=Adam(learning_rate=0.001),
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    
    print(f"模型构建完成,用时: {time.time() - model_build_start:.2f}秒")
    print("\n模型结构摘要:")
    model.summary()
    
    # 5. 训练模型
    print("\n开始训练模型...")
    training_start = time.time()
    
    # 设置回调函数
    early_stopping = EarlyStopping(monitor='val_accuracy', patience=10, restore_best_weights=True)
    reduce_lr = ReduceLROnPlateau(monitor='val_accuracy', factor=0.5, patience=5, min_lr=0.00001)
    
    # 训练模型
    history = model.fit(
        X_train, y_train,
        batch_size=512,
        epochs=100,
        validation_split=0.2,
        callbacks=[early_stopping, reduce_lr],
        verbose=1
    )
    
    print(f"\n模型训练完成,用时: {time.time() - training_start:.2f}秒")
    
    # 6. 评估模型
    print("\n评估模型性能...")
    eval_start = time.time()
    
    # 整体准确率
    test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)
    print(f"测试集整体准确率: {test_accuracy:.4f}")
    
    # 预测
    y_pred = model.predict(X_test, verbose=0)
    y_pred_classes = np.argmax(y_pred, axis=1)
    y_true_classes = np.argmax(y_test, axis=1)
    
    print(f"模型评估完成,用时: {time.time() - eval_start:.2f}秒")
    
    # 7. 计算不同信噪比下的准确率
    print("\n计算不同信噪比下的准确率...")
    snr_calc_start = time.time()
    
    snr_accuracies = {}
    for snr in snrs:
        mask = snr_test == snr
        if np.sum(mask) > 0:
            acc = np.mean(y_pred_classes[mask] == y_true_classes[mask])
            snr_accuracies[snr] = acc
            print(f"SNR {snr}dB: {acc:.4f}")
    
    print(f"信噪比准确率计算完成,用时: {time.time() - snr_calc_start:.2f}秒")
    
    # 8. 计算每种调制类型的准确率
    print("\n计算每种调制类型的准确率...")
    mod_calc_start = time.time()
    
    mod_accuracies = {}
    for i, mod in enumerate(mods):
        mask = y_true_classes == i
        if np.sum(mask) > 0:
            acc = np.mean(y_pred_classes[mask] == i)
            mod_accuracies[mod] = acc
            print(f"{mod}: {acc:.4f}")
    
    print(f"调制类型准确率计算完成,用时: {time.time() - mod_calc_start:.2f}秒")
    
    # 9. 可视化结果
    print("\n生成可视化图表...")
    viz_start = time.time()
    
    plt.style.use('seaborn-v0_8-darkgrid')
    fig = plt.figure(figsize=(18, 5))
    
    # 图1: 信噪比-准确率曲线
    plt.subplot(1, 3, 1)
    snr_list = sorted(snr_accuracies.keys())
    acc_list = [snr_accuracies[snr] for snr in snr_list]
    plt.plot(snr_list, acc_list, 'b-o', linewidth=2, markersize=8)
    plt.xlabel('信噪比 (dB)', fontsize=12)
    plt.ylabel('识别准确率', fontsize=12)
    plt.title('不同信噪比下的识别准确率', fontsize=14, fontweight='bold')
    plt.grid(True, alpha=0.3)
    plt.ylim(0, 1.05)
    # 添加0.9准确率参考线
    plt.axhline(y=0.9, color='r', linestyle='--', alpha=0.7, label='目标准确率 (0.9)')
    plt.legend()
    
    # 图2: 调制类型准确率对比
    plt.subplot(1, 3, 2)
    mod_names = list(mod_accuracies.keys())
    mod_accs = list(mod_accuracies.values())
    colors = plt.cm.viridis(np.linspace(0, 1, len(mod_names)))
    bars = plt.bar(range(len(mod_names)), mod_accs, color=colors)
    plt.xlabel('调制类型', fontsize=12)
    plt.ylabel('识别准确率', fontsize=12)
    plt.title('各调制类型的识别准确率', fontsize=14, fontweight='bold')
    plt.xticks(range(len(mod_names)), mod_names, rotation=45, ha='right')
    plt.ylim(0, 1.05)
    plt.axhline(y=0.9, color='r', linestyle='--', alpha=0.7, label='目标准确率 (0.9)')
    plt.legend()
    # 在柱状图上添加数值
    for bar, acc in zip(bars, mod_accs):
        plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01, 
                 f'{acc:.3f}', ha='center', va='bottom', fontsize=9)
    
    # 图3: 训练历史
    plt.subplot(1, 3, 3)
    plt.plot(history.history['accuracy'], label='训练准确率', linewidth=2)
    plt.plot(history.history['val_accuracy'], label='验证准确率', linewidth=2)
    plt.xlabel('训练轮次', fontsize=12)
    plt.ylabel('准确率', fontsize=12)
    plt.title('训练过程准确率变化', fontsize=14, fontweight='bold')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig('signal_recognition_results.png', dpi=300, bbox_inches='tight')
    plt.show()
    
    print(f"可视化完成,用时: {time.time() - viz_start:.2f}秒")
    
    # 10. 生成混淆矩阵热力图
    print("\n生成混淆矩阵...")
    confusion_start = time.time()
    
    from sklearn.metrics import confusion_matrix
    
    cm = confusion_matrix(y_true_classes, y_pred_classes)
    plt.figure(figsize=(12, 10))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
                xticklabels=mods, yticklabels=mods)
    plt.xlabel('预测类别', fontsize=12)
    plt.ylabel('真实类别', fontsize=12)
    plt.title('调制信号识别混淆矩阵', fontsize=14, fontweight='bold')
    plt.tight_layout()
    plt.savefig('confusion_matrix.png', dpi=300, bbox_inches='tight')
    plt.show()
    
    print(f"混淆矩阵生成完成,用时: {time.time() - confusion_start:.2f}秒")
    
    # 11. 总结统计
    total_time = time.time() - start_time
    print("\n" + "="*50)
    print("程序运行总结")
    print("="*50)
    print(f"程序结束时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"总运行时间: {total_time:.2f}秒 ({total_time/60:.2f}分钟)")
    print(f"\n各阶段用时:")
    print(f"  - 数据加载: {time.time() - data_load_start:.2f}秒")
    print(f"  - 数据预处理: {time.time() - preprocess_start:.2f}秒")
    print(f"  - 模型构建: {time.time() - model_build_start:.2f}秒")
    print(f"  - 模型训练: {time.time() - training_start:.2f}秒")
    print(f"  - 模型评估: {time.time() - eval_start:.2f}秒")
    print(f"\n性能指标:")
    print(f"  - 测试集整体准确率: {test_accuracy:.4f}")
    print(f"  - 高信噪比(≥10dB)平均准确率: {np.mean([acc for snr, acc in snr_accuracies.items() if snr >= 10]):.4f}")
    print(f"  - 达到0.9准确率的信噪比数量: {sum(1 for acc in snr_accuracies.values() if acc >= 0.9)}/{len(snr_accuracies)}")
    

    这个实现具有以下特点:

    1. 高准确率设计:
      • 使用CNN-LSTM混合架构,结合了CNN的特征提取能力和LSTM的时序建模能力
      • 添加了BatchNormalization层提高训练稳定性
      • 使用Dropout防止过

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.