AI 工具链：Gradio 演示界面

AI 工具链：Gradio 演示界面 | 极客日志

维度	说明	重要程度
理论基础	数学原理与算法推导	⭐⭐⭐⭐⭐
代码实现	Python 库的使用与编程	⭐⭐⭐⭐⭐
实践应用	解决实际问题的能力	⭐⭐⭐⭐
优化调参	提升模型性能的技巧	⭐⭐⭐⭐

""" AI 模型基础类 - 基础实现示例 """
import numpy as np
from typing import List, Dict, Optional, Tuple
import warnings
warnings.filterwarnings('ignore')

class CoreAIModel:
    """ AI 模型基础类
    这是一个展示 AI 工具链核心概念的示例类，
    包含了数据处理、模型训练、预测评估的完整流程。
    """
    def __init__(self, learning_rate: float = 0.01, epochs: int = 100, batch_size: int = 32):
        """ 初始化模型
        Args:
            learning_rate: 学习率
            epochs: 训练轮数
            batch_size: 批量大小
        """
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.batch_size = batch_size
        self.weights = None
        self.bias = None
        self.loss_history = []

    def _initialize_parameters(self, n_features: int):
        """初始化模型参数"""
        np.random.seed(42)
        self.weights = np.random.randn(n_features) * 0.01
        self.bias = 0

    def _forward(self, X: np.ndarray) -> np.ndarray:
        """前向传播"""
        return np.dot(X, self.weights) + self.bias

    def _compute_loss(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:
        """计算损失函数（均方误差）"""
        return np.mean((y_true - y_pred)**2)

    def _backward(self, X: np.ndarray, y_true: np.ndarray, y_pred: np.ndarray):
        """反向传播计算梯度"""
        m = len(y_true)
        dw = -2/m * np.dot(X.T, (y_true - y_pred))
        db = -2/m * np.sum(y_true - y_pred)
        return dw, db

    def fit(self, X: np.ndarray, y: np.ndarray) -> 'CoreAIModel':
        """ 训练模型
        Args:
            X: 特征矩阵
            y: 目标变量
        Returns:
            self: 训练后的模型实例
        """
        n_samples, n_features = X.shape
        self._initialize_parameters(n_features)
        for epoch in range(self.epochs):
            indices = np.random.permutation(n_samples)
            X_shuffled = X[indices]
            y_shuffled = y[indices]
            for i in range(0, n_samples, self.batch_size):
                X_batch = X_shuffled[i:i+self.batch_size]
                y_batch = y_shuffled[i:i+self.batch_size]
                y_pred = self._forward(X_batch)
                loss = self._compute_loss(y_batch, y_pred)
                dw, db = self._backward(X_batch, y_batch, y_pred)
                self.weights -= self.learning_rate * dw
                self.bias -= self.learning_rate * db
                if (epoch + 1) % 10 == 0:
                    y_pred_full = self._forward(X)
                    loss = self._compute_loss(y, y_pred_full)
                    self.loss_history.append(loss)
                    print(f"Epoch {epoch+1}/{self.epochs}, Loss: {loss:.4f}")
        return self

    def predict(self, X: np.ndarray) -> np.ndarray:
        """ 预测
        Args:
            X: 特征矩阵
        Returns:
            预测结果
        """
        return self._forward(X)

    def score(self, X: np.ndarray, y: np.ndarray) -> float:
        """ 计算 R²分数
        Args:
            X: 特征矩阵
            y: 真实值
        Returns:
            R²分数
        """
        y_pred = self.predict(X)
        ss_res = np.sum((y - y_pred)**2)
        ss_tot = np.sum((y - np.mean(y))**2)
        return 1 - (ss_res / ss_tot)

if __name__ == "__main__":
    np.random.seed(42)
    X = np.random.randn(1000, 5)
    true_weights = np.array([1.5, -2.0, 0.5, 1.0, -0.5])
    y = np.dot(X, true_weights) + np.random.randn(1000) * 0.1
    split = int(0.8 * len(X))
    X_train, X_test = X[:split], X[split:]
    y_train, y_test = y[:split], y[split:]
    model = CoreAIModel(learning_rate=0.01, epochs=100, batch_size=32)
    model.fit(X_train, y_train)
    train_score = model.score(X_train, y_train)
    test_score = model.score(X_test, y_test)
    print(f"\n训练集 R²: {train_score:.4f}")
    print(f"测试集 R²: {test_score:.4f}")

""" AI 模型进阶实现示例 - TensorFlow/PyTorch"""
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import torch
import torch.nn as nn
import torch.optim as optim

# TensorFlow 实现
class TensorFlowModel:
    """ TensorFlow 版本的模型实现"""
    def __init__(self, input_dim: int, hidden_units: List[int] = [64, 32]):
        self.model = self._build_model(input_dim, hidden_units)

    def _build_model(self, input_dim: int, hidden_units: List[int]) -> keras.Model:
        inputs = keras.Input(shape=(input_dim,))
        x = inputs
        for units in hidden_units:
            x = layers.Dense(units, activation='relu')(x)
            x = layers.BatchNormalization()(x)
            x = layers.Dropout(0.2)(x)
        outputs = layers.Dense(1)(x)
        model = keras.Model(inputs=inputs, outputs=outputs)
        model.compile(
            optimizer=keras.optimizers.Adam(learning_rate=0.001),
            loss='mse',
            metrics=['mae'])
        return model

    def train(self, X_train, y_train, X_val, y_val, epochs=100, batch_size=32):
        history = self.model.fit(
            X_train, y_train, validation_data=(X_val, y_val),
            epochs=epochs, batch_size=batch_size, verbose=1)
        return history

    def predict(self, X):
        return self.model.predict(X)

# PyTorch 实现
class PyTorchModel(nn.Module):
    """ PyTorch 版本的模型实现"""
    def __init__(self, input_dim: int, hidden_units: List[int] = [64, 32]):
        super(PyTorchModel, self).__init__()
        layers_list = []
        prev_units = input_dim
        for units in hidden_units:
            layers_list.append(nn.Linear(prev_units, units))
            layers_list.append(nn.ReLU())
            layers_list.append(nn.BatchNorm1d(units))
            layers_list.append(nn.Dropout(0.2))
            prev_units = units
        layers_list.append(nn.Linear(prev_units, 1))
        self.network = nn.Sequential(*layers_list)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """前向传播"""
        return self.network(x)

    def train_model(self, train_loader, val_loader, epochs=100, lr=0.001):
        criterion = nn.MSELoss()
        optimizer = optim.Adam(self.parameters(), lr=lr)
        train_losses = []
        val_losses = []
        for epoch in range(epochs):
            self.train()
            train_loss = 0.0
            for X_batch, y_batch in train_loader:
                optimizer.zero_grad()
                outputs = self(X_batch)
                loss = criterion(outputs, y_batch)
                loss.backward()
                optimizer.step()
                train_loss += loss.item()
            self.eval()
            val_loss = 0.0
            with torch.no_grad():
                for X_batch, y_batch in val_loader:
                    outputs = self(X_batch)
                    loss = criterion(outputs, y_batch)
                    val_loss += loss.item()
            train_losses.append(train_loss / len(train_loader))
            val_losses.append(val_loss / len(val_loader))
            if (epoch + 1) % 10 == 0:
                print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_losses[-1]:.4f}, Val Loss: {val_losses[-1]:.4f}")
        return train_losses, val_losses

