Partage de technologie

Apprentissage automatique (5) -- Apprentissage supervisé (6) -- Régression logistique

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Table des matières et liens vers des séries d'articles

Article précédent :Apprentissage automatique (5) -- Apprentissage supervisé (5) -- Régression linéaire 2
Article suivant :Apprentissage automatique (5) -- Apprentissage supervisé (7) --SVM1

Préface

tips：标题前有“***”的内容为补充内容，是给好奇心重的宝宝看的，可自行跳过。文章内容被“文章内容”删除线标记的，也可以自行跳过。“！！！”一般需要特别注意或者容易出错的地方。

本系列文章是作者边学习边总结的，内容有不对的地方还请多多指正，同时本系列文章会不断完善，每篇文章不定时会有修改。

由于作者时间不算富裕，有些内容的《算法实现》部分暂未完善，以后有时间再来补充。见谅！

文中为方便理解，会将接口在用到的时候才导入，实际中应在文件开始统一导入。

1. Compréhension et définition populaires

1. Qu'est-ce que la régression logistique (Quoi)

Régression logistique = régression linéaire + fonction sigmoïde

La régression logistique (Logistic Regression) consiste simplement à trouver une ligne droite pour diviser une donnée binaire.

2. Le but de la régression logistique (Pourquoi)

Résoudre le problème de classification binaire en classant les objets appartenant à une certaine catégorievaleur de probabilitéPour déterminer si elle appartient à une certaine catégorie, cette catégorie est marquée par défaut par 1 (exemple positif), et l'autre catégorie sera marquée par 0 (exemple négatif).

3. Comment trouver cette ligne (Comment)

En fait, cela est similaire à l'étape de régression linéaire. La différence réside dans les méthodes utilisées pour « vérifier l'effet d'ajustement du modèle » et « ajuster l'angle de position du modèle ».

  1. Tracez une ligne droite au hasard comme ligne droite initiale
  2. Vérifiez son effet d'ajustement,
  3. Si ce n'est pas le meilleur (seuil atteint), ajuster la position et l'angle de la ligne
  4. Répétez les étapes 2 et 3 jusqu'à obtenir le meilleur effet (atteindre le seuil défini), et enfin le modèle souhaité.

Vous devez utiliser une fonction (fonction sigmoïde) pour mapper les données d'entrée entre 0 et 1, et si la valeur de la fonction est supérieure à 0,5, elle est jugée égale à 1, sinon elle est égale à 0. Cela peut être converti en une représentation probabiliste.

2. Compréhension des principes et formules

1. Perceptron

1.1. Description du problème

Prenons l'exemple de la classification des images, divisez les images en verticales et horizontales

C'est ainsi que ces données sont affichées sur le graphique. Afin de séparer les points de différentes couleurs (différentes catégories) dans le graphique, nous traçons une telle ligne. Le but de cette classification est de trouver une telle ligne.

Il s'agit d'une "ligne droite qui fait du vecteur de poids un vecteur normal" (que le vecteur de poids soit perpendiculaire à la ligne)

w est le vecteur poids ; ce qui en fait une droite du vecteur normal, même

1.2. Modèle Perceptron

Un modèle qui accepte plusieurs valeurs, multiplie chaque valeur par son poids respectif et génère finalement la somme.

1.3. Fonction discriminante

Le produit scalaire est une mesure du degré de similarité entre les vecteurs. Un résultat positif indique une similarité, une valeur de 0 indique une verticalité et un résultat négatif indique une dissimilarité.

utiliserC'est plus facile à comprendre, car |w| et |x| sont tous deux des nombres positifs, donc le signe du produit scalaire est déterminé par cosθ, c'est-à-dire que s'il est inférieur à 90 degrés, il est similaire, et s'il est supérieur à 90 degrés, il est différent, c'est-à-dire

1.4. Estimation des paramètres (expression de mise à jour du poids)

