1
线性不可分的典型案例：
2

3
情况1: 同心圆数据
4
    ●○●○●○●○●
5
  ○●○●○●○●○●○
6
●○●○●○●○●○●○●
7
  ○●○●○●○●○●○
8
    ●○●○●○●○●
9

10
情况2: 异或(XOR)问题
11
  ○    ●
12
     ×
13
  ●    ○
14

15
情况3: 月牙形数据
16
  ●●●●●●○○○
17
●●●●●●○○○○○
18
●●●●●○○○○○○
19
  ●●●○○○○○
20
    ●○○○○

1
# RBF核参数对决策边界的影响
2
def plot_rbf_effect():
3
    gamma_values = [0.1, 1.0, 10.0, 100.0]
4

5
    for gamma in gamma_values:
6
        svm = SVC(kernel='rbf', gamma=gamma, C=1.0)
7
        # ... 训练和可视化代码

1
# C参数对决策边界的影响
2
def plot_C_effect():
3
    """可视化C参数对决策边界复杂度的影响"""
4
    C_values = [0.1, 1, 10, 100]
5

6
    # 生成有噪声的数据
7
    X, y = make_circles(n_samples=100, noise=0.3, factor=0.3, random_state=42)
8

9
    fig, axes = plt.subplots(1, 4, figsize=(16, 4))
10

11
    for i, C in enumerate(C_values):
12
        svm = SVC(kernel='rbf', C=C, gamma='scale')
13
        svm.fit(X, y)
14

15
        # 绘制决策边界和支持向量
16
        # ... 可视化代码
17

18
        axes[i].set_title(f'C = {C}\n支持向量数: {len(svm.support_vectors_)}')
19

20
    plt.show()

1
from sklearn.model_selection import GridSearchCV, cross_val_score
2
from sklearn.metrics import classification_report, confusion_matrix
3
import seaborn as sns
4

5
def comprehensive_svm_tuning(X, y, test_size=0.2):
6
    """全面的SVM参数调优流程"""
7

8
    # 数据分割
9
    X_train, X_test, y_train, y_test = train_test_split(
10
        X, y, test_size=test_size, random_state=42, stratify=y
11
    )
12

13
    # 定义参数搜索空间
14
    param_grids = [
15
        {
16
            'kernel': ['linear'],
17
            'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]
18
        },
19
        {
20
            'kernel': ['rbf'],
21
            'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
22
            'gamma': ['scale', 'auto', 0.001, 0.01, 0.1, 1, 10, 100]
23
        },
24
        {
25
            'kernel': ['poly'],
26
            'C': [0.1, 1, 10, 100],
27
            'degree': [2, 3, 4, 5],
28
            'gamma': ['scale', 'auto', 0.01, 0.1, 1]
29
        }
30
    ]
31

32
    # 执行网格搜索
33
    print("开始网格搜索...")
34
    svm = SVC(random_state=42)
35
    grid_search = GridSearchCV(
36
        estimator=svm,
37
        param_grid=param_grids,
38
        cv=5,                    # 5折交叉验证
39
        scoring='accuracy',      # 评估指标
40
        n_jobs=-1,              # 使用所有CPU核心
41
        verbose=1               # 显示进度
42
    )
43

44
    grid_search.fit(X_train, y_train)
45

46
    # 输出最佳参数
47
    print(f"\n最佳参数组合: {grid_search.best_params_}")
48
    print(f"最佳交叉验证分数: {grid_search.best_score_:.4f}")
49

50
    # 在测试集上评估
51
    best_svm = grid_search.best_estimator_
52
    train_score = best_svm.score(X_train, y_train)
53
    test_score = best_svm.score(X_test, y_test)
54

55
    print(f"\n模型性能:")
56
    print(f"训练集准确率: {train_score:.4f}")
57
    print(f"测试集准确率: {test_score:.4f}")
58
    print(f"过拟合程度: {train_score - test_score:.4f}")
59

60
    # 详细的分类报告
61
    y_pred = best_svm.predict(X_test)
62
    print(f"\n详细分类报告:")
63
    print(classification_report(y_test, y_pred))
64

65
    # 绘制混淆矩阵
66
    cm = confusion_matrix(y_test, y_pred)
67
    plt.figure(figsize=(8, 6))
68
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
69
                xticklabels=np.unique(y), yticklabels=np.unique(y))
70
    plt.title('混淆矩阵')
71
    plt.ylabel('真实标签')
72
    plt.xlabel('预测标签')
73
    plt.show()
74

75
    return best_svm, grid_search
76

77
# 实际应用示例
78
from sklearn.datasets import load_breast_cancer
79
from sklearn.preprocessing import StandardScaler
80

