Chapitre 2 : Algorithme du k-voisin le plus proche
Présentation de KNN
k-近邻（kNN, k-NearestNeighbor）算法是一种基本分类与回归方法，我们这里只讨论分类问题中的 k-近邻算法。
Pour le résumer en une phrase : ceux qui sont proches du rouge sont rouges et ceux qui sont proches de l'encre sont noirs !
k 近邻算法的输入为实例的特征向量，对应于特征空间的点；输出为实例的类别，可以取多类。k 近邻算法假设给定一个训练数据集，其中的实例类别已定。分类时，对新的实例，根据其 k 个最近邻的训练实例的类别，通过多数表决等方式进行预测。因此，k近邻算法不具有显式的学习过程。
k 近邻算法实际上利用训练数据集对特征向量空间进行划分，并作为其分类的“模型”。 k值的选择、距离度量以及分类决策规则是k近邻算法的三个基本要素。
Scénario KNN
Les films peuvent être classés selon leurs thèmes, alors comment distinguer entre 动作片et 爱情片?
- Films d'action : plus de combats
- Films d'amour : plus de bisous
En fonction du nombre de baisers et de bagarres dans le film, en utilisant l'algorithme du k-voisin le plus proche pour construire un programme, le type de sujet du film peut être automatiquement divisé.
现在根据上面我们得到的样本集中所有电影与未知电影的距离，按照距离递增排序，可以找到 k 个距离最近的电影。
假定 k=3，则三个最靠近的电影依次是， He's Not Really into Dudes 、 Beautiful Woman 和 California Man。
knn 算法按照距离最近的三部电影的类型，决定未知电影的类型，而这三部电影全是爱情片，因此我们判定未知电影是爱情片。
Principe KNN
Comment fonctionne KNN
- Supposons qu'il existe un exemple d'ensemble de données étiqueté (ensemble d'échantillons d'entraînement), qui contient la correspondance entre chaque élément de données et sa catégorie.
- Après avoir saisi de nouvelles données sans étiquettes, comparez chaque caractéristique des nouvelles données avec la caractéristique correspondante des données de l'ensemble d'échantillons.
- Calculez la distance entre les nouvelles données et chaque élément de données de l’exemple d’ensemble de données.
- Triez toutes les distances obtenues (de petite à grande, plus petite signifie plus similaire).
- Obtenez les étiquettes de classification correspondant aux k premiers échantillons de données (k est généralement inférieur ou égal à 20).
- Recherchez l'étiquette de classification qui apparaît le plus fréquemment parmi les k éléments de données comme classification des nouvelles données.
Compréhension populaire de KNN
Étant donné un ensemble de données d'entraînement, pour une nouvelle instance d'entrée, recherchez les k instances les plus proches de l'instance dans l'ensemble de données d'entraînement. Si la plupart de ces k instances appartiennent à une certaine classe, l'instance d'entrée est classée dans cette classe.
Processus de développement KNN
收集数据：任何方法
准备数据：距离计算所需要的数值，最好是结构化的数据格式
分析数据：任何方法
训练算法：此步骤不适用于 k-近邻算法
测试算法：计算错误率
使用算法：输入样本数据和结构化的输出结果，然后运行 k-近邻算法判断输入数据分类属于哪个分类，最后对计算出的分类执行后续处理
Caractéristiques de l'algorithme KNN
优点：精度高、对异常值不敏感、无数据输入假定
缺点：计算复杂度高、空间复杂度高
适用数据范围：数值型和标称型
Cas du projet KNN
Cas de projet 1 : Optimiser l’effet de correspondance des sites de rencontres
Aperçu du projet
Helen utilise un site de rencontres pour trouver un rendez-vous. Après un certain temps, elle a découvert qu'elle était sortie avec trois types de personnes :
- les gens qui n'aiment pas
- personne charmante et médiocre
- Personne très charmante
Elle espère:
- Rendez-vous en semaine avec des personnes moyennement attirantes
- Rendez-vous du week-end avec une personne très attirante
- Ceux qui n’apprécieront pas seront directement éliminés.
Elle a désormais collecté des données que les sites de rencontres n’enregistrent pas, ce qui peut aider à catégoriser les correspondances.
Processus de développement
收集数据：提供文本文件
准备数据：使用 Python 解析文本文件
分析数据：使用 Matplotlib 画二维散点图
训练算法：此步骤不适用于 k-近邻算法
测试算法：使用海伦提供的部分数据作为测试样本。
测试样本和非测试样本的区别在于：
测试样本是已经完成分类的数据，如果预测分类与实际类别不同，则标记为一个错误。
使用算法：产生简单的命令行程序，然后海伦可以输入一些特征数据以判断对方是否为自己喜欢的类型。
Collecter des données : fournir un fichier texte
Helen stocke les données de ces partenaires de rencontres dans le fichier texte datingTestSet2.txt , avec un total de 1 000 lignes. Les partenaires amoureux d’Helen comprennent principalement les trois caractéristiques suivantes :
- Miles de fidélisation gagnés par an
- Pourcentage de temps passé à jouer à des jeux vidéo
- Litres de glace consommés par semaine
Le format des données du fichier texte est le suivant :
40920 8.326976 0.953952 3
14488 7.153469 1.673904 2
26052 1.441871 0.805124 1
75136 13.147394 0.428964 1
38344 1.669788 0.134296 1
Préparation des données : analyse de fichiers texte à l'aide de Python
Analyseur pour convertir des enregistrements texte en NumPy
def file2matrix(filename):
"""
Desc:
导入训练数据
parameters:
filename: 数据文件路径
return:
数据矩阵 returnMat 和对应的类别 classLabelVector
"""
fr = open(filename)
# 获得文件中的数据行的行数
numberOfLines = len(fr.readlines())
# 生成对应的空矩阵
# 例如：zeros(2，3)就是生成一个 2*3的矩阵，各个位置上全是 0
returnMat = zeros((numberOfLines, 3)) # prepare matrix to return
classLabelVector = [] # prepare labels return
fr = open(filename)
index = 0
for line in fr.readlines():
# str.strip([chars]) --返回已移除字符串头尾指定字符所生成的新字符串
line = line.strip()
# 以 '\t' 切割字符串
listFromLine = line.split('\t')
# 每列的属性数据
returnMat[index, :] = listFromLine[0:3]
# 每列的类别数据，就是 label 标签数据
classLabelVector.append(int(listFromLine[-1]))
index += 1
# 返回数据矩阵returnMat和对应的类别classLabelVector
return returnMat, classLabelVector
Analyser les données : utilisez Matplotlib pour dessiner un nuage de points bidimensionnel
import matplotlib
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(datingDataMat[:, 0], datingDataMat[:, 1], 15.0*array(datingLabels), 15.0*array(datingLabels))
plt.show()
Dans la figure ci-dessous, les attributs de la première et de la deuxième colonne de la matrice sont utilisés pour obtenir un bon effet d'affichage. Trois zones de classification d'échantillons différentes sont clairement identifiées. Les personnes ayant des passe-temps différents ont également des zones de catégories différentes.
- Données normalisées (la normalisation est un processus visant à uniformiser les poids, veuillez vous référer à : https://www.zhihu.com/question/19951858 pour plus de détails )
| numéro de série | Pourcentage de temps passé à jouer à des jeux vidéo | Miles de fidélisation gagnés par an | Litres de glace consommés par semaine | Classement des échantillons |
|---|---|---|---|---|
| 1 | 0,8 | 400 | 0,5 | 1 |
| 2 | 12 | 134 000 | 0,9 | 3 |
| 3 | 0 | 20 000 | 1.1 | 2 |
| 4 | 67 | 32 000 | 0,1 | 2 |
La distance entre l'échantillon 3 et l'échantillon 4 :
( 0 − 67 ) 2 + ( 20000 − 32000 ) 2 + ( 1.1 − 0.1 ) 2 \sqrt{(0-67)^2 + (20000 − 32000)^2 + (1.1 - 0,1)^2 }( 0−6 7 )2+( 2 0 0 0 0−3 2 0 0 0 )2+( 1 . 1−0 . 1 )2
Normaliser les valeurs des caractéristiques pour éliminer l'influence causée par différentes ampleurs entre les caractéristiques
Définition de la normalisation : je pense que oui. La normalisation consiste à limiter les données que vous devez traiter (via un certain algorithme) à une certaine plage dont vous avez besoin. Tout d'abord, la normalisation vise à faciliter le traitement ultérieur des données, et deuxièmement, elle vise à accélérer la convergence lorsque le programme de correction est en cours d'exécution. Les méthodes sont les suivantes :
-
Conversion de fonction linéaire, l'expression est la suivante :
y = (x-ValeurMin)/(ValeurMax-ValeurMin)
Remarque : x et y sont respectivement les valeurs avant et après conversion, MaxValue et MinValue sont respectivement les valeurs maximale et minimale de l'échantillon.
-
Conversion de fonction logarithmique, l'expression est la suivante :
y=log10(x)
Description : Conversion de fonction logarithmique en base 10.
Comme le montre l'image :
-
Conversion de fonction cotangente inverse, l'expression est la suivante :
y=arctan(x)*2/PI
Comme le montre l'image :
- L'équation (1) convertit la valeur d'entrée en une valeur dans l'intervalle [-1,1] et utilise l'équation (2) au niveau de la couche de sortie pour la reconvertir à la valeur initiale, où et représentent les valeurs maximales et minimales. de la charge dans l’ensemble d’échantillons d’apprentissage respectivement.
En statistique, le rôle spécifique de la normalisation est de résumer la distribution statistique d'un échantillon unifié. La normalisation entre 0 et 1 est une distribution de probabilité statistique et la normalisation entre -1 et +1 est une distribution de coordonnées statistiques.
def autoNorm(dataSet):
"""
Desc:
归一化特征值，消除特征之间量级不同导致的影响
parameter:
dataSet: 数据集
return:
归一化后的数据集 normDataSet. ranges和minVals即最小值与范围，并没有用到
归一化公式：
Y = (X-Xmin)/(Xmax-Xmin)
其中的 min 和 max 分别是数据集中的最小特征值和最大特征值。该函数可以自动将数字特征值转化为0到1的区间。
"""
# 计算每种属性的最大值、最小值、范围
minVals = dataSet.min(0)
maxVals = dataSet.max(0)
# 极差
ranges = maxVals - minVals
normDataSet = zeros(shape(dataSet))
m = dataSet.shape[0]
# 生成与最小值之差组成的矩阵
normDataSet = dataSet - tile(minVals, (m, 1))
# 将最小值之差除以范围组成矩阵
normDataSet = normDataSet / tile(ranges, (m, 1)) # element wise divide
return normDataSet, ranges, minVals
Algorithme de formation : cette étape ne s'applique pas à l'algorithme du k-voisin le plus proche
Étant donné que les données de test doivent être comparées à chaque fois avec les données d’entraînement complètes, ce processus n’est pas nécessaire.
Pseudo-code de l'algorithme kNN :
对于每一个在数据集中的数据点：
计算目标的数据点（需要分类的数据点）与该数据点的距离
将距离排序：从小到大
选取前K个最短距离
选取这K个中最多的分类类别
返回该类别来作为目标数据点的预测值
def classify0(inX, dataSet, labels, k):
dataSetSize = dataSet.shape[0]
#距离度量 度量公式为欧氏距离
diffMat = tile(inX, (dataSetSize,1)) – dataSet
sqDiffMat = diffMat**2
sqDistances = sqDiffMat.sum(axis=1)
distances = sqDistances**0.5
#将距离排序：从小到大
sortedDistIndicies = distances.argsort()
#选取前K个最短距离， 选取这K个中最多的分类类别
classCount={
}
for i in range(k)：
voteIlabel = labels[sortedDistIndicies[i]]
classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
return sortedClassCount[0][0]
Algorithme de test : utilisez certaines des données fournies par Helen comme échantillons de test. Si la classe prédite diffère de la classe réelle, elle est marquée comme une erreur.
Code de test du classificateur kNN pour site de rencontres
def datingClassTest():
"""
Desc:
对约会网站的测试方法
parameters:
none
return:
错误数
"""
# 设置测试数据的的一个比例（训练数据集比例=1-hoRatio）
hoRatio = 0.1 # 测试范围,一部分测试一部分作为样本
# 从文件中加载数据
datingDataMat, datingLabels = file2matrix('db/2.KNN/datingTestSet2.txt') # load data setfrom file
# 归一化数据
normMat, ranges, minVals = autoNorm(datingDataMat)
# m 表示数据的行数，即矩阵的第一维
m = normMat.shape[0]
# 设置测试的样本数量， numTestVecs:m表示训练样本的数量
numTestVecs = int(m * hoRatio)
print 'numTestVecs=', numTestVecs
errorCount = 0.0
for i in range(numTestVecs):
# 对数据测试
classifierResult = classify0(normMat[i, :], normMat[numTestVecs:m, :], datingLabels[numTestVecs:m], 3)
print "the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLabels[i])
if (classifierResult != datingLabels[i]): errorCount += 1.0
print "the total error rate is: %f" % (errorCount / float(numTestVecs))
print errorCount
Utiliser un algorithme : générez un programme de ligne de commande simple, puis Helen peut saisir des données caractéristiques pour déterminer si l'autre partie est du type qu'elle aime.
Fonction de prédiction des sites de rencontres
def classifyPerson():
resultList = ['not at all', 'in small doses', 'in large doses']
percentTats = float(raw_input("percentage of time spent playing video games ?"))
ffMiles = float(raw_input("frequent filer miles earned per year?"))
iceCream = float(raw_input("liters of ice cream consumed per year?"))
datingDataMat, datingLabels = file2matrix('datingTestSet2.txt')
normMat, ranges, minVals = autoNorm(datingDataMat)
inArr = array([ffMiles, percentTats, iceCream])
classifierResult = classify0((inArr-minVals)/ranges,normMat,datingLabels, 3)
print "You will probably like this person: ", resultList[classifierResult - 1]
L'effet opérationnel réel est le suivant :
>>> classifyPerson()
percentage of time spent playing video games?10
frequent flier miles earned per year?10000
liters of ice cream consumed per year?0.5
You will probably like this person: in small doses
Cas de projet 2 : Système de reconnaissance de numéros manuscrits
Aperçu du projet
Construisez un système de reconnaissance de chiffres manuscrits basé sur le classificateur KNN capable de reconnaître les chiffres de 0 à 9.
Les nombres à reconnaître sont des images en noir et blanc stockées dans un fichier texte de même couleur et taille : la largeur et la hauteur sont de 32 pixels * 32 pixels.
Processus de développement
收集数据：提供文本文件。
准备数据：编写函数 img2vector(), 将图像格式转换为分类器使用的向量格式
分析数据：在 Python 命令提示符中检查数据，确保它符合要求
训练算法：此步骤不适用于 KNN
测试算法：编写函数使用提供的部分数据集作为测试样本，测试样本与非测试样本的
区别在于测试样本是已经完成分类的数据，如果预测分类与实际类别不同，
则标记为一个错误
使用算法：本例没有完成此步骤，若你感兴趣可以构建完整的应用程序，从图像中提取
数字，并完成数字识别，美国的邮件分拣系统就是一个实际运行的类似系统
Collecter des données : fournir un fichier texte
Le répertoire trainingDigits contient environ 2 000 exemples. Le contenu de chaque exemple est tel qu'illustré dans la figure ci-dessous. Chaque numéro contient environ 200 échantillons ; le répertoire testDigits contient environ 900 données de test.
Préparer les données : écrivez la fonction img2vector() pour convertir les données de texte d'image en vecteurs utilisés par le classificateur
Convertir les données de texte d'image en vecteur
def img2vector(filename):
returnVect = zeros((1,1024))
fr = open(filename)
for i in range(32):
lineStr = fr.readline()
for j in range(32):
returnVect[0,32*i+j] = int(lineStr[j])
return returnVect
Analyser les données : vérifiez les données dans l'invite de commande Python pour vous assurer qu'elles répondent aux exigences
Testez la fonction img2vector en saisissant la commande suivante sur la ligne de commande Python et comparez-la à un fichier ouvert dans un éditeur de texte :
>>> testVector = kNN.img2vector('testDigits/0_13.txt')
>>> testVector[0,0:32]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
>>> testVector[0,32:64]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
Algorithme de formation : cette étape ne s'applique pas à KNN
Étant donné que les données de test doivent être comparées à chaque fois avec les données d’entraînement complètes, ce processus n’est pas nécessaire.
Testez l'algorithme : écrivez une fonction qui utilise une partie de l'ensemble de données fourni comme échantillon de test et la signale comme une erreur si la classe prédite est différente de la classe réelle.
def handwritingClassTest():
# 1. 导入训练数据
hwLabels = []
trainingFileList = listdir('db/2.KNN/trainingDigits') # load the training set
m = len(trainingFileList)
trainingMat = zeros((m, 1024))
# hwLabels存储0～9对应的index位置， trainingMat存放的每个位置对应的图片向量
for i in range(m):
fileNameStr = trainingFileList[i]
fileStr = fileNameStr.split('.')[0] # take off .txt
classNumStr = int(fileStr.split('_')[0])
hwLabels.append(classNumStr)
# 将 32*32的矩阵->1*1024的矩阵
trainingMat[i, :] = img2vector('db/2.KNN/trainingDigits/%s' % fileNameStr)
# 2. 导入测试数据
testFileList = listdir('db/2.KNN/testDigits') # iterate through the test set
errorCount = 0.0
mTest = len(testFileList)
for i in range(mTest):
fileNameStr = testFileList[i]
fileStr = fileNameStr.split('.')[0] # take off .txt
classNumStr = int(fileStr.split('_')[0])
vectorUnderTest = img2vector('db/2.KNN/testDigits/%s' % fileNameStr)
classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)
print "the classifier came back with: %d, the real answer is: %d" % (classifierResult, classNumStr)
if (classifierResult != classNumStr): errorCount += 1.0
print "\nthe total number of errors is: %d" % errorCount
print "\nthe total error rate is: %f" % (errorCount / float(mTest))
Utilisation de l'algorithme : Cette étape n'est pas réalisée dans cet exemple. Si vous êtes intéressé, vous pouvez créer une application complète pour extraire des numéros à partir d'images et compléter la reconnaissance des numéros. Le système de tri du courrier aux États-Unis est un système similaire qui fonctionne réellement.
Résumé KNN
Qu’est-ce que KNN ? Définition : Apprentissage supervisé ? Un apprentissage non supervisé ?
KNN est un processus d'apprentissage simple non explicite et un modèle d'apprentissage supervisé sans généralisation. Il a des applications à la fois en classification et en régression.
Fondamental
Pour faire simple : calculez la distance entre le point de requête et chaque point de données d'entraînement grâce à la mesure de la distance, puis sélectionnez les K voisins les plus proches qui sont proches du point de requête (point de requête) et utilisez la prise de décision de classification pour sélectionner l'étiquette correspondante. comme étiquette du point de requête.
KNN trois éléments
K, la valeur de K
Cela a un impact significatif sur les étiquettes des points de requête (résultats exceptionnels). Lorsque la valeur k est petite, l’erreur d’approximation est faible et l’erreur d’estimation est grande. Lorsque la valeur k est grande, l’erreur d’approximation est grande et l’erreur d’estimation est petite.
Si vous choisissez une valeur k plus petite, cela équivaut à utiliser des instances d'entraînement dans un quartier plus petit pour la prédiction. L'erreur d'approximation de « l'apprentissage » sera réduite et seuls les exemples d'entraînement plus proches (similaires) de l'instance d'entrée seront créés. Les instances joueront un rôle dans les résultats de la prédiction. Mais l'inconvénient est que l'erreur d'estimation de « l'apprentissage » augmentera et les résultats de la prédiction seront très sensibles aux points d'instance proches. Si les points d'instance proches sont du bruit, la prédiction sera fausse. En d’autres termes, la réduction de la valeur k signifie que le modèle global devient complexe et sujet au surajustement.
Si vous choisissez une valeur k plus grande, cela équivaut à utiliser des instances d'entraînement dans un quartier plus grand pour faire des prédictions. L’avantage est que cela peut réduire l’erreur d’estimation de l’apprentissage. Mais l’inconvénient est que l’erreur d’approximation d’apprentissage va augmenter. À ce stade, les instances d'entraînement qui sont éloignées de l'instance d'entrée (différentes) affecteront également la prédiction, ce qui rendra la prédiction erronée. Une augmentation de la valeur k signifie que le modèle global devient plus simple.
Ni trop grand ni trop petit n'est bon. Vous pouvez utiliser la validation croisée pour sélectionner une valeur k appropriée.
Erreur d'approximation et erreur d'estimation, veuillez voir ici : https://www.zhihu.com/question/60793482
Mesure métrique/distance
La métrique de distance est généralement la distance euclidienne, mais elle peut également être la distance de Minkowski ou la distance de Manhattan. Il peut également s'agir d'une formule de distance dans l'espace géographique. (Pour plus de détails, veuillez vous référer à la section valid_metric dans sklearn)
décision de classification (règle de décision)
Dans les problèmes de classification, la décision de classification consiste généralement à sélectionner l'étiquette avec le plus de votes par règle majoritaire. Dans les problèmes de régression, il s'agit généralement de la moyenne des étiquettes des K voisins les plus proches.
Algorithme : (il existe trois types sur sklearn)
Calcul de force brute Brute Force/analyse linéaire
KD Tree utilise un arbre binaire pour diviser l'espace des paramètres en fonction des dimensions des données.
Ball Tree utilise une série d'hypersphères pour diviser en deux l'ensemble de données d'entraînement.
Les algorithmes de structure arborescente ont deux processus : la construction d’arborescence et l’interrogation. Brute Force n'a pas de processus de construction.
Caractéristiques de l'algorithme :
优点 : Haute précision, aucune hypothèse sur les données, non sensible aux valeurs aberrantes
Inconvénients : complexité temporelle et spatiale élevée
Champ d'application : valeurs continues et valeurs nominales
Produits homologues similaires :
voisins de rayon Rechercher des voisins en fonction du rayon spécifié
Facteurs affectant l'algorithme :
N est le nombre d'échantillons dans l'ensemble de données, D est la dimension des données (nombre d'entités)
Consommation totale :
Force brute : O[DN^2]
Ce qui est considéré ici est la méthode la plus stupide : compter les distances entre tous les points d’entraînement. Bien sûr, il existe des implémentations plus rapides, telles que O(ND + kN) et O(NDK), et la plus rapide est O[DN]. Si vous êtes intéressé, vous pouvez lire ce lien : complexité computationnelle k-NN
Arbre KD : O[DN log(N)]
Ball Tree : O[DN log(N)] est du même ordre de grandeur que KD Tree. Bien que le temps de construction de l'arbre soit plus long que KD Tree, la vitesse de requête est grandement améliorée dans les données hautement structurées, même dans les données de haute latitude. .promouvoir.
Interroger la consommation requise :
Force brute : O[DN]
Arbre KD : lorsque la dimension est relativement petite, comme D<20, O[Dlog(N)]. Au contraire, il aura tendance à O[DN]
Arbre à billes : O[Dlog(N)]
Lorsque l'ensemble de données est relativement petit, tel que N <30, Brute Force présente plus d'avantages.
Dimensionnalité intrinsèque et parcimonie
La dimensionnalité intrinsèque des données fait référence à la dimension d < D de la variété où se trouvent les données, qui peut être linéaire ou non linéaire dans l'espace des paramètres. La parcimonie fait référence au degré auquel les données remplissent l'espace des paramètres (ceci est différent du concept utilisé dans les matrices « clairsemées », une matrice de données peut ne pas avoir zéro entrée, mais en ce sens, sa structure est toujours « clairsemée »).
Les temps de requête pour Brute Force ne sont pas affectés.
Pour le temps de requête de KD Tree et Ball Tree, le temps de requête des ensembles de données avec des dimensions intrinsèques plus petites et plus clairsemées est plus rapide. L'amélioration de KD Tree n'est pas aussi significative que celle de Ball Tree en raison de ses propres caractéristiques de division en deux de l'espace des paramètres via l'axe de coordonnées.
La valeur de k (k points voisins)
Le temps de requête de Brute Force n’est pratiquement pas affecté.
Mais pour KD Tree et Ball Tree, plus k est grand, plus le temps de requête est lent.
k Lorsque N représente une proportion importante, il est préférable d'utiliser la Force Brute.
Nombre de points de requête (nombre de points de requête, c'est-à-dire le nombre de données de test)
Brute Force est utilisé lorsqu'il y a peu de points de requête. Lorsqu’il existe de nombreux points de requête, l’algorithme de structure arborescente peut être utilisé.
Quelques informations supplémentaires sur les modèles dans sklearn :
Si les scénarios d'application de KD Tree, Ball Tree et Brute Force ne sont pas clairs, vous pouvez directement utiliser le module contenant algorithm='auto'. algorithm='auto' sélectionne automatiquement l'algorithme optimal pour vous.
Vous avez le choix entre un régresseur et un classificateur.
La mesure métrique/distance est facultative. De plus, la distance peut être pondérée en poids.
L'impact de la taille des feuilles sur l'arbre KD et l'arbre à boules
Temps d'établissement de l'arbre : lorsque la taille des feuilles est plus grande, le temps d'établissement de l'arbre sera plus rapide.
Temps de requête : la taille des feuilles n’est pas bonne si elles sont trop grandes ou trop petites. Si la taille de la feuille tend vers N (le nombre d'échantillons dans les données d'entraînement), l'algorithme est en réalité une force brute. Si la taille des feuilles est trop petite, tendant vers 1, alors le temps nécessaire pour parcourir l'arbre pendant la requête sera considérablement augmenté. La valeur recommandée pour la taille des feuilles est 30, qui est la valeur par défaut.
Mémoire : la taille des feuilles devient plus grande et la mémoire pour stocker la structure arborescente devient plus petite.
Classificateur centroïde le plus proche
La décision de classification dépend du centre de gravité de l'étiquette qui est le plus proche du point de test et de l'étiquette sélectionnée.
Le modèle suppose une variance égale dans toutes les dimensions. C'est une bonne ligne de base.
Version avancée : centroïde rétréci le plus proche
Peut être défini via Shrink_threshold.
Fonction : peut supprimer certaines fonctionnalités qui affectent la classification, telles que la suppression de l'impact des fonctionnalités de bruit.
- Les informations de référence proviennent d' ApacheCN