if __name__ == "__main__":
    print("=== TensorFlow 实现 ===")
    tf_model = TensorFlowModel(input_dim=5)
    print("\n=== PyTorch 实现 ===")
    torch_model = PyTorchModel(input_dim=5)
    print(torch_model)

""" 数据处理完整流程 """
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.impute import SimpleImputer
from typing import List, Tuple

class DataProcessor:
    """数据处理类"""
    def __init__(self):
        self.scaler = StandardScaler()
        self.label_encoders = {}
        self.imputer = SimpleImputer(strategy='mean')

    def process(self, data: pd.DataFrame, target_col: str, categorical_cols: List[str] = None, test_size: float = 0.2) -> Tuple:
        """ 完整的数据处理流程
        Args:
            data: 原始数据
            target_col: 目标列名
            categorical_cols: 类别列名列表
            test_size: 测试集比例
        Returns:
            处理后的训练集和测试集
        """
        X = data.drop(columns=[target_col])
        y = data[target_col]
        X = pd.DataFrame(
            self.imputer.fit_transform(X.select_dtypes(include=[np.number])),
            columns=X.select_dtypes(include=[np.number]).columns)
        if categorical_cols:
            for col in categorical_cols:
                if col in X.columns:
                    le = LabelEncoder()
                    X[col] = le.fit_transform(X[col].astype(str))
                    self.label_encoders[col] = le
        X_scaled = self.scaler.fit_transform(X)
        X_train, X_test, y_train, y_test = train_test_split(
            X_scaled, y, test_size=test_size, random_state=42)
        return X_train, X_test, y_train, y_test