S'il est égal à la valeur de l'étiquette d'origine, le vecteur de poids ne sera pas mis à jour. S'il n'est pas égal à la valeur de l'étiquette d'origine, l'ajout de vecteurs sera utilisé pour mettre à jour le vecteur de poids.

Comme le montre la figure, si elle n'est pas égale à l'étiquette d'origine, alors

ligne droite après mise à jour

Après mise à jour, égal

Étapes : Déterminez d'abord au hasard une ligne droite (c'est-à-dire déterminez au hasard un vecteur de poids w), remplacez une valeur réelle x dans le produit interne et obtenez une valeur (1 ou -1) via la fonction discriminante si elle est égale. à la valeur de l'étiquette d'origine, le vecteur de poids n'est pas mis à jour, s'il est différent de la valeur de l'étiquette d'origine, utilisez l'ajout de vecteur pour mettre à jour le vecteur de poids.

! ! !Remarque : le perceptron ne peut résoudre que des problèmes linéairement séparables
Linéairement séparable : cas où des lignes droites peuvent être utilisées pour la classification
Inséparabilité linéaire : ne peut être classée par des lignes droites

2. fonction sigmoïde

Le noir est la fonction sigmoïde, le rouge est la fonction échelon (discontinue)

Fonction : L'entrée de la régression logistique est le résultat de la régression linéaire.Nous pouvons obtenir une valeur prédite en régression linéaire. La fonction sigmoïde mappe n'importe quelle entrée sur l'intervalle [0,1], complétant ainsi la conversion de la valeur en probabilité, qui est une tâche de classification.

3. Régression logistique

3.1. Définition du modèle

Régression logistique = régression linéaire + fonction sigmoïde

Régression linéaire:

fonction sigmoïde :

Régression logistique:

Pour que y représente l'étiquette, remplacez-la par :

Pour faire des probabilités, utilisez :

3.2. Fonction discriminante

Autrement dit, les catégories peuvent être distinguées par probabilité

3.3. Limite de décision

Il peut être réécrit comme suit :

quand

Données de remplacement :

Il y a une telle image

La ligne droite utilisée pour la classification des données est la limite de décision

3.4. Fonction objectif (fonction log de vraisemblance)

Ce que nous voulons, c'est ceci :
Lorsque y=1, P(y=1|x) est le plus grand
Lorsque y=0, P(y=0|x) est le plus grand

Fonction de vraisemblance (probabilité conjointe) : voici la probabilité que l'on souhaite maximiser

Fonction log-vraisemblance : Il est difficile de différencier directement la fonction de vraisemblance. Vous devez d'abord prendre le logarithme.

Après déformation, il devient :

3.4. Estimation des paramètres (descente de gradient)

Différenciation de la fonction de vraisemblance :

3. Avantages et inconvénients

3.1. Avantages :

1. Simple à mettre en œuvre : La régression logistique est un algorithme simple, facile à comprendre et à mettre en œuvre.
2. Efficacité de calcul élevée : la régression logistique nécessite une quantité relativement faible de calculs et convient aux ensembles de données à grande échelle.
3. Forte interprétabilité : les résultats de sortie de la régression logistique sont des valeurs de probabilité, qui peuvent expliquer intuitivement la sortie du modèle.

3.2. Inconvénients :

1. Exigences de séparabilité linéaire : la régression logistique est un modèle linéaire et fonctionne mal pour les problèmes séparables non linéaires.
2. Problème de corrélation des caractéristiques : la régression logistique est plus sensible à la corrélation entre les caractéristiques d'entrée. Lorsqu'il existe une forte corrélation entre les caractéristiques, cela peut entraîner une baisse des performances du modèle.
3. Problème de surajustement : lorsqu'il y a trop de caractéristiques d'échantillon ou que le nombre d'échantillons est petit, la régression logistique est sujette à des problèmes de surajustement.

3. ** Implémentation de l'algorithme