81
# 加载乳腺癌数据集
82
cancer = load_breast_cancer()
83
X, y = cancer.data, cancer.target
84

85
# 特征标准化（重要！）
86
scaler = StandardScaler()
87
X_scaled = scaler.fit_transform(X)
88

89
print("数据集信息:")
90
print(f"样本数量: {X.shape[0]}")
91
print(f"特征数量: {X.shape[1]}")
92
print(f"类别分布: {np.bincount(y)}")
93

94
# 执行参数调优
95
best_model, grid_results = comprehensive_svm_tuning(X_scaled, y)

1
from sklearn.model_selection import learning_curve
2

3
def plot_learning_curves(estimator, X, y, title="学习曲线"):
4
    """绘制学习曲线，分析模型的偏差和方差"""
5

6
    train_sizes, train_scores, val_scores = learning_curve(
7
        estimator, X, y, cv=5, n_jobs=-1,
8
        train_sizes=np.linspace(0.1, 1.0, 10),
9
        scoring='accuracy'
10
    )
11

12
    # 计算均值和标准差
13
    train_mean = np.mean(train_scores, axis=1)
14
    train_std = np.std(train_scores, axis=1)
15
    val_mean = np.mean(val_scores, axis=1)
16
    val_std = np.std(val_scores, axis=1)
17

18
    # 绘制学习曲线
19
    plt.figure(figsize=(10, 6))
20
    plt.plot(train_sizes, train_mean, 'o-', color='blue', label='训练分数')
21
    plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, alpha=0.1, color='blue')
22

23
    plt.plot(train_sizes, val_mean, 'o-', color='red', label='验证分数')
24
    plt.fill_between(train_sizes, val_mean - val_std, val_mean + val_std, alpha=0.1, color='red')
25

26
    plt.xlabel('训练样本数量')
27
    plt.ylabel('准确率')
28
    plt.title(title)
29
    plt.legend()
30
    plt.grid(True, alpha=0.3)
31
    plt.show()
32

33
    # 分析结果
34
    final_gap = train_mean[-1] - val_mean[-1]
35
    if final_gap > 0.05:
36
        print("检测到过拟合：训练分数明显高于验证分数")
37
        print("建议：减小C值或增大gamma值")
38
    elif val_mean[-1] < 0.8:
39
        print("检测到欠拟合：验证分数较低")
40
        print("建议：增大C值或减小gamma值")
41
    else:
42
        print("模型拟合较好")
43

44
# 分析最佳模型的学习曲线
45
plot_learning_curves(best_model, X_scaled, y, "最佳SVM模型学习曲线")

1
from sklearn.model_selection import validation_curve
2

3
def plot_validation_curve(X, y, param_name, param_range, kernel='rbf'):
4
    """绘制验证曲线，分析单个参数的影响"""
5

6
    # 固定其他参数
7
    base_params = {'kernel': kernel, 'random_state': 42}
8
    if kernel == 'rbf':
9
        if param_name != 'gamma':
10
            base_params['gamma'] = 'scale'
11
        if param_name != 'C':
12
            base_params['C'] = 1.0
13

14
    train_scores, val_scores = validation_curve(
15
        SVC(**base_params), X, y,
16
        param_name=param_name, param_range=param_range,
17
        cv=5, scoring='accuracy', n_jobs=-1
18
    )
19

20
    train_mean = np.mean(train_scores, axis=1)
21
    train_std = np.std(train_scores, axis=1)
22
    val_mean = np.mean(val_scores, axis=1)
23
    val_std = np.std(val_scores, axis=1)
24

25
    plt.figure(figsize=(10, 6))
26
    plt.semilogx(param_range, train_mean, 'o-', color='blue', label='训练分数')
27
    plt.fill_between(param_range, train_mean - train_std, train_mean + train_std, alpha=0.1, color='blue')
28

29
    plt.semilogx(param_range, val_mean, 'o-', color='red', label='验证分数')
30
    plt.fill_between(param_range, val_mean - val_std, val_mean + val_std, alpha=0.1, color='red')
31

32
    plt.xlabel(f'{param_name}')
33
    plt.ylabel('准确率')
34
    plt.title(f'{param_name}参数的验证曲线')
35
    plt.legend()
36
    plt.grid(True, alpha=0.3)
37
    plt.show()
38

39
    # 找到最佳参数
40
    best_idx = np.argmax(val_mean)
41
    best_param = param_range[best_idx]
42
    print(f"最佳{param_name}值: {best_param}")
43
    print(f"对应验证分数: {val_mean[best_idx]:.4f}")
44

45
# 分析C参数的影响
46
C_range = np.logspace(-3, 3, 13)
47
plot_validation_curve(X_scaled, y, 'C', C_range)
48