if __name__ == "__main__":
    data = pd.DataFrame({
        'feature1': np.random.randn(1000),
        'feature2': np.random.randn(1000),
        'feature3': np.random.choice(['A', 'B', 'C'], 1000),
        'target': np.random.randn(1000)
    })
    processor = DataProcessor()
    X_train, X_test, y_train, y_test = processor.process(
        data, target_col='target', categorical_cols=['feature3'])
    print(f"训练集形状：{X_train.shape}")
    print(f"测试集形状：{X_test.shape}")

""" 模型评估工具 """
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score,
    f1_score, roc_auc_score, confusion_matrix,
    classification_report, mean_squared_error,
    mean_absolute_error, r2_score
)
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

class ModelEvaluator:
    """模型评估类"""
    @staticmethod
    def evaluate_classification(y_true, y_pred, y_prob=None):
        """评估分类模型"""
        metrics = {
            'accuracy': accuracy_score(y_true, y_pred),
            'precision': precision_score(y_true, y_pred, average='weighted'),
            'recall': recall_score(y_true, y_pred, average='weighted'),
            'f1': f1_score(y_true, y_pred, average='weighted')
        }
        if y_prob is not None:
            metrics['roc_auc'] = roc_auc_score(y_true, y_prob, multi_class='ovr')
        return metrics

    @staticmethod
    def evaluate_regression(y_true, y_pred):
        """评估回归模型"""
        return {
            'mse': mean_squared_error(y_true, y_pred),
            'rmse': np.sqrt(mean_squared_error(y_true, y_pred)),
            'mae': mean_absolute_error(y_true, y_pred),
            'r2': r2_score(y_true, y_pred)
        }

    @staticmethod
    def plot_confusion_matrix(y_true, y_pred, labels=None):
        """绘制混淆矩阵"""
        cm = confusion_matrix(y_true, y_pred)
        plt.figure(figsize=(8, 6))
        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)
        plt.title('混淆矩阵')
        plt.xlabel('预测值')
        plt.ylabel('真实值')
        plt.show()

    @staticmethod
    def plot_learning_curve(train_losses, val_losses):
        """绘制学习曲线"""
        plt.figure(figsize=(10, 6))
        plt.plot(train_losses, label='训练损失')
        plt.plot(val_losses, label='验证损失')
        plt.xlabel('Epoch')
        plt.ylabel('Loss')
        plt.title('学习曲线')
        plt.legend()
        plt.grid(True)
        plt.show()

if __name__ == "__main__":
    y_true_cls = [0, 1, 0, 1, 0, 1, 0, 0, 1, 1]
    y_pred_cls = [0, 1, 0, 0, 0, 1, 1, 0, 1, 1]
    cls_metrics = ModelEvaluator.evaluate_classification(y_true_cls, y_pred_cls)
    print("分类指标:", cls_metrics)
    y_true_reg = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
    y_pred_reg = np.array([1.1, 1.9, 3.2, 3.8, 5.1])
    reg_metrics = ModelEvaluator.evaluate_regression(y_true_reg, y_pred_reg)
    print("回归指标:", reg_metrics)

# 数据分析完整流程示例
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