1. Obtenez des données

  1. import numpy as np
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. %matplotlib notebook
  5.  
  6. # 读取数据
  7. train=pd.read_csv('csv/images2.csv')
  8. train_x=train.iloc[:,0:2]
  9. train_y=train.iloc[:,2]
  10. # print(train_x)
  11. # print(train_y)
  12.  
  13. # 绘图
  14. plt.figure()
  15. plt.plot(train_x[train_y ==1].iloc[:,0],train_x[train_y ==1].iloc[:,1],'o')
  16. plt.plot(train_x[train_y == 0].iloc[:,0],train_x[train_y == 0].iloc[:,1],'x')
  17. plt.axis('scaled')
  18. # plt.axis([0,500,0,500])
  19. plt.show()

2. Traitement des données

  1. # 初始化参数
  2. theta=np.random.randn(3)
  3.  
  4. # 标准化
  5. mu = train_x.mean(axis=0)
  6. sigma = train_x.std(axis=0)
  7. # print(mu,sigma)
  8.  
  9.  
  10. def standardize(x):
  11.     return (x - mu) / sigma
  12.  
  13. train_z = standardize(train_x)
  14. # print(train_z)
  15.  
  16. # 增加 x0
  17. def to_matrix(x):
  18.     x0 = np.ones([x.shape[0], 1])
  19.     return np.hstack([x0, x])
  20.  
  21. X = to_matrix(train_z)
  22.  
  23.  
  24. # 绘图
  25. plt.figure()
  26. plt.plot(train_z[train_y ==1].iloc[:,0],train_z[train_y ==1].iloc[:,1],'o')
  27. plt.plot(train_z[train_y == 0].iloc[:,0],train_z[train_y == 0].iloc[:,1],'x')
  28. plt.axis('scaled')
  29. # plt.axis([0,500,0,500])
  30. plt.show()

3. Fonction sigmoïde et fonction discriminante

  1. # sigmoid 函数
  2. def f(x):
  3.     return 1 / (1 + np.exp(-np.dot(x, theta)))
  4.  
  5. # 分类函数
  6. def classify(x):
  7.     return (f(x) >= 0.5).astype(np.int)

4. Paramétrage et formation

  1. # 学习率
  2. ETA = 1e-3
  3.  
  4. # 重复次数
  5. epoch = 5000
  6.  
  7. # 更新次数
  8. count = 0
  9. print(f(X))
  10.  
  11. # 重复学习
  12. for _ in range(epoch):
  13.     theta = theta - ETA * np.dot(f(X) - train_y, X)
  14.  
  15.     # 日志输出
  16.     count += 1
  17.     print('第 {} 次 : theta = {}'.format(count, theta))

5. Confirmation du dessin

  1. # 绘图确认
  2. plt.figure()
  3. x0 = np.linspace(-2, 2, 100)
  4. plt.plot(train_z[train_y ==1].iloc[:,0],train_z[train_y ==1].iloc[:,1],'o')
  5. plt.plot(train_z[train_y == 0].iloc[:,0],train_z[train_y == 0].iloc[:,1],'x')
  6. plt.plot(x0, -(theta[0] + theta[1] * x0) / theta[2], linestyle='dashed')
  7. plt.show()

 

6.Vérification

  1. # 验证
  2. text=[[200,100],[500,400],[150,170]]
  3. tt=pd.DataFrame(text,columns=['x1','x2'])
  4. # text=pd.DataFrame({'x1':[200,400,150],'x2':[100,50,170]})
  5. x=to_matrix(standardize(tt))
  6. print(x)
  7. a=f(x)
  8. print(a)
  9.  
  10. b=classify(x)
  11. print(b)
  12.  
  13. plt.plot(x[:,1],x[:,2],'ro')

 

4. Implémentation de l'interface

1. Introduction à l'ensemble de données sur le cancer du sein

1.1. API

from sklearn.datasets import load_breast_cancer

