El Algoritmo K-vecinos más cercanos (KNN) es un método de aprendizaje automático supervisado que se emplea para abordar problemas de clasificación y regresión. Evelyn Fix y Joseph Hodges desarrollaron este algoritmo en 1951, que posteriormente fue ampliado por Thomas Cover. El artículo explora los fundamentos, el funcionamiento y la implementación del algoritmo KNN.
¿Qué es el algoritmo K-vecinos más cercanos?
KNN es uno de los algoritmos de clasificación más básicos pero esenciales en el aprendizaje automático. pertenece a la aprendizaje supervisado dominio y encuentra una intensa aplicación en el reconocimiento de patrones, Es ampliamente desechable en escenarios de la vida real ya que no es paramétrico, lo que significa que no hace suposiciones subyacentes sobre la distribución de datos (a diferencia de otros algoritmos como GMM, que asumen una distribución gaussiana de los datos proporcionados). Se nos proporcionan algunos datos previos (también llamados datos de entrenamiento), que clasifican las coordenadas en grupos identificados por un atributo.
convertir de char a int java
Como ejemplo, considere la siguiente tabla de puntos de datos que contienen dos características:
Visualización de trabajo del algoritmo KNN
Ahora, dado otro conjunto de puntos de datos (también llamados datos de prueba), asigne estos puntos a un grupo analizando el conjunto de entrenamiento. Tenga en cuenta que los puntos no clasificados están marcados como 'Blancos'.
Intuición detrás del algoritmo KNN
Si trazamos estos puntos en un gráfico, es posible que podamos localizar algunos conglomerados o grupos. Ahora, dado un punto no clasificado, podemos asignarlo a un grupo observando a qué grupo pertenecen sus vecinos más cercanos. Esto significa que un punto cercano a un grupo de puntos clasificados como 'Rojo' tiene una mayor probabilidad de ser clasificado como 'Rojo'.
Intuitivamente, podemos ver que el primer punto (2.5, 7) debe clasificarse como “Verde” y el segundo punto (5.5, 4.5) debe clasificarse como “Rojo”.
¿Por qué necesitamos un algoritmo KNN?
(K-NN) es un algoritmo de aprendizaje automático versátil y ampliamente utilizado que se utiliza principalmente por su simplicidad y facilidad de implementación. No requiere ninguna suposición sobre la distribución de datos subyacente. También puede manejar datos tanto numéricos como categóricos, lo que lo convierte en una opción flexible para varios tipos de conjuntos de datos en tareas de clasificación y regresión. Es un método no paramétrico que realiza predicciones basadas en la similitud de puntos de datos en un conjunto de datos determinado. K-NN es menos sensible a los valores atípicos en comparación con otros algoritmos.
El algoritmo K-NN funciona encontrando los K vecinos más cercanos a un punto de datos determinado en función de una métrica de distancia, como la distancia euclidiana. La clase o valor del punto de datos se determina luego por el voto mayoritario o el promedio de los K vecinos. Este enfoque permite que el algoritmo se adapte a diferentes patrones y realice predicciones basadas en la estructura local de los datos.
Métricas de distancia utilizadas en el algoritmo KNN
Como sabemos, el algoritmo KNN nos ayuda a identificar los puntos o grupos más cercanos para un punto de consulta. Pero para determinar los grupos más cercanos o los puntos más cercanos para un punto de consulta necesitamos alguna métrica. Para ello, utilizamos las siguientes métricas de distancia:
Distancia euclidiana
Esto no es más que la distancia cartesiana entre los dos puntos que están en el plano/hiperplano. distancia euclidiana También se puede visualizar como la longitud de la línea recta que une los dos puntos que se consideran. Esta métrica nos ayuda a calcular el desplazamiento neto realizado entre los dos estados de un objeto.
![ext{distancia}(x, X_i) = sqrt{sum_{j=1}^{d} (x_j - X_{i_j})^2} ]](http://techcodeview.com/img/directi/44/k-nearest-neighbor-algorithm-2.webp)
Distancia de Manhattan
Distancia de Manhattan La métrica se utiliza generalmente cuando nos interesa la distancia total recorrida por el objeto en lugar del desplazamiento. Esta métrica se calcula sumando la diferencia absoluta entre las coordenadas de los puntos en n dimensiones.
Distancia de Minkowski
Podemos decir que la distancia euclidiana, así como la distancia de Manhattan, son casos especiales de la distancia de Minkowski .
De la fórmula anterior podemos decir que cuando p = 2 entonces es la misma que la fórmula para la distancia euclidiana y cuando p = 1 entonces obtenemos la fórmula para la distancia de Manhattan.
Las métricas discutidas anteriormente son más comunes cuando se trata de un Aprendizaje automático problema, pero también hay otras métricas de distancia como Distancia de Hamming lo cual resulta útil al abordar problemas que requieren comparaciones superpuestas entre dos vectores cuyo contenido puede ser tanto booleano como valores de cadena.
¿Cómo elegir el valor de k para el algoritmo KNN?
El valor de k es muy crucial en el algoritmo KNN para definir el número de vecinos en el algoritmo. El valor de k en el algoritmo de k vecinos más cercanos (k-NN) debe elegirse en función de los datos de entrada. Si los datos de entrada tienen más valores atípicos o ruido, sería mejor un valor más alto de k. Se recomienda elegir un valor impar para k para evitar empates en la clasificación. Validación cruzada Los métodos pueden ayudar a seleccionar el mejor valor k para el conjunto de datos dado.
Funcionamiento del algoritmo KNN
El algoritmo K-Vecinos más cercanos (KNN) opera según el principio de similitud, donde predice la etiqueta o el valor de un nuevo punto de datos considerando las etiquetas o valores de sus K vecinos más cercanos en el conjunto de datos de entrenamiento.
A continuación se explica paso a paso cómo funciona KNN:
Paso 1: Seleccionar el valor óptimo de K
- K representa el número de vecinos más cercanos que deben considerarse al realizar la predicción.
Paso 2: Calcular la distancia
- Para medir la similitud entre los puntos de datos objetivo y de entrenamiento, se utiliza la distancia euclidiana. La distancia se calcula entre cada uno de los puntos de datos en el conjunto de datos y el punto objetivo.
Paso 3: encontrar vecinos más cercanos
- Los k puntos de datos con las distancias más pequeñas al punto objetivo son los vecinos más cercanos.
Paso 4: Votar por la clasificación o tomar el promedio para la regresión
- En el problema de clasificación, las etiquetas de clase se determinan mediante votación mayoritaria. La clase con más apariciones entre los vecinos se convierte en la clase prevista para el punto de datos de destino.
- En el problema de regresión, la etiqueta de clase se calcula tomando el promedio de los valores objetivo de K vecinos más cercanos. El valor promedio calculado se convierte en la salida prevista para el punto de datos objetivo.
Sea X el conjunto de datos de entrenamiento con n puntos de datos, donde cada punto de datos está representado por un vector de características d-dimensional 
e Y sean las etiquetas o valores correspondientes para cada punto de datos en X. Dado un nuevo punto de datos x, el algoritmo calcula la distancia entre x y cada punto de datos en X usando una métrica de distancia, como la distancia euclidiana:
El algoritmo selecciona los K puntos de datos de X que tienen las distancias más cortas a x. Para tareas de clasificación, el algoritmo asigna la etiqueta y que es más frecuente entre los K vecinos más cercanos a x. Para tareas de regresión, el algoritmo calcula el promedio o promedio ponderado de los valores y de los K vecinos más cercanos y lo asigna como el valor predicho para x.
Ventajas del algoritmo KNN
- Fácil de implementar ya que la complejidad del algoritmo no es tan alta.
- Se adapta fácilmente – Según el funcionamiento del algoritmo KNN, almacena todos los datos en la memoria y, por lo tanto, cada vez que se agrega un nuevo ejemplo o punto de datos, el algoritmo se ajusta según ese nuevo ejemplo y también contribuye a las predicciones futuras.
- Pocos hiperparámetros – Los únicos parámetros que se requieren en el entrenamiento de un algoritmo KNN son el valor de k y la elección de la métrica de distancia que nos gustaría elegir de nuestra métrica de evaluación.
Desventajas del algoritmo KNN
- No escala – Como hemos oído hablar de esto, el algoritmo KNN también se considera un algoritmo perezoso. El significado principal de este término es que requiere mucha potencia informática y almacenamiento de datos. Esto hace que este algoritmo consuma mucho tiempo y agote los recursos.
- Maldición de dimensionalidad – Existe un término conocido como fenómeno de pico según este, el algoritmo KNN se ve afectado por el maldición de dimensionalidad lo que implica que el algoritmo enfrenta dificultades para clasificar correctamente los puntos de datos cuando la dimensionalidad es demasiado alta.
- Propenso al sobreajuste – Como el algoritmo se ve afectado debido a la maldición de la dimensionalidad, también es propenso al problema de sobreajuste. Por lo tanto, generalmente selección de características así como reducción de dimensionalidad Se aplican técnicas para abordar este problema.
Programa de ejemplo:
alinear imagen css
Suponga 0 y 1 como los dos clasificadores (grupos).
C++
// C++ program to find groups of unknown> // Points using K nearest neighbour algorithm.> #include> using> namespace> std;> struct> Point> {> >int> val;>// Group of point> >double> x, y;>// Co-ordinate of point> >double> distance;>// Distance from test point> };> // Used to sort an array of points by increasing> // order of distance> bool> comparison(Point a, Point b)> {> >return> (a.distance } // This function finds classification of point p using // k nearest neighbour algorithm. It assumes only two // groups and returns 0 if p belongs to group 0, else // 1 (belongs to group 1). int classifyAPoint(Point arr[], int n, int k, Point p) { // Fill distances of all points from p for (int i = 0; i arr[i].distance = sqrt((arr[i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y)); // Sort the Points by distance from p sort(arr, arr+n, comparison); // Now consider the first k elements and only // two groups int freq1 = 0; // Frequency of group 0 int freq2 = 0; // Frequency of group 1 for (int i = 0; i { if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return (freq1>frecuencia2? 0: 1); } // Código del controlador int main() { int n = 17; // Número de puntos de datos Point arr[n]; arreglo[0].x = 1; arreglo[0].y = 12; llegada[0].val = 0; arreglo[1].x = 2; arreglo[1].y = 5; llegada[1].val = 0; arreglo[2].x = 5; arreglo[2].y = 3; llegada[2].val = 1; arreglo[3].x = 3; arreglo[3].y = 2; llegada[3].val = 1; arreglo[4].x = 3; arreglo[4].y = 6; llegada[4].val = 0; arreglo[5].x = 1,5; arreglo[5].y = 9; llegada[5].val = 1; arreglo[6].x = 7; arreglo[6].y = 2; llegada[6].val = 1; arreglo[7].x = 6; arreglo[7].y = 1; llegada[7].val = 1; arreglo[8].x = 3,8; arreglo[8].y = 3; llegada[8].val = 1; arreglo[9].x = 3; arreglo[9].y = 10; llegada[9].val = 0; arreglo[10].x = 5,6; arreglo[10].y = 4; llegada[10].val = 1; arreglo[11].x = 4; arreglo[11].y = 2; llegada[11].val = 1; arreglo[12].x = 3,5; arreglo[12].y = 8; llegada[12].val = 0; arreglo[13].x = 2; arreglo[13].y = 11; llegada[13].val = 0; arreglo[14].x = 2; arreglo[14].y = 5; llegada[14].val = 1; arreglo[15].x = 2; arreglo[15].y = 9; llegada[15].val = 0; arreglo[16].x = 1; arreglo[16].y = 7; llegada[16].val = 0; /*Punto de prueba*/ Punto p; p.x = 2,5; p.y = 7; // Parámetro para decidir el grupo del punto de prueba int k = 3; printf ('El valor clasificado en punto desconocido' ' es %d.
', classifyAPoint(arr, n, k, p)); devolver 0; }> |
>
>
Java
// Java program to find groups of unknown> // Points using K nearest neighbour algorithm.> import> java.io.*;> import> java.util.*;> class> GFG {> >static> class> Point {> >int> val;>// Group of point> >double> x, y;>// Co-ordinate of point> >double> distance;>// Distance from test point> >}> >// Used to sort an array of points by increasing> >// order of distance> >static> class> comparison>implements> Comparator {> >public> int> compare(Point a, Point b)> >{> >if> (a.distance return -1; else if (a.distance>b.distancia) regresar 1; devolver 0; } } // Esta función encuentra la clasificación del punto p usando // k algoritmo del vecino más cercano. Asume solo dos // grupos y devuelve 0 si p pertenece al grupo 0, en caso contrario // 1 (pertenece al grupo 1). static int classifyAPoint(Point arr[], int n, int k, Point p) { // Rellena las distancias de todos los puntos desde p for (int i = 0; i arr[i].distance = Math.sqrt( (arr[ i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y) // Ordenar los puntos por distancia desde p Arrays.sort(arr, new compare()); // Ahora considere los primeros k elementos y solo // dos grupos int freq1 = 0 // Frecuencia del grupo 0 int freq2 = 0; (int i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return (freq1> freq2 ? 0 : 1); } / / Código del controlador public static void main(String[] args) { int n = 17 // Número de puntos de datos Point[] arr = new Point[n];<17; i++) { arr[i] = new Point(); } arr[0].x = 1; arr[0].y = 12; arr[0].val = 0; arr[1].x = 2; arr[1].y = 5; arr[1].val = 0; arr[2].x = 5; arr[2].y = 3; arr[2].val = 1; arr[3].x = 3; arr[3].y = 2; arr[3].val = 1; arr[4].x = 3; arr[4].y = 6; arr[4].val = 0; arr[5].x = 1.5; arr[5].y = 9; arr[5].val = 1; arr[6].x = 7; arr[6].y = 2; arr[6].val = 1; arr[7].x = 6; arr[7].y = 1; arr[7].val = 1; arr[8].x = 3.8; arr[8].y = 3; arr[8].val = 1; arr[9].x = 3; arr[9].y = 10; arr[9].val = 0; arr[10].x = 5.6; arr[10].y = 4; arr[10].val = 1; arr[11].x = 4; arr[11].y = 2; arr[11].val = 1; arr[12].x = 3.5; arr[12].y = 8; arr[12].val = 0; arr[13].x = 2; arr[13].y = 11; arr[13].val = 0; arr[14].x = 2; arr[14].y = 5; arr[14].val = 1; arr[15].x = 2; arr[15].y = 9; arr[15].val = 0; arr[16].x = 1; arr[16].y = 7; arr[16].val = 0; /*Testing Point*/ Point p = new Point(); p.x = 2.5; p.y = 7; // Parameter to decide group of the testing point int k = 3; System.out.println( 'The value classified to unknown point is ' + classifyAPoint(arr, n, k, p)); } } // This code is contributed by Karandeep1234> |
>
>
Python3
import> math> def> classifyAPoint(points,p,k>=>3>):> >'''> >This function finds the classification of p using> >k nearest neighbor algorithm. It assumes only two> >groups and returns 0 if p belongs to group 0, else> >1 (belongs to group 1).> >Parameters -> >points: Dictionary of training points having two keys - 0 and 1> >Each key have a list of training data points belong to that> >p : A tuple, test data point of the form (x,y)> >k : number of nearest neighbour to consider, default is 3> >'''> >distance>=>[]> >for> group>in> points:> >for> feature>in> points[group]:> >#calculate the euclidean distance of p from training points> >euclidean_distance>=> math.sqrt((feature[>0>]>->p[>0>])>*>*>2> +>(feature[>1>]>->p[>1>])>*>*>2>)> ># Add a tuple of form (distance,group) in the distance list> >distance.append((euclidean_distance,group))> ># sort the distance list in ascending order> ># and select first k distances> >distance>=> sorted>(distance)[:k]> >freq1>=> 0> #frequency of group 0> >freq2>=> 0> #frequency og group 1> >for> d>in> distance:> >if> d[>1>]>=>=> 0>:> >freq1>+>=> 1> >elif> d[>1>]>=>=> 1>:> >freq2>+>=> 1> >return> 0> if> freq1>frecuencia2>else> 1> # driver function> def> main():> ># Dictionary of training points having two keys - 0 and 1> ># key 0 have points belong to class 0> ># key 1 have points belong to class 1> >points>=> {>0>:[(>1>,>12>),(>2>,>5>),(>3>,>6>),(>3>,>10>),(>3.5>,>8>),(>2>,>11>),(>2>,>9>),(>1>,>7>)],> >1>:[(>5>,>3>),(>3>,>2>),(>1.5>,>9>),(>7>,>2>),(>6>,>1>),(>3.8>,>1>),(>5.6>,>4>),(>4>,>2>),(>2>,>5>)]}> ># testing point p(x,y)> >p>=> (>2.5>,>7>)> ># Number of neighbours> >k>=> 3> >print>(>'The value classified to unknown point is: {}'>.> >format>(classifyAPoint(points,p,k)))> if> __name__>=>=> '__main__'>:> >main()> |
>
>
C#
using> System;> using> System.Collections;> using> System.Collections.Generic;> using> System.Linq;> // C# program to find groups of unknown> // Points using K nearest neighbour algorithm.> class> Point {> >public> int> val;>// Group of point> >public> double> x, y;>// Co-ordinate of point> >public> int> distance;>// Distance from test point> }> class> HelloWorld {> >// This function finds classification of point p using> >// k nearest neighbour algorithm. It assumes only two> >// groups and returns 0 if p belongs to group 0, else> >// 1 (belongs to group 1).> >public> static> int> classifyAPoint(List arr,>int> n,>int> k, Point p)> >{> >// Fill distances of all points from p> >for> (>int> i = 0; i arr[i].distance = (int)Math.Sqrt((arr[i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y)); // Sort the Points by distance from p arr.Sort(delegate(Point x, Point y) { return x.distance.CompareTo(y.distance); }); // Now consider the first k elements and only // two groups int freq1 = 0; // Frequency of group 0 int freq2 = 0; // Frequency of group 1 for (int i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return (freq1>frecuencia2? 0: 1); } static void Principal() { int n = 17; // Número de puntos de datos Lista arr = new List(); for(int i = 0; i arr.Add(new Point()); } arr[0].x = 1; arr[0].y = 12; arr[0].val = 0; arr[1] .x = 2; arreglo[1].y = 5; arreglo[1].val = 0; arreglo[2].x = 5; arreglo[2].y = 3; matriz[3].x = 3; matriz[3].y = 2; matriz[4].x = 3; matriz[4].y = 6; valor = 0; arreglo[5].x = 1,5; arreglo[5].y = 9; arreglo[5].x = 7; [6].val = 1; arreglo[7].x = 6; arreglo[7].y = 1; arreglo[8].x = 3.8; = 3; arreglo[8].val = 1; arreglo[9].x = 3; arreglo[9].y = 10; arreglo[9].x = 5.6; 10].y = 4; arr[10].val = 1; arr[11].x = 4; arr[11].val = 1; 3.5; arreglo[12].y = 8; arreglo[12].val = 0; arreglo[13].y = 11; arreglo[13].x = 2; arreglo[13].y = 11; ].x = 2; arreglo[14].y = 5; arreglo[14].val = 1; arreglo[15].x = 0; ; arr[16].x = 1; arr[16].y = 7; arr[16].val = 0; /*Punto de prueba*/ Punto p = nuevo punto(); // Parámetro para decidir el grupo del punto de prueba int k = 3; Console.WriteLine('El valor clasificado en un punto desconocido es ' + classifyAPoint(arr, n, k, p)); } } // El código es aportado por Nidhi goel.> |
>
>
JavaScript
class Point {> >constructor(val, x, y, distance) {> >this>.val = val;>// Group of point> >this>.x = x;>// X-coordinate of point> >this>.y = y;>// Y-coordinate of point> >this>.distance = distance;>// Distance from test point> >}> }> // Used to sort an array of points by increasing order of distance> class Comparison {> >compare(a, b) {> >if> (a.distance return -1; } else if (a.distance>b.distancia) { return 1; } devolver 0; } } // Esta función encuentra la clasificación del punto p usando // k algoritmo del vecino más cercano. Asume solo dos // grupos y devuelve 0 si p pertenece al grupo 0, en caso contrario // 1 (pertenece al grupo 1). function classifyAPoint(arr, n, k, p) { // Rellena las distancias de todos los puntos desde p for (let i = 0; i arr[i].distance = Math.sqrt((arr[i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y) } // Ordenar los puntos por distancia desde p arr.sort(new) Comparación()); // Ahora considere los primeros k elementos y solo dos grupos let freq1 = 0; // Frecuencia del grupo 0 let freq2 = 0 // Frecuencia del grupo 1 for (let i = 0; i if (arr; [i].val === 0) { freq1++; else if (arr[i].val === 1) { freq2++ } } return freq1> freq2 ? 17; // Número de puntos de datos const arr = new Array(n);<17; i++) { arr[i] = new Point(); } arr[0].x = 1; arr[0].y = 12; arr[0].val = 0; arr[1].x = 2; arr[1].y = 5; arr[1].val = 0; arr[2].x = 5; arr[2].y = 3; arr[2].val = 1; arr[3].x = 3; arr[3].y = 2; arr[3].val = 1; arr[4].x = 3; arr[4].y = 6; arr[4].val = 0; arr[5].x = 1.5; arr[5].y = 9; arr[5].val = 1; arr[6].x = 7; arr[6].y = 2; arr[6].val = 1; arr[7].x = 6; arr[7].y = 1; arr[7].val = 1; arr[8].x = 3.8; arr[8].y = 3; arr[8].val = 1; arr[9].x = 3; arr[9].y = 10; arr[9].val = 0; arr[10].x = 5.6; arr[10].y = 4; arr[10].val = 1; arr[11].x = 4 arr[11].y = 2; arr[11].val = 1; arr[12].x = 3.5; arr[12].y = 8; arr[12].val = 0; arr[13].x = 2; arr[13].y = 11; arr[13].val = 0; arr[14].x = 2; arr[14].y = 5; arr[14].val = 1; arr[15].x = 2; arr[15].y = 9; arr[15].val = 0; arr[16].x = 1; arr[16].y = 7; arr[16].val = 0; // Testing Point let p = { x: 2.5, y: 7, val: -1, // uninitialized }; // Parameter to decide group of the testing point let k = 3; console.log( 'The value classified to unknown point is ' + classifyAPoint(arr, n, k, p) ); function classifyAPoint(arr, n, k, p) { // Fill distances of all points from p for (let i = 0; i arr[i].distance = Math.sqrt( (arr[i].x - p.x) * (arr[i].x - p.x) + (arr[i].y - p.y) * (arr[i].y - p.y) ); } // Sort the Points by distance from p arr.sort(function (a, b) { if (a.distance return -1; else if (a.distance>b.distancia) regresar 1; devolver 0; }); // Ahora considere los primeros k elementos y solo dos grupos let freq1 = 0; // Frecuencia del grupo 0 let freq2 = 0; // Frecuencia del grupo 1 for (let i = 0; i if (arr[i].val == 0) freq1++; else if (arr[i].val == 1) freq2++; } return freq1> freq2 ? 0 : 1; }> |
>
>
Producción:
The value classified as an unknown point is 0.>
Complejidad del tiempo: O(norte * registronorte)
Espacio Auxiliar: O(1)
Aplicaciones del algoritmo KNN
- Preprocesamiento de datos – Al abordar cualquier problema de aprendizaje automático, primero realizamos la Imputación KNN lo cual es bastante efectivo y generalmente se usa para metodologías de imputación sofisticadas.
- Reconocimiento de patrones – Los algoritmos KNN funcionan muy bien si entrenó un algoritmo KNN utilizando el conjunto de datos MNIST y luego realizó el proceso de evaluación, entonces debe haberse encontrado con el hecho de que la precisión es demasiado alta.
- Motores de recomendación – La tarea principal que realiza un algoritmo KNN es asignar un nuevo punto de consulta a un grupo preexistente que se ha creado utilizando un enorme corpus de conjuntos de datos. Esto es exactamente lo que se requiere en el K vecinos más cercanos con Python | ml
- Implementación de K-vecinos más cercanos desde cero usando Python
- Explicación matemática del vecino K-más cercano
- K-NN ponderado
Preguntas frecuentes (FAQ)
P. ¿Por qué KNN aprende con pereza?
El algoritmo KNN no construye un modelo durante la fase de entrenamiento. El algoritmo almacena todo el conjunto de datos de entrenamiento y realiza acciones sobre el conjunto de datos en el momento de la clasificación.
P. ¿Por qué KNN no es paramétrico?
El algoritmo KNN no hace suposiciones sobre los datos que analiza.
P. ¿Cuál es la diferencia entre KNN y K significa?
- KNN es un modelo de aprendizaje automático supervisado que se utiliza para problemas de clasificación, mientras que K-means es un modelo de aprendizaje automático no supervisado que se utiliza para la agrupación.
- K en KNN es el número de vecinos más cercanos, mientras que K en K significa es el número de clústeres.