def analyze_dataset(data_path: str):
    """完整的数据分析流程"""
    data = pd.read_csv(data_path)
    print("数据形状:", data.shape)
    print("\n数据概览:")
    print(data.head())
    print("\n数据类型:")
    print(data.dtypes)
    print("\n缺失值统计:")
    print(data.isnull().sum())
    print("\n描述性统计:")
    print(data.describe())
    numeric_cols = data.select_dtypes(include=[np.number]).columns
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    for i, col in enumerate(numeric_cols[:4]):
        ax = axes[i//2, i%2]
        data[col].hist(ax=ax, bins=30, edgecolor='black')
        ax.set_title(f'{col}分布')
        ax.set_xlabel(col)
        ax.set_ylabel('频数')
    plt.tight_layout()
    plt.show()
    plt.figure(figsize=(10, 8))
    correlation = data[numeric_cols].corr()
    sns.heatmap(correlation, annot=True, cmap='coolwarm', center=0)
    plt.title('特征相关性热力图')
    plt.show()
    return data

应用领域	具体用途	推荐算法
分类问题	预测离散标签	随机森林、XGBoost
回归问题	预测连续值	线性回归、神经网络
聚类问题	数据分组	K-Means、DBSCAN
降维问题	特征压缩	PCA、t-SNE

# 创建虚拟环境
conda create -n ai_env python=3.9
conda activate ai_env
# 安装核心库
pip install numpy pandas matplotlib seaborn
pip install scikit-learn tensorflow torch
pip install jupyter notebook
# 验证安装
python -c "import tensorflow as tf; print(tf.__version__)"
python -c "import torch; print(torch.__version__)"

project/
├── data/          # 数据目录
│   ├── raw/       # 原始数据
│   ├── processed/ # 处理后数据
│   └── external/  # 外部数据
├── notebooks/     # Jupyter 笔记本
│   └── exploration.ipynb
├── src/           # 源代码
│   ├── data/      # 数据处理
│   ├── features/  # 特征工程
│   ├── models/    # 模型定义
│   └── utils/     # 工具函数
├── tests/         # 测试代码
├── configs/       # 配置文件
├── requirements.txt # 依赖列表
└── README.md      # 项目说明

阶段	任务	输出
数据准备	收集、清洗、划分	干净的数据集
特征工程	提取、选择、转换	特征矩阵
模型选择	算法对比、实验	最优模型
训练优化	调参、验证	训练好的模型
部署上线	打包、服务化	API 接口

""" 房价预测完整案例 """
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
import matplotlib.pyplot as plt

class HousePricePredictor:
    """房价预测器"""
    def __init__(self):
        self.model = None
        self.preprocessor = None

    def prepare_data(self, data: pd.DataFrame, target_col: str):
        """准备数据"""
        X = data.drop(columns=[target_col])
        y = data[target_col]
        numeric_features = X.select_dtypes(include=[np.number]).columns.tolist()
        categorical_features = X.select_dtypes(exclude=[np.number]).columns.tolist()
        self.preprocessor = ColumnTransformer(
            transformers=[
                ('num', StandardScaler(), numeric_features),
                ('cat', OneHotEncoder(handle_unknown='ignore'), categorical_features)
            ])
        return train_test_split(X, y, test_size=0.2, random_state=42)

    def train(self, X_train, y_train):
        """训练模型"""
        self.model = Pipeline([
            ('preprocessor', self.preprocessor),
            ('regressor', GradientBoostingRegressor(
                n_estimators=200, learning_rate=0.1, max_depth=5, random_state=42))
        ])
        self.model.fit(X_train, y_train)
        return self

    def evaluate(self, X_test, y_test):
        """评估模型"""
        y_pred = self.model.predict(X_test)
        metrics = {
            'RMSE': np.sqrt(mean_squared_error(y_test, y_pred)),
            'MAE': mean_absolute_error(y_test, y_pred),
            'R2': r2_score(y_test, y_pred)
        }
        return metrics, y_pred

    def plot_predictions(self, y_test, y_pred):
        """绘制预测结果"""
        plt.figure(figsize=(10, 6))
        plt.scatter(y_test, y_pred, alpha=0.5)
        plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--')
        plt.xlabel('真实价格')
        plt.ylabel('预测价格')
        plt.title('房价预测结果')
        plt.show()

if __name__ == "__main__":
    pass

指标	数值
RMSE	25000
MAE	18000
R²	0.89

数据量	推荐模型	原因
小样本	传统 ML	不易过拟合
中等样本	集成学习	性能稳定
大样本	深度学习	潜力更大

# 处理数据不平衡的方法
from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import RandomUnderSampler
from sklearn.utils.class_weight import compute_class_weight

# 方法 1：过采样
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X, y)

# 方法 2：欠采样
undersampler = RandomUnderSampler(random_state=42)
X_resampled, y_resampled = undersampler.fit_resample(X, y)

# 方法 3：类别权重
class_weights = compute_class_weight('balanced', classes=np.unique(y), y=y)

趋势	描述	预计时间
AutoML	自动化机器学习	已实现
大模型	预训练模型微调	主流趋势
多模态	图文音视频融合	快速发展
边缘 AI	端侧部署	持续推进

AI 工具链：Gradio 演示界面

AI 工具链：Gradio 演示界面

引言

核心概念解析

基本定义

关键术语解释

技术原理深入

核心算法原理

数据处理流程

模型评估方法

实践应用指南

应用场景分析

实施步骤详解

最佳实践分享

案例分析

成功案例：房价预测模型

失败教训：过拟合问题

常见问题解答

技术问题

应用问题

未来发展趋势

技术趋势

应用趋势

总结

更多推荐文章

相关免费在线工具

AI 工具链：Gradio 演示界面

AI 工具链：Gradio 演示界面

引言

核心概念解析

基本定义

关键术语解释

技术原理深入

核心算法原理

数据处理流程

模型评估方法

实践应用指南

应用场景分析

实施步骤详解

最佳实践分享

案例分析

成功案例：房价预测模型

失败教训：过拟合问题

常见问题解答

技术问题

应用问题

未来发展趋势

技术趋势

应用趋势

总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具