1.2. Informations de base

  1. # 键
  2. print("乳腺癌数据集的键：",breast_cancer.keys())
  3.  
  4.  
  5.  
  6. # 特征值名字、目标值名字
  7. print("乳腺癌数据集的特征数据形状：",breast_cancer.data.shape)
  8. print("乳腺癌数据集的目标数据形状：",breast_cancer.target.shape)
  9.  
  10. print("乳腺癌数据集的特征值名字：",breast_cancer.feature_names)
  11. print("乳腺癌数据集的目标值名字：",breast_cancer.target_names)
  12.  
  13. # print("乳腺癌数据集的特征值：",breast_cancer.data)
  14. # print("乳腺癌数据集的目标值：",breast_cancer.target)
  15.  
  16.  
  17.  
  18. # 返回值
  19. # print("乳腺癌数据集的返回值：n", breast_cancer)
  20. # 返回值类型是bunch--是一个字典类型
  21.  
  22. # 描述
  23. # print("乳腺癌数据集的描述：",breast_cancer.DESCR)
  24.  
  25.  
  26.  
  27. # 每个特征信息
  28. print("最小值：",breast_cancer.data.min(axis=0))
  29. print("最大值：",breast_cancer.data.max(axis=0))
  30. print("平均值：",breast_cancer.data.mean(axis=0))
  31. print("标准差：",breast_cancer.data.std(axis=0))
  32.  

  1. # 取其中间两列特征
  2. x=breast_cancer.data[0:569,0:2]
  3. y=breast_cancer.target[0:569]
  4.  
  5. samples_0 = x[y==0, :]
  6. samples_1 = x[y==1, :]
  7.  
  8.  
  9.  
  10. # 实现可视化
  11. plt.figure()
  12. plt.scatter(samples_0[:,0],samples_0[:,1],marker='o',color='r')
  13. plt.scatter(samples_1[:,0],samples_1[:,1],marker='x',color='y')
  14. plt.xlabel('mean radius')
  15. plt.ylabel('mean texture')
  16. plt.show()

  1. # 绘制每个特征直方图，显示特征值的分布情况。
  2. for i, feature_name in enumerate(breast_cancer.feature_names):
  3.     plt.figure(figsize=(6, 4))
  4.     sns.histplot(breast_cancer.data[:, i], kde=True)
  5.     plt.xlabel(feature_name)
  6.     plt.ylabel("数量")
  7.     plt.title("{}直方图".format(feature_name))
  8.     plt.show()

  1. # 绘制箱线图，展示每个特征最小值、第一四分位数、中位数、第三四分位数和最大值概括。
  2. plt.figure(figsize=(10, 6))
  3. sns.boxplot(data=breast_cancer.data, orient="v")
  4. plt.xticks(range(len(breast_cancer.feature_names)), breast_cancer.feature_names, rotation=90)
  5. plt.xlabel("特征")
  6. plt.ylabel("值")
  7. plt.title("特征箱线图")
  8. plt.show()

1.3. Valeurs manquantes et valeurs aberrantes

  1. # 创建DataFrame对象
  2. df = pd.DataFrame(breast_cancer.data, columns=breast_cancer.feature_names)
  3.  
  4. # 检测缺失值
  5. print("缺失值数量：")
  6. print(df.isnull().sum())
  7.  
  8. # 检测异常值
  9. print("异常值统计信息：")
  10. print(df.describe())
  11. # 使用.describe()方法获取数据集的统计信息，包括计数、均值、标准差、最小值、25%分位数、中位数、75%分位数和最大值。

1.4.Pertinence

  1. # 创建DataFrame对象
  2. df = pd.DataFrame(breast_cancer.data, columns=breast_cancer.feature_names)
  3.  
  4. # 计算相关系数
  5. correlation_matrix = df.corr()
  6.  
  7. # 可视化相关系数热力图
  8. plt.figure(figsize=(10, 8))
  9. sns.heatmap(correlation_matrix, annot=True, cmap="coolwarm")
  10. plt.title("Correlation Heatmap")
  11. plt.show()

2. API

  1. sklearn.linear_model.LogisticRegression
  2.  
  3. 导入：
  4. from sklearn.linear_model import LogisticRegression
  5.  
  6. 语法：
  7. LogisticRegression(solver='liblinear', penalty=‘l2’, C = 1.0)
  8.     solver可选参数:{'liblinear', 'sag', 'saga','newton-cg', 'lbfgs'}，
  9.         默认: 'liblinear'；用于优化问题的算法。
  10.         对于小数据集来说，“liblinear”是个不错的选择，而“sag”和'saga'对于大型数据集会更快。
  11.         对于多类问题，只有'newton-cg'， 'sag'， 'saga'和'lbfgs'可以处理多项损失;“liblinear”仅限于“one-versus-rest”分类。
  12.     penalty：正则化的种类
  13.     C：正则化力度

2. Processus

2.1. Obtenir des données

  1. from sklearn.datasets import load_breast_cancer
  2. from sklearn.model_selection import train_test_split
  3.  
  4. from sklearn.linear_model import LogisticRegression
  5.  
  6. # 获取数据
  7. breast_cancer = load_breast_cancer()

2.2. Prétraitement des données

  1. # 划分数据集
  2. x_train,x_test,y_train,y_test = train_test_split(breast_cancer.data, breast_cancer.target, test_size=0.2, random_state=1473)

2.3. Ingénierie des fonctionnalités

2.4. Formation sur modèle

  1. # 实例化学习器
  2. lr = LogisticRegression(max_iter=10000)
  3.  
  4. # 模型训练
  5. lr.fit(x_train, y_train)
  6.  
  7. print("建立的逻辑回归模型为：n", lr)

 

2.5. Évaluation du modèle

  1. # 用模型计算测试值，得到预测值
  2. y_pred = lr.predict(x_test)
  3. print('预测前20个结果为：n', y_pred[:20])
  4.  
  5. # 求出预测结果的准确率和混淆矩阵
  6. from sklearn.metrics import accuracy_score, confusion_matrix,precision_score,recall_score
  7. print("预测结果准确率为：", accuracy_score(y_test, y_pred))
  8. print("预测结果混淆矩阵为：n", confusion_matrix(y_test, y_pred))
  9.  
  10. print("预测结果查准率为：", precision_score(y_test, y_pred))
  11. print("预测结果召回率为：", recall_score(y_test, y_pred))

  1. from sklearn.metrics import roc_curve,roc_auc_score,auc
  2.  
  3. fpr,tpr,thresholds=roc_curve(y_test,y_pred)
  4.  
  5. plt.plot(fpr, tpr)
  6. plt.axis("square")
  7. plt.xlabel("假正例率/False positive rate")
  8. plt.ylabel("正正例率/True positive rate")
  9. plt.title("ROC curve")
  10. plt.show()
  11.  
  12. print("AUC指标为：",roc_auc_score(y_test,y_pred))

 

  1. # 求出预测取值和真实取值一致的数目 
  2. num_accu = np.sum(y_test == y_pred)
  3. print('预测对的结果数目为：', num_accu)
  4. print('预测错的结果数目为：', y_test.shape[0]-num_accu)
  5. print('预测结果准确率为：', num_accu/y_test.shape[0])

2.6. Prédiction des résultats

Le modèle qui passe après l'évaluation du modèle peut être remplacé par la valeur réelle à des fins de prédiction.

Les vieux rêves peuvent être revécus, voyons voir :Apprentissage automatique (5) -- Apprentissage supervisé (5) -- Régression linéaire 2
Si vous voulez savoir ce qui se passe ensuite, jetons un coup d’œil :Apprentissage automatique (5) -- Apprentissage supervisé (7) --SVM1

Profil personnel

Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.

mes coordonnées

Mail