49
# 分析gamma参数的影响
50
gamma_range = np.logspace(-4, 1, 12)
51
plot_validation_curve(X_scaled, y, 'gamma', gamma_range)

1
from skopt import BayesSearchCV
2
from skopt.space import Real, Integer, Categorical
3

4
def bayesian_optimization_svm(X, y):
5
    """使用贝叶斯优化进行SVM参数调优"""
6

7
    # 定义搜索空间
8
    search_spaces = {
9
        'C': Real(1e-3, 1e3, prior='log-uniform'),
10
        'gamma': Real(1e-4, 1e1, prior='log-uniform'),
11
        'kernel': Categorical(['rbf', 'poly', 'sigmoid'])
12
    }
13

14
    # 贝叶斯搜索
15
    bayes_search = BayesSearchCV(
16
        SVC(random_state=42),
17
        search_spaces,
18
        n_iter=50,        # 迭代次数
19
        cv=5,
20
        scoring='accuracy',
21
        n_jobs=-1,
22
        random_state=42
23
    )
24

25
    bayes_search.fit(X, y)
26

27
    print(f"贝叶斯优化最佳参数: {bayes_search.best_params_}")
28
    print(f"贝叶斯优化最佳分数: {bayes_search.best_score_:.4f}")
29

30
    return bayes_search.best_estimator_

1
from sklearn.metrics import make_scorer, f1_score, precision_score, recall_score
2

3
def multi_objective_optimization(X, y):
4
    """多目标SVM优化"""
5

6
    # 定义多个评分指标
7
    scoring = {
8
        'accuracy': 'accuracy',
9
        'precision': make_scorer(precision_score, average='weighted'),
10
        'recall': make_scorer(recall_score, average='weighted'),
11
        'f1': make_scorer(f1_score, average='weighted')
12
    }
13

14
    param_grid = {
15
        'C': [0.1, 1, 10],
16
        'gamma': ['scale', 0.01, 0.1, 1],
17
        'kernel': ['rbf']
18
    }
19

20
    grid_search = GridSearchCV(
21
        SVC(random_state=42),
22
        param_grid,
23
        cv=5,
24
        scoring=scoring,
25
        refit='f1',  # 以F1分数作为最终选择标准
26
        return_train_score=True
27
    )
28

29
    grid_search.fit(X, y)
30

31
    # 分析结果
32
    results_df = pd.DataFrame(grid_search.cv_results_)
33
    print("Top 5 参数组合 (按F1分数排序):")
34
    print(results_df.nlargest[5, 'mean_test_f1'](['params', 'mean_test_accuracy', 'mean_test_precision', 'mean_test_recall', 'mean_test_f1')])
35

36
    return grid_search.best_estimator_

1
import re
2
import nltk
3
from nltk.corpus import stopwords
4
from nltk.tokenize import word_tokenize
5
from nltk.stem import PorterStemmer, WordNetLemmatizer
6
import pandas as pd
7

8
class TextPreprocessor:
9
    """文本预处理器"""
10

11
    def __init__(self, language='english'):
12
        # 下载必要的NLTK数据
13
        try:
14
            nltk.data.find('tokenizers/punkt')
15
        except LookupError:
16
            nltk.download('punkt')
17

18
        try:
19
            nltk.data.find('corpora/stopwords')
20
        except LookupError:
21
            nltk.download('stopwords')
22

23
        try:
24
            nltk.data.find('corpora/wordnet')
25
        except LookupError:
26
            nltk.download('wordnet')
27

28
        self.stop_words = set(stopwords.words(language))
29
        self.stemmer = PorterStemmer()
30
        self.lemmatizer = WordNetLemmatizer()
31

32
    def clean_text(self, text):
33
        """文本清洗"""
34
        if not isinstance(text, str):
35
            return ""
36

37
        # 转换为小写
38
        text = text.lower()
39

40
        # 移除HTML标签
41
        text = re.sub(r'<[^>]+>', '', text)
42

43
        # 移除URL
44
        text = re.sub(r'http\S+', '', text)
45

46
        # 移除邮箱
47
        text = re.sub(r'\S+@\S+', '', text)
48

49
        # 保留字母和空格，移除数字和特殊字符
50
        text = re.sub(r'[^a-zA-Z\s]', '', text)
51

52
        # 移除多余空格
53
        text = re.sub(r'\s+', ' ', text).strip()
54

55
        return text
56

57
    def tokenize_and_process(self, text, use_stemming=True, use_lemmatization=False):
58
        """分词和词汇处理"""
59
        if not text:
60
            return []
61

62
        # 分词
63
        tokens = word_tokenize(text)
