脚本如何实现文件内容回归分析

本文目录导读：

1. Python实现基础回归分析
2. 多种回归方法实现
3. 自动化回归分析脚本
4. 使用示例
5. 可视化分析

的回归分析。

Python实现基础回归分析

文件读取与数据准备

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error
# 读取CSV文件
def read_data_from_file(file_path, file_type='csv'):
    if file_type == 'csv':
        df = pd.read_csv(file_path)
    elif file_type == 'excel':
        df = pd.read_excel(file_path)
    elif file_type == 'txt':
        df = pd.read_csv(file_path, delimiter='\t')
    return df
# 基本线性回归
def linear_regression_analysis(df, target_column, feature_columns):
    # 准备数据
    X = df[feature_columns]
    y = df[target_column]
    # 分割训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    # 训练模型
    model = LinearRegression()
    model.fit(X_train, y_train)
    # 预测和评估
    y_pred = model.predict(X_test)
    results = {
        'coefficients': model.coef_,
        'intercept': model.intercept_,
        'r2_score': r2_score(y_test, y_pred),
        'mse': mean_squared_error(y_test, y_pred),
        'model': model
    }
    return results

多种回归方法实现

多元回归与多项式回归

from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import Ridge, Lasso
class FileRegressionAnalyzer:
    def __init__(self, file_path):
        self.df = self.load_file(file_path)
        self.models = {}
    def load_file(self, file_path):
        # 自动检测文件格式
        if file_path.endswith('.csv'):
            return pd.read_csv(file_path)
        elif file_path.endswith(('.xlsx', '.xls')):
            return pd.read_excel(file_path)
        elif file_path.endswith('.json'):
            return pd.read_json(file_path)
        else:
            raise ValueError("不支持的文件格式")
    def polynomial_regression(self, target_col, feature_cols, degree=2):
        """多项式回归"""
        X = self.df[feature_cols]
        y = self.df[target_col]
        # 生成多项式特征
        poly_features = PolynomialFeatures(degree=degree)
        X_poly = poly_features.fit_transform(X)
        # 训练模型
        model = LinearRegression()
        model.fit(X_poly, y)
        return {
            'model': model,
            'poly_features': poly_features,
            'predictions': model.predict(X_poly)
        }
    def ridge_regression(self, target_col, feature_cols, alpha=1.0):
        """岭回归（L2正则化）"""
        X = self.df[feature_cols]
        y = self.df[target_col]
        model = Ridge(alpha=alpha)
        model.fit(X, y)
        return model

自动化回归分析脚本

完整的工作流程脚本

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
import argparse
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from typing import Dict, List, Tuple
class AutomaticRegressionAnalyzer:
    def __init__(self):
        self.data = None
        self.results = {}
    def load_and_analyze(self, file_path: str, target_column: str):
        """加载文件并执行完整分析"""
        # 加载数据
        self.data = self._load_data(file_path)
        # 数据探索
        print("数据基本信息：")
        print(self.data.info())
        print("\n数据统计描述：")
        print(self.data.describe())
        # 自动选择特征列
        feature_columns = self._auto_select_features(target_column)
        # 执行回归分析
        results = self._perform_regression(target_column, feature_columns)
        # 生成报告
        self._generate_report(results, file_path)
        return results
    def _load_data(self, file_path: str) -> pd.DataFrame:
        """智能加载数据"""
        if file_path.endswith('.csv'):
            return pd.read_csv(file_path)
        elif file_path.endswith(('.xlsx', '.xls')):
            return pd.read_excel(file_path)
        elif file_path.endswith('.txt'):
            # 尝试不同的分隔符
            for sep in [',', '\t', ';', '|']:
                try:
                    df = pd.read_csv(file_path, sep=sep)
                    if len(df.columns) > 1:
                        return df
                except:
                    continue
        else:
            # 默认使用pandas读取
            return pd.read_csv(file_path)
    def _auto_select_features(self, target_col: str) -> List[str]:
        """自动选择特征列"""
        # 排除目标列和非数值列
        numeric_cols = self.data.select_dtypes(include=[np.number]).columns
        feature_cols = [col for col in numeric_cols if col != target_col]
        # 计算相关性
        correlations = self.data[feature_cols].corrwith(self.data[target_col])
        # 选择相关性高的特征（阈值0.3）
        high_corr_features = correlations[abs(correlations) > 0.3].index.tolist()
        return high_corr_features if high_corr_features else feature_cols[:5]
    def _perform_regression(self, target_col: str, feature_cols: List[str]) -> Dict:
        """执行多种回归分析"""
        from sklearn.ensemble import RandomForestRegressor
        from sklearn.metrics import mean_absolute_error
        X = self.data[feature_cols]
        y = self.data[target_col]
        # 分割数据
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.2, random_state=42
        )
        results = {
            'features': feature_cols,
            'models': {}
        }
        # 1. 线性回归
        lr = LinearRegression()
        lr.fit(X_train, y_train)
        results['models']['线性回归'] = {
            'model': lr,
            'r2': r2_score(y_test, lr.predict(X_test)),
            'mae': mean_absolute_error(y_test, lr.predict(X_test))
        }
        # 2. 随机森林回归
        rf = RandomForestRegressor(n_estimators=100, random_state=42)
        rf.fit(X_train, y_train)
        results['models']['随机森林'] = {
            'model': rf,
            'r2': r2_score(y_test, rf.predict(X_test)),
            'mae': mean_absolute_error(y_test, rf.predict(X_test))
        }
        return results
    def _generate_report(self, results: Dict, file_path: str):
        """生成分析报告"""
        print("\n" + "="*50)
        print(f"回归分析报告 - {file_path}")
        print("="*50)
        print(f"\n使用的特征列：{results['features']}")
        print("\n各模型性能比较：")
        best_model = None
        best_r2 = -1
        for model_name, model_info in results['models'].items():
            print(f"\n{model_name}:")
            print(f"  R²分数: {model_info['r2']:.4f}")
            print(f"  MAE: {model_info['mae']:.4f}")
            if model_info['r2'] > best_r2:
                best_r2 = model_info['r2']
                best_model = model_name
        print(f"\n最佳模型: {best_model} (R² = {best_r2:.4f})")
