基于TSK模糊规则的分类模型Python实现

本代码实现了一个基于TSK模糊规则的分类模型，并包含数据加载、预处理、模型训练和评估等步骤。

代码解析

import argparse
import os
import scipy.io as sp
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from lib.inits import *
from lib.models import *
from lib.tuning_train import *

# 设置随机种子以保证结果可复现
np.random.seed(1447)
t.manual_seed(1447)

# 定义命令行参数解析函数
def get_parser():
    # 使用argparse库创建参数解析器
    parser = argparse.ArgumentParser()

    # 定义是否使用GPU的参数，默认使用GPU
    flag_parser = parser.add_mutually_exclusive_group(required=False)
    flag_parser.add_argument('--gpu', dest='gpu', action='store_true')
    flag_parser.add_argument('--cpu', dest='gpu', action='store_false')
    parser.set_defaults(gpu=True)

    # 定义是否使用Batch Normalization的参数，默认使用
    flag_parser = parser.add_mutually_exclusive_group(required=False)
    flag_parser.add_argument('--bn', dest='bn', action='store_true')
    flag_parser.add_argument('--no_bn', dest='bn', action='store_false')
    parser.set_defaults(bn=True)

    # 定义训练参数
    parser.add_argument('--batch_size', default=64, type=int, help='批次大小')
    parser.add_argument('--epochs', default=1000, type=int, help='总训练轮数')
    parser.add_argument('--patience', default=40, type=int, help='早停的耐心轮数')
    parser.add_argument('--data', default='Abalone', type=str, help='数据集名称')
    parser.add_argument('--n_rules', default=20, type=int, help='TSK模糊规则数量')
    parser.add_argument('--loss_type', default='crossentropy', type=str, help='损失函数类型')
    parser.add_argument('--optim_type', default='adabound', type=str, help='优化器类型')
    parser.add_argument('--weight_decay', default=0.05, type=float, help='L2正则化权重')
    parser.add_argument('--lr', default=1e-2, type=float, help='学习率')

    # 定义正则化权重
    parser.add_argument('--weight_frs', default=0, type=float, help='UR损失函数权重')

    # 定义TSK规则中心初始化方法
    parser.add_argument('--init', default='kmean', type=str, help='TSK规则中心初始化方法')
    
    # 定义是否进行参数调整
    parser.add_argument('--tune_param', default=1, type=int, help='是否进行参数调整')
    
    # 定义重复实验次数
    parser.add_argument('--repeats', default=1, type=int, help='重复实验次数')

    # 返回解析后的参数
    return parser.parse_args()

# 创建参数解析器并解析命令行参数
parser = argparse.ArgumentParser()
args = get_parser()

# 定义数据根目录
data_root = 'data/'

# 定义模型训练和评估函数
def run(flag, tail):
    # 设置标志
    args.flag = flag

    # 定义模型保存路径
    save_path = 'diff_split/ckpt/{}_{}_{}.pkl'.format(args.data, flag, tail)

    # 加载数据
    f = np.load(os.path.join(data_root, args.data + '.npz'))
    if flag == 0:
        print('Loading {} data, saving to {}'.format(args.data, save_path))
    data = f['con_data'].astype('float')
    label = f['label']
    n_classes = len(np.unique(label))
    train_idx, test_idx = f['trains'][flag], f['tests'][flag]

    # 划分训练集和测试集
    x_train, y_train = data[train_idx], label[train_idx]
    x_test, y_test = data[test_idx], label[test_idx]

    # 数据标准化
    ss = StandardScaler()
    x_train = ss.fit_transform(x_train)
    x_test = ss.transform(x_test)

    # 设置TSK模糊规则数量
    n_rules = args.n_rules

    # 根据选择的初始化方法初始化TSK规则中心
    if args.init == 'rpi':
        Cs, Vs = RPI(x_train, n_rules)
    elif args.init == 'kmean':
        Cs, Vs = kmean_init(x_train, n_rules)
    elif args.init == 'fcm':
        Cs, Vs = fcm_init(x_train, n_rules)
    else:
        exit()

    # 创建TSK分类模型
    model = ClsTSK(x_train.shape[1], n_rules, n_classes, init_centers=Cs, init_Vs=Vs, bn=args.bn)

    # 创建模型训练器
    Train = ClassModelTrain(
        model=model, train_data=(x_train, y_train),
        test_data=(x_test, y_test), n_classes=n_classes,
        args=args, save_path=save_path, optim_type=args.optim_type
    )

    # 训练模型并获取最佳准确率和BCA
    best_test_bca, best_test_acc = Train.train()

    # 打印结果
    print('[FLAG {:2d}] ACC: {:.4f}, BCA: {:.4f}'.format(flag, best_test_acc, best_test_bca))

    # 返回最佳准确率和BCA
    return best_test_acc, best_test_bca

# 主函数
if __name__ == '__main__':
    # 设置重复实验次数
    n_repeats = 30

    # 初始化结果列表
    hist = [1] * n_repeats
    best_acc = [0] * n_repeats
    best_bca = [0] * n_repeats

    # 设置结果文件名后缀
    tail = args.loss_type
    if args.weight_frs > 0:
        tail += '_ur'
    if not args.bn:
        tail += '_noBN'
    if args.init != 'kmean':
        tail += '_{}'.format(args.init)

    # 定义结果保存路径
    save_path = 'diff_split/res/{}_{}.mat'.format(args.data, tail)

    # 如果结果文件已存在，则退出程序
    if os.path.exists(save_path):
        print('{} Exists.'.format(save_path))
        exit()

    # 打印结果保存路径
    print('saving to {}'.format(save_path))

    # 循环进行多次实验
    for i in range(n_repeats):
        # 训练模型并获取最佳准确率和BCA
        best_acc[i], best_bca[i] = run(i, tail)

    # 打印平均准确率和BCA
    print(save_path, np.mean(best_acc), np.mean(best_bca))

    # 将结果保存到MAT文件
    sp.savemat(save_path, {'best_acc': best_acc, 'best_bca': best_bca})

代码功能

该代码实现了一个基于TSK模糊规则的分类模型，主要功能如下：

数据加载和预处理: 加载指定数据集，进行数据标准化处理。
模型定义: 定义TSK分类模型，包括输入层、模糊规则层、推理层和输出层。
模型训练: 使用训练数据对模型进行训练，并根据指定的参数进行优化。
模型评估: 使用测试数据对训练好的模型进行评估，计算准确率和BCA等指标。
结果保存: 将实验结果保存到文件中，方便后续分析和比较。

参数说明

以下是代码中一些重要参数的说明：

data: 数据集名称
n_rules: TSK模糊规则数量
loss_type: 损失函数类型
optim_type: 优化器类型
weight_decay: L2正则化权重
lr: 学习率
init: TSK规则中心初始化方法

用户可以通过修改这些参数来调整模型的结构和训练过程。