64

65
        # 移除停用词和短词
66
        tokens = [token for token in tokens
67
                 if token not in self.stop_words and len(token) > 2]
68

69
        # 词干提取或词形还原
70
        if use_stemming:
71
            tokens = [self.stemmer.stem(token) for token in tokens]
72
        elif use_lemmatization:
73
            tokens = [self.lemmatizer.lemmatize(token) for token in tokens]
74

75
        return tokens
76

77
    def preprocess_corpus(self, texts, use_stemming=True):
78
        """批量预处理文本"""
79
        processed_texts = []
80

81
        for text in texts:
82
            # 清洗文本
83
            cleaned = self.clean_text(text)
84

85
            # 分词处理
86
            tokens = self.tokenize_and_process(cleaned, use_stemming)
87

88
            # 重新组合成字符串
89
            processed_text = ' '.join(tokens)
90
            processed_texts.append(processed_text)
91

92
        return processed_texts
93

94
# 示例使用
95
preprocessor = TextPreprocessor()
96

97
# 测试文本预处理
98
sample_text = """
99
This is a SAMPLE text with HTML <tags> and URLs like https://example.com!
100
It also has some numbers 123 and special characters @#$%.
101
We want to clean this text for machine learning purposes.
102
"""
103

104
cleaned = preprocessor.clean_text(sample_text)
105
tokens = preprocessor.tokenize_and_process(cleaned)
106
print(f"原文: {sample_text}")
107
print(f"清洗后: {cleaned}")
108
print(f"分词结果: {tokens}")

1
from sklearn.feature_extraction.text import TfidfVectorizer
2
from sklearn.feature_selection import SelectKBest, chi2
3

4
class AdvancedTfidfVectorizer:
5
    """增强版TF-IDF向量化器"""
6

7
    def __init__(self, max_features=10000, min_df=2, max_df=0.95,
8
                 ngram_range=(1, 2), use_feature_selection=True, k_best=5000):
9
        self.max_features = max_features
10
        self.min_df = min_df
11
        self.max_df = max_df
12
        self.ngram_range = ngram_range
13
        self.use_feature_selection = use_feature_selection
14
        self.k_best = k_best
15

16
        self.vectorizer = None
17
        self.feature_selector = None
18
        self.feature_names = None
19

20
    def fit_transform(self, texts, labels=None):
21
        """训练并转换文本"""
22

23
        # TF-IDF向量化
24
        self.vectorizer = TfidfVectorizer(
25
            max_features=self.max_features,
26
            min_df=self.min_df,
27
            max_df=self.max_df,
28
            ngram_range=self.ngram_range,
29
            stop_words='english',
30
            lowercase=True,
31
            strip_accents='unicode'
32
        )
33

34
        X = self.vectorizer.fit_transform(texts)
35
        print(f"TF-IDF矩阵形状: {X.shape}")
36
        print(f"矩阵稀疏度: {1 - X.nnz / (X.shape[0] * X.shape[1]):.4f}")
37

38
        # 特征选择（如果提供了标签）
39
        if self.use_feature_selection and labels is not None:
40
            self.feature_selector = SelectKBest(chi2, k=min(self.k_best, X.shape[1]))
41
            X = self.feature_selector.fit_transform(X, labels)
42
            print(f"特征选择后矩阵形状: {X.shape}")
43

44
            # 获取选中的特征名
45
            feature_mask = self.feature_selector.get_support()
46
            self.feature_names = np.array(self.vectorizer.get_feature_names_out())[feature_mask]
47
        else:
48
            self.feature_names = self.vectorizer.get_feature_names_out()
49

50
        return X
51

52
    def transform(self, texts):
53
        """转换新文本"""
54
        if self.vectorizer is None:
55
            raise ValueError("必须先调用fit_transform")
56

57
        X = self.vectorizer.transform(texts)
58

59
        if self.feature_selector is not None:
60
            X = self.feature_selector.transform(X)
61

62
        return X
63

64
    def get_feature_importance(self, svm_model, top_n=20):
65
        """获取SVM模型的特征重要性"""
66
        if hasattr(svm_model, 'coef_'):
67
            # 线性SVM的特征重要性
68
            coef = svm_model.coef_[0]
69
            feature_importance = np.abs(coef)
70

71
            # 排序获取最重要的特征
72
            top_indices = np.argsort[feature_importance][-top_n:](::-1)
73

74
            top_features = []
75
            for idx in top_indices:
76
                feature_name = self.feature_names[idx]
77
                importance = feature_importance[idx]
78
                top_features.append((feature_name, importance))
79

80
            return top_features
81
        else:
82
            print("非线性SVM无法直接提取特征重要性")
83
            return None