# 命令行接口
def main():
    parser = argparse.ArgumentParser(description='文件内容回归分析工具')
    parser.add_argument('file_path', help='数据文件路径')
    parser.add_argument('target_column', help='目标变量列名')
    parser.add_argument('--output', '-o', help='输出结果文件路径', default=None)
    args = parser.parse_args()
    analyzer = AutomaticRegressionAnalyzer()
    results = analyzer.load_and_analyze(args.file_path, args.output)
if __name__ == "__main__":
    main()

使用示例

命令行使用

# 基本使用
python regression_analyzer.py data.csv target_column_name
# 保存结果到文件
python regression_analyzer.py data.csv price --output results.json
# 处理Excel文件
python regression_analyzer.py data.xlsx sales

Python代码中调用

from regression_analyzer import FileRegressionAnalyzer
# 创建分析器
analyzer = FileRegressionAnalyzer('data.csv')
# 执行线性回归
results = analyzer.linear_regression_analysis(
    target_column='price',
    feature_columns=['size', 'rooms', 'age']
)
# 执行多项式回归
poly_results = analyzer.polynomial_regression(
    target_col='price',
    feature_cols=['size'],
    degree=3
)

可视化分析

import matplotlib.pyplot as plt
import seaborn as sns
def visualize_regression_results(analyzer, target_col, feature_cols):
    """可视化回归结果"""
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    # 1. 相关性热图
    corr_matrix = analyzer.df[feature_cols + [target_col]].corr()
    sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', ax=axes[0,0])
    axes[0,0].set_title('特征相关性热图')
    # 2. 实际vs预测值
    results = analyzer.linear_regression_analysis(target_col, feature_cols)
    y_pred = results['model'].predict(analyzer.df[feature_cols])
    axes[0,1].scatter(analyzer.df[target_col], y_pred, alpha=0.5)
    axes[0,1].plot([analyzer.df[target_col].min(), analyzer.df[target_col].max()],
                   [analyzer.df[target_col].min(), analyzer.df[target_col].max()],
                   'r--', lw=2)
    axes[0,1].set_xlabel('实际值')
    axes[0,1].set_ylabel('预测值')
    axes[0,1].set_title('实际值 vs 预测值')
    # 3. 残差图
    residuals = analyzer.df[target_col] - y_pred
    axes[1,0].scatter(y_pred, residuals, alpha=0.5)
    axes[1,0].axhline(y=0, color='r', linestyle='--', lw=2)
    axes[1,0].set_xlabel('预测值')
    axes[1,0].set_ylabel('残差')
    axes[1,0].set_title('残差分布图')
    # 4. 特征重要性
    if hasattr(results['model'], 'coef_'):
        coef_df = pd.DataFrame({
            '特征': feature_cols,
            '系数': results['model'].coef_
        }).sort_values('系数', ascending=True)
        axes[1,1].barh(coef_df['特征'], coef_df['系数'])
        axes[1,1].set_title('特征系数重要性')
    plt.tight_layout()
    plt.show()

这个脚本框架提供了完整的文件内容回归分析功能,包括：

• 多种文件格式支持（CSV、Excel、JSON、TXT）
• 自动特征选择
• 多种回归方法（线性、多项式、岭回归、随机森林）
• 完整的评估指标
• 可视化分析
• 命令行接口

根据你的具体需求,可以进一步扩展功能或调整参数。