首页 > 其他分享 >人工智能学习记录--Auto ML

人工智能学习记录--Auto ML

时间:2024-11-08 10:18:38浏览次数:3  
标签:-- Auto 模型 kan metrics train ML test model

1.什么是AutoML?

AutoML(自动化机器学习)是一种技术方法,旨在将机器学习的流程自动化,包括特征工程、模型选择、超参数优化等步骤。它通过简化机器学习过程,使得非专业人员或数据科学团队能更快、更便捷地构建并优化机器学习模型,特别适合于模型快速部署和大规模应用。

2.AutoML的核心步骤

  1. 数据预处理:自动处理缺失值、编码分类变量、标准化数据等。
  2. 特征工程:自动创建和选择特征,以提高模型性能。
  3. 模型选择:通过自动化流程选择最适合数据的模型(如决策树、随机森林、XGBoost等)。
  4. 超参数优化:通过网格搜索、贝叶斯优化或进化算法等,自动调节超参数以提高模型效果。
  5. 模型评估与选择:根据不同模型的表现选择最佳模型,并基于验证集评估性能。
  6. 部署与监控:在模型上线后,自动化工具可以持续监控和更新模型。

AutoML执行过程:

3.AutoML的常见工具

  1. Auto-sklearn:基于scikit-learn的开源AutoML工具。
  2. TPOT:基于遗传算法的Python库,能自动搜索最佳模型与特征工程。
  3. H2O AutoML:支持多种算法、数据预处理,适用于大数据。
  4. Google Cloud AutoML:适合Google云平台用户,提供计算资源和自动化建模。
  5. Microsoft Azure AutoML:专为Azure用户设计的AutoML工具。
  6. FLAML:一个轻量级快速库,适合小型数据集和资源受限的环境。

4.AutoML工具分析

1. Auto-sklearn

Auto-sklearn 是一个基于 scikit-learn 的 AutoML 工具,主要用于分类和回归任务

优点

  • 开源免费:基于 Python 和 scikit-learn 构建,开源,适合自主研究和应用。
  • 集成丰富:包含丰富的scikit-learn模型库和特征工程预处理器。
  • 自动化模型组合:使用集成学习方法,通过模型加权组合获得更优结果。
  • 内置超参数优化:自动执行模型选择和超参数优化,使用贝叶斯优化加速搜索。

缺点

  • 资源消耗较高:复杂模型和大数据集下训练时间较长。
  • 模型支持有限:仅支持scikit-learn模型,不支持深度学习模型。

使用场景

  • 小规模数据集的分类或回归任务:适合科研应用、小规模数据建模或快速原型验证。

2. TPOT (Tree-based Pipeline Optimization Tool)

TPOT 是基于遗传算法的AutoML工具,能够自动优化和组合机器学习模型。

优点

  • 遗传算法搜索:使用遗传算法进行模型选择和特征工程,有助于发掘复杂的模型组合。
  • 可读性强:最终模型以Python代码形式导出,便于调试和理解。
  • 特征工程能力强:能自动化复杂的特征工程处理。

缺点

  • 训练时间长:遗传算法计算量较大,尤其是在大规模数据集上。
  • 较少模型支持:不支持深度学习模型,主要用于经典机器学习任务。

使用场景

  • 特征工程复杂的任务:适合需要大量特征转换的任务,例如文本或图像的基础特征提取。
  • 结构化数据的分类和回归任务:适用于结构化数据场景,例如金融、医疗、营销等领域。

3. H2O AutoML

H2O AutoML 是由 H2O.ai 开发的,支持大规模数据集的自动化机器学习平台,能处理分类、回归等任务。

优点

  • 丰富的模型支持:包含随机森林、GBM、XGBoost等多个集成学习模型。
  • 大数据支持:适合大规模数据,能很好地适应分布式和云计算环境。
  • 模型堆叠:支持自动化模型堆叠,通过多个模型的组合提高性能。

缺点

  • 较高的资源需求:在大规模数据集上运行时需要较多的计算资源。
  • 用户界面不如其他工具友好:相对来说需要较强的专业知识。

使用场景

  • 大规模数据的回归和分类任务:适合对大数据进行建模的场景,如电商推荐、金融预测、用户行为分析等。
  • 需要模型堆叠的场景:适合需要组合多个模型来提升预测性能的场景

4. Google Cloud AutoML

Google Cloud AutoML 是谷歌云平台的AutoML服务,支持图像、文本、表格等多种数据类型,提供了强大的计算资源。

优点

  • 云计算资源支持:适合需要高计算能力的用户,无需本地计算资源。
  • 多种数据类型支持:支持结构化数据、文本、图像等多种数据格式。
  • 深度学习支持:可以自动优化深度学习模型结构,适用于复杂任务。

缺点

  • 付费服务:Google Cloud AutoML 是付费的,适合预算充足的企业用户。
  • 数据隐私问题:数据需上传到云端,可能涉及数据隐私问题。

使用场景

  • 企业级自动化建模:适合预算充足的企业,特别是需要处理图像和自然语言处理任务。
  • 无本地计算资源:适合无大型计算资源的中小型团队。

5. Microsoft Azure AutoML

Azure AutoML 是微软提供的云端AutoML服务,支持多种机器学习任务,包括分类、回归、时间序列预测等。

优点

  • 集成微软生态:与Azure其他服务无缝集成,如Azure ML Studio和Azure Data Lake。
  • 时间序列预测支持:内置时间序列预测,适合时序数据的建模。
  • 自动化特征工程:内置丰富的特征工程模块,能快速提升模型效果。

缺点

  • 依赖Azure云平台:主要适用于Azure云用户,不适合离线使用。
  • 费用较高:和其他云服务类似,按计算资源收费。

使用场景

  • 时间序列数据建模:适合金融、物流等行业的时间序列预测任务。
  • 企业级自动化建模:适合已经在Azure生态中的企业用户。

6. FLAML (Fast Lightweight AutoML)

FLAML 是由微软开发的轻量级AutoML库,专注于快速构建和优化模型,特别适合小型数据集和资源受限的环境。

优点

  • 轻量化:计算资源需求低,适合资源受限的本地环境。
  • 支持多种任务:支持分类、回归、时间序列和多目标优化等任务。
  • 可调节的模型训练速度:可以通过限制搜索空间加速建模过程。

缺点

  • 模型选择较少:不支持深度学习模型,主要用于经典机器学习任务。
  • 性能略逊于大规模AutoML工具:在特定任务上可能不如H2O等性能表现。

使用场景

  • 资源受限环境:适合小型团队、科研项目或资源有限的环境。
  • 快速原型设计:适用于快速迭代和测试的场景,尤其是在处理小型数据集时。
7.实现一个原生Auto ML
import os
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, recall_score, precision_score, f1_score, confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import StandardScaler
from tensorflow.keras.layers import Dense
from tensorflow.keras.models import Sequential
from tensorflow.keras.utils import to_categorical
from torch.utils.data import DataLoader, TensorDataset
from xgboost import XGBClassifier


def load_data_from_folder(folder_path):
    """读取指定文件夹中的所有CSV文件并合并为一个DataFrame"""
    all_data = pd.DataFrame()
    for file_name in os.listdir(folder_path):
        if file_name.endswith('normalized.csv'):
            file_path = os.path.join(folder_path, file_name)
            data = pd.read_csv(file_path)
            all_data = pd.concat([all_data, data], ignore_index=True)
    return all_data


def split_data(data):
    """将数据分为特征和标签,并进行训练集和测试集的划分"""
    X = data.iloc[:, 1:]  # 所有特征列
    y = data.iloc[:, 0]  # 标签列
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    return X_train, X_test, y_train, y_test

def split_data_for_kan(data):
    """将数据分为特征和标签,并进行训练集和测试集的划分"""
    X = data.iloc[:, 1:].values  # 转换为 numpy 数组
    y = data.iloc[:, 0].values   # 转换为 numpy 数组
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    return X_train, X_test, y_train, y_test

def create_data_loaders_for_kan(X_train, y_train, X_test, y_test, batch_size=32):
    """创建数据加载器"""
    X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
    y_train_tensor = torch.tensor(y_train, dtype=torch.long)
    X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
    y_test_tensor = torch.tensor(y_test, dtype=torch.long)

    train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
    test_dataset = TensorDataset(X_test_tensor, y_test_tensor)

    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
    return train_loader, test_loader



def encode_labels(y_train, y_test):
    """对标签列进行编码,转换为数值类型"""
    label_encoder = LabelEncoder()
    y_train_encoded = label_encoder.fit_transform(y_train)
    y_test_encoded = label_encoder.transform(y_test)
    return y_train_encoded, y_test_encoded, label_encoder

def preprocess_data(X_train, X_test):
    """对特征进行标准化处理"""
    scaler = StandardScaler()
    X_train = scaler.fit_transform(X_train)
    X_test = scaler.transform(X_test)
    return X_train, X_test

def train_random_forest(X_train, y_train):
    """训练随机森林分类模型并返回训练好的模型"""
    model = RandomForestClassifier(random_state=42)
    model.fit(X_train, y_train)
    return model

def train_xgboost(X_train, y_train):
    """训练XGBoost分类模型并返回训练好的模型"""
    model = XGBClassifier(eval_metric='mlogloss', random_state=42)
    model.fit(X_train, y_train)
    return model

def train_ann_model(input_dim, output_dim):
    """构建并返回一个简单的ANN模型"""
    model = Sequential([
        Dense(64, activation='relu', input_dim=input_dim),
        Dense(32, activation='relu'),
        Dense(output_dim, activation='softmax')
    ])
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    return model

# 定义KAN模型
class KAN(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(KAN, self).__init__()
        self.hidden1 = nn.Linear(input_dim, 256)
        self.hidden2 = nn.Linear(256, 128)
        self.hidden3 = nn.Linear(128, 64)
        self.output = nn.Linear(64, output_dim)
        self.activation = nn.ReLU()

    def forward(self, x):
        x = self.activation(self.hidden1(x))
        x = self.activation(self.hidden2(x))
        x = self.activation(self.hidden3(x))
        x = self.output(x)
        return x

def train_kan_model(model, train_loader, criterion, optimizer, num_epochs=100):
    """训练模型"""
    for epoch in range(num_epochs):
        model.train()
        for X_batch, y_batch in train_loader:
            optimizer.zero_grad()
            outputs = model(X_batch)
            loss = criterion(outputs, y_batch)
            loss.backward()
            optimizer.step()

def evaluate_kan_model(model, X_train_tensor, X_test_tensor):
    """评估模型,返回训练集和测试集预测结果"""
    model.eval()
    with torch.no_grad():
        train_outputs = model(X_train_tensor)
        test_outputs = model(X_test_tensor)
        _, train_preds = torch.max(train_outputs, 1)
        _, test_preds = torch.max(test_outputs, 1)
    return train_preds, test_preds

def calculate_metrics(y_true, y_pred):
    """计算并返回模型的评估指标"""
    accuracy = accuracy_score(y_true, y_pred)
    recall = recall_score(y_true, y_pred, average='macro', zero_division=0)
    precision = precision_score(y_true, y_pred, average='macro', zero_division=0)
    f1 = f1_score(y_true, y_pred, average='macro', zero_division=0)

    # 处理多分类情况
    tn, fp, fn, tp = 0, 0, 0, 0
    if len(confusion_matrix(y_true, y_pred)) == 2:
        tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()

    # 计算漏报率和误报率
    cm = confusion_matrix(y_true, y_pred)
    miss_rate, false_alarm_rate = None, None

    if cm.shape == (2, 2):  # 针对二分类的情况
        tn, fp, fn, tp = cm.ravel()
        miss_rate = fn / (fn + tp) if (fn + tp) > 0 else 0
        false_alarm_rate = fp / (fp + tn) if (fp + tn) > 0 else 0
    else:  # 多分类情况
        miss_rate = sum(cm[i][j] for i in range(len(cm)) for j in range(len(cm)) if i != j) / cm.sum()
        false_alarm_rate = sum(cm[j][i] for i in range(len(cm)) for j in range(len(cm)) if i != j) / cm.sum()

    return {
        "Accuracy": accuracy,
        "Miss Rate": miss_rate,
        "False Alarm Rate": false_alarm_rate,
        "F1 Score": f1,
        "Recall": recall
    }


def save_metrics_to_csv(train_metrics, test_metrics, save_path):
    """将训练集和测试集的评估指标保存为CSV文件"""
    results_df = pd.DataFrame({
        "Metric": ["Accuracy", "Miss Rate", "False Alarm Rate", "F1 Score", "Recall"],
        "Training Set": [train_metrics["Accuracy"], train_metrics["Miss Rate"],
                         train_metrics["False Alarm Rate"], train_metrics["F1 Score"],
                         train_metrics["Recall"]],
        "Test Set": [test_metrics["Accuracy"], test_metrics["Miss Rate"],
                     test_metrics["False Alarm Rate"], test_metrics["F1 Score"],
                     test_metrics["Recall"]]
    })
    results_df.to_csv(save_path, index=False)
    print(f"评估结果已保存到: {save_path}")


def compare_models(folder_path, result_file_path):
    """对比多种模型性能,选择最优模型"""

    # 加载数据
    all_data = load_data_from_folder(folder_path)
    X_train, X_test, y_train, y_test = split_data(all_data)

    # 对标签进行编码
    y_train_encoded, y_test_encoded, label_encoder = encode_labels(y_train, y_test)

    # 存储各个模型的评估结果
    model_performance = {}

    # 1. 随机森林模型
    rf_model = train_random_forest(X_train, y_train_encoded)
    rf_train_pred = rf_model.predict(X_train)
    rf_test_pred = rf_model.predict(X_test)
    rf_train_metrics = calculate_metrics(y_train_encoded, rf_train_pred)
    rf_test_metrics = calculate_metrics(y_test_encoded, rf_test_pred)
    model_performance["RandomForest"] = (rf_train_metrics, rf_test_metrics)

    # 2. XGBoost模型
    xgb_model = train_xgboost(X_train, y_train_encoded)
    xgb_train_pred = xgb_model.predict(X_train)
    xgb_test_pred = xgb_model.predict(X_test)
    xgb_train_metrics = calculate_metrics(y_train_encoded, xgb_train_pred)
    xgb_test_metrics = calculate_metrics(y_test_encoded, xgb_test_pred)
    model_performance["XGBoost"] = (xgb_train_metrics, xgb_test_metrics)

    # 3. ANN模型
    X_train_preprocessed, X_test_preprocessed = preprocess_data(X_train, X_test)
    y_train_onehot = to_categorical(y_train_encoded)
    y_test_onehot = to_categorical(y_test_encoded)
    ann_model = train_ann_model(X_train_preprocessed.shape[1], y_train_onehot.shape[1])
    ann_model.fit(X_train_preprocessed, y_train_onehot, epochs=20, batch_size=32, verbose=1)
    ann_train_pred = np.argmax(ann_model.predict(X_train_preprocessed), axis=1)
    ann_test_pred = np.argmax(ann_model.predict(X_test_preprocessed), axis=1)
    ann_train_metrics = calculate_metrics(y_train_encoded, ann_train_pred)
    ann_test_metrics = calculate_metrics(y_test_encoded, ann_test_pred)
    model_performance["ANN"] = (ann_train_metrics, ann_test_metrics)

    # 4. KAN模型
    X_train_kan, X_test_kan, y_train_kan, y_test_kan = split_data_for_kan(all_data)
    y_train_kan_encoded, y_test_kan_encoded, label_encoder = encode_labels(y_train_kan, y_test_kan)
    train_loader, test_loader = create_data_loaders_for_kan(X_train_kan, y_train_kan_encoded, X_test_kan,
                                                            y_test_kan_encoded)
    input_dim = X_train_kan.shape[1]
    output_dim = len(np.unique(y_train_kan_encoded))
    kan_model = KAN(input_dim, output_dim)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(kan_model.parameters(), lr=0.001)
    train_kan_model(kan_model, train_loader, criterion, optimizer)
    X_train_tensor = torch.tensor(X_train_kan, dtype=torch.float32)
    X_test_tensor = torch.tensor(X_test_kan, dtype=torch.float32)
    kan_train_pred, kan_test_pred = evaluate_kan_model(kan_model, X_train_tensor, X_test_tensor)
    kan_train_metrics = calculate_metrics(y_train_kan_encoded, kan_train_pred.numpy())
    kan_test_metrics = calculate_metrics(y_test_kan_encoded, kan_test_pred.numpy())
    model_performance["KAN"] = (kan_train_metrics, kan_test_metrics)

    # 比较各个模型的测试集 `Accuracy`,选出性能最优的模型
    best_model_name = None
    best_accuracy = 0

    for model_name, (train_metrics, test_metrics) in model_performance.items():
        if test_metrics["Accuracy"] > best_accuracy:
            best_model_name = model_name
            best_accuracy = test_metrics["Accuracy"]

    # 输出最佳模型
    best_train_metrics, best_test_metrics = model_performance[best_model_name]
    print(f"最佳模型: {best_model_name}")
    print("训练集性能:", best_train_metrics)
    print("测试集性能:", best_test_metrics)

    # 保存最佳模型的评估指标
    save_metrics_to_csv(best_train_metrics, best_test_metrics, result_file_path)

    return best_model_name, best_train_metrics, best_test_metrics

标签:--,Auto,模型,kan,metrics,train,ML,test,model
From: https://blog.csdn.net/m0_69435612/article/details/143590906

相关文章

  • L1-013 计算阶乘和
    目录一、问题描述二、问题分析 三、源码解答四、参考资料一、问题描述对于给定的正整数N,需要你计算S=1!+2!+3!+...+N!。1.输入格式输入在一行中给出一个不超过10的正整数N。2.输出格式在一行中输出S的值。3.输入样例34.输出样例95.限制条件代码长......
  • L1-009 N个数求和
    目录一、问题描述二、问题分析 三、源码解答四、参考资料一、问题描述本题的要求很简单,就是求N个数字的和。麻烦的是,这些数字是以有理数分子/分母的形式给出的,你输出的和也必须是有理数的形式。1.输入格式输入第一行给出一个正整数N(≤100)。随后一行按格式a1/b1a2/b......
  • 队列详解
    目录队列队列的概念及结构队列的实现代码队列功能的实现队列的尾插voidQueuePush(Queue*pq,QDataTypex);结构体封装指针typedefstructQueue总结代码队列的头删voidQueuePop(Queue*pq)代码队列的初始化voidQueueInit(Queue*pq)代码队列的销毁voidQueueDest......
  • 速成黑客大佬?30天网络安全零基础自学宝典!新手必看
     很多人上来就说想学习黑客,但是连方向都没搞清楚就开始学习,最终也只是会无疾而终!黑客是一个大的概念,里面包含了许多方向,不同的方向需要学习的内容也不一样。网络安全学习路线&学习资源我给大家整理了一些网络安全的资料,大家不想一个一个去找的话,可以参考一下这些资料哈......
  • 基于YOLOv8模型的塑料瓶目标检测系统(PyTorch+Pyside6+YOLOv8模型)
    摘要:基于YOLOv8模型的塑料瓶目标检测系统可用于日常生活中检测与定位塑料瓶目标,利用深度学习算法可实现图片、视频、摄像头等方式的目标检测,另外本系统还支持图片、视频等格式的结果可视化与结果导出。本系统采用YOLOv8目标检测算法训练数据集,使用Pysdie6库来搭建前端页面展示......
  • L1-005 考试座位号
    目录一、问题描述二、问题分析 三、源码解答四、参考资料一、问题描述        每个PAT考生在参加考试时都会被分配两个座位号,一个是试机座位,一个是考试座位。正常情况下,考生在入场时先得到试机座位号码,入座进入试机状态后,系统会显示该考生的考试座位号码,考试......
  • 【全99集】强推!这可能是C站最全的大模型零基础全套教程,2024最新版,草履虫能都学会!存下
    ChatGPT的出现在全球掀起了AI大模型的浪潮,2023年可以被称为AI元年,AI大模型以一种野蛮的方式,闯入你我的生活之中。从问答对话到辅助编程,从图画解析到自主创作,AI所展现出来的能力,超出了多数人的预料,让不少人惊呼:“未来是属于AI的”。AI大模型——成为互联网从业者必备技能。......
  • YashanDB一键安装脚本分享
    前言前段时间,yashanDB发布了YashanDBPersonal23.3版本,立马准备安装试试,想着安装后续可能还会有其他版本,本着一劳永逸的想法,写了这个一键安装脚本。后续还有优化空间,这里简单分享记录下脚本安装过程。环境准备1.官网下载最新的个人版安装包:点击获取YashanDBPersonal......
  • Spring JPA集成YashanDB教程分享
    引言关于SpringJPASpringJPA(JavaPersistenceAPI)是JavaEE中关于持久化(即对象持久化到数据库)的标准规范,它为Java应用提供了一种与数据库交互的面向对象的方法。SpringDataJPA是Spring对JPA的实现,它极大地简化了数据持久化的操作。以下是SpringJPA的重要性和用途重......
  • 短链接使用攻略 - 数据统计
    客户对我的推广有兴趣吗?他喜欢我的产品吗?他打开了我的营销信息吗?这三个问题相信每一位推广者都遇到过。下面给大家介绍短链接的使用攻略「数据统计」——它能帮你监测每一位用户的行为,让你分分钟掌握用户的心理!具体使用方法:第一步:在C1N短网址首页(c1n.cn),输入您需要推广的......