In a KNN algorithm, a test sample is given as the class of majority of its nearest neighbours. In plain words, if you are similar to your neighbours, then you are one of them. Or if apple looks more similar to banana, orange, and melon (fruits) than monkey, cat and rat (animals), then most likely apple is a fruit. Below is an example, we have three classes and the goal is to find a class label for the unknown example [math]x_j [/math]. In this cas,e we use the Euclidean distance and a value of k=5 neighbors. Of the 5 closest neighbors, 4 belong to [math] \omega_1[/math] and 1 belongs to [math] \omega_3[/math], so [math]x_j [/math] is assigned to [math] \omega_1[/math], the predominant class. The choice of k is a hyper-parameter that can be tuned or set heuristically.

(Source - Tecniche non parametriche)

Risposta tratta da La risposta di Shehroz Khan a Qual è la differenza tra un algoritmo KNN e un algoritmo k-means?

Sì. Ridimensionare le tue variabili equivale a usare una norma diversa, e kNN è molto sensibile alla tua scelta della norma.

Come linea di base forte raccomando

Naive Bayes

dopo aver creato una linea di base puoi provare

XGBoost,

Logistic Regression,

LSTM,

Bidirection LSTM (GRU)

Naturalmente è necessario prima preprocessare il testo - fare la pulizia del testo poi cambiare il testo in vettore - per la linea di base tfidf o countvectorizer per algoritmi più avanzati come LSTM (DNN) embedding come word2vec, glove, fasttext

Mi sono documentato su MUSIC di recente, e ho scoperto che è un uso brillante della decomposizione degli autovalori. Spiegherò un caso d'uso: la stima della frequenza sinusoidale.

Supponiamo di avere un segnale composto da una somma di sinusoidi (diciamo r) più un certo rumore (w(n)), che deve essere strettamente indipendente dal segnale. Avete M campioni di questo segnale, cioè n = 0,1,2,...M-1.

[math]x(n) = \sum_{i=1}^{r}A_i\exp(j\omega_in + \phi_i) + w(n) [/math]

Se si fa una decomposizione degli autovalori su questa matrice di covarianza di questo segnale ([math]\in \mathbb{R}^{M \times M}[/math]) gli autovalori più grandi r rappresentano gli autovettori che abbracciano il sottospazio del segnale + rumore, e i rimanenti abbracciano solo il sottospazio del rumore. Ricordate che gli autovettori sono tutti ortogonali in questo caso.

Ora formulate una funzione come questa:

[math]P(\\omega) =frac{1}{sum_{i=r+1}^{M}|\mathbf{a(\omega)}^H\mathbf{q_i}|^2}[/math]

[math]\mathbf{a}(\omega) = [1, e^{j\omega}, e^{2j\omega} \cdots e^{(M-1)j\omega}]^T[/math]

e [math]\mathbf{q_i}[/math] sono gli ultimi M-r autovettori, cioèe., gli autovettori che coprono solo il sottospazio del rumore. Siccome sappiamo che questi autovettori sono ortogonali al segnale, per tutti quei [math]\omega[/math] che sono effettivamente presenti nel segnale ([math]\omega_i'[/math]s), la funzione [math]P(\omega)[/math] dovrebbe essere teoricamente infinita (la proiezione di [math]\mathbf{a}(\omega)[/math]su [math]\mathbf{q_i}[/math]'s dovrebbe essere zero).

Quindi, si cerca su un intervallo di frequenze, e si cercano i picchi nella funzione [math]P(\omega)[/math] per stimare le frequenze presenti nel vostro segnale. La risoluzione è migliore di quella della FFT, e l'algoritmo è robusto in presenza di rumore. Tuttavia, è molto più costoso computazionalmente ([math]O(N^3)[/math] contro [math]O(Nlog_2N)[/math] per la FFT).

A comprehensive answer here is almost impossible. Actually, I am pretty certain that very few experts can provide you with an in-depth list of possible algorithms, as most will be specialized in one or two particular classes. Here is a nice starting point:

[1] Do we need hundreds of classifiers to solve real world classification problems?

This is an investigation as to whether some classification algorithms can actually outperfom a good majority of the others in a large-scale testing. Just to give you an idea on how many algorithms there are out there, Fernandez-Delgado et al. tested 179 classifiers, which can be roughly classified in SEVENTEEN different families (although many of these can be classified as meta-algorithms, such as ensembling techniques). The rest includes disciminant methods, neural networks, support vector machines, instance-based methods, rule-based methods, MARS, and many more.

For a simpler categorization, you may look at a slightly older paper:

[2] Supervised Machine Learning: A Review of Classification Techniques.

A nice feature of the article, is that it discusses the techniques in terms of many features (not just accuracy, however it is measured), so it highlights some aspects of less known methods which can prove useful in practice (see in particular Table IV), including how well they can cope with nominal attributes, whether you can interpret in some way the resulting model, etc.

It really depends on what your dimensions are, how many there are, what distance measure you're using (Euclidean? Cosine?) and what your classification task is. Unfortunately, that's a lot.

Specifying KNN is only the first step here.

Even when you know these other questions, the choices you're asking about here will vary in at least the following respects (and I may be overlooking some):

• are your classes well-separated
• what computational costs are you willing to incur? a fixed radius, with a small number of dimensions (e.g. GPS tags), can be hashed to very quick lookups, in very high dimensional spaces (e.g. vocabulary vectors) that hashing isn't worth much and you may have to compare to very large sets.

Nell'algoritmo KNN 'K' si riferisce al numero di vicini da considerare per la classificazione. Dovrebbe essere un valore dispari. Il valore di 'K' deve essere selezionato con attenzione altrimenti può causare difetti nel nostro modello. Se il valore di 'K' è piccolo, allora causa un basso bias, un'alta varianza, cioè un overfitting del modello. Allo stesso modo, se 'K' è molto grande, allora porta a un alto bias, una bassa varianza, cioè un underfitting del modello. Ci sono molti tipi di ricerche fatte sulla selezione del giusto valore di K, tuttavia nella maggior parte dei casi prendere 'K' = {radice quadrata di (numero totale di dati 'n')} dà un risultato abbastanza buono. Se il valore 'K' risulta essere dispari allora va bene, altrimenti lo rendiamo dispari aggiungendo o sottraendo 1 da esso.

Hi

We will start with understanding how k-NN, and k-means clustering works.

K-Nearest Neighbors (K-NN)

k-NN is a supervised algorithm used for classification. What this means is that we have some labeled data upfront which we provide to the model for it to understand the dynamics within that data i.e. train. It then uses those learnings to make inferences on the unseen data i.e. test. In the case of classification this labeled data is discrete in nature.

Steps

1. Decide on your similarity or distance metric.
2. Split the original labeled dataset into training and test data.
3. Pick an evaluation metric.
4. Decide upon the value of k. Here k refers to the number of closest neighbors we will consider while doing the majority voting of target labels.
5. Run k-NN a few times, changing k and checking the evaluation measure.
6. In each iteration, k neighbors vote, majority vote wins and becomes the ultimate prediction
7. Optimize k by picking the one with the best evaluation measure.
8. Once you’ve chosen k, use the same training set and now create a new test set with the people’s ages and incomes that you have no labels for, and want to predict.

k-Means

k-Means is an unsupervised algorithm used for clustering. By unsupervised we mean that we don’t have any labeled data upfront to train the model. Hence the algorithm just relies on the dynamics of the independent features to make inferences on unseen data.

Steps

1. Initially, randomly pick k centroids/cluster centers. Try to make them near the data but different from one another.
2. Then assign each data point to the closest centroid.
3. Move the centroids to the average location of the data points assigned to it.
4. Repeat the preceding two steps until the assignments don’t change, or change very little.

Now it’s time to compare the two algorithms.

Cheers,

Danish

Utilizzeremo il dataset Iris per implementare l'algoritmo di classificazione KNN.

# Algoritmo di classificazione KNN

from sklearn.datasets import load_iris

from sklearn.neighbors import KNeighborsClassifier

import numpy as np

from sklearn.model_selection import train_test_split

iris_dataset=load_iris()

A_train, A_test, B_train, B_test = train_test_split(iris_dataset[data], iris_dataset[target], random_state=0)

kn = KNeighborsClassifier(n_neighbors=1)

kn.fit(A_train, B_train)

A_new = np.array([[8, 2.5, 1, 1.2]])

prediction = kn.predict(A_new)

print(Predicted target value: {}\n.format(prediction))

print(Predicted feature name: {}\n.format

(iris_dataset[target_names][prediction]))

print(Test score: {:.2f}.format(kn.score(A_test, B_test)))

Output:

Predicted Target Name: [0]

Nome della caratteristica prevista: [' Setosa']

Punteggio del test: 0.92

Per imparare il test del software e la certificazione allora vai attraverso udemy e fai riferimento a corsi come ASTQB Certified Mobile Tester Training .

Beh, dipende dal problema, comunque, se si tratta di rispondere a qualcosa, direi reti neurali.

Il problema negli algoritmi di classificazione è che ci sono molte variabili da considerare. Per esempio, le reti neurali sono più lente degli SVM. Se avete bisogno di qualcosa di più veloce e facile da usare, gli SVM sono meglio, o l'algoritmo XGBoost.

A volte l'approccio migliore è quello di andare con gli algoritmi più semplici, come la regressione lineare o la classificazione logistica. A volte tutto ciò di cui avete bisogno è qualcosa che possa spiegarsi da solo, come un albero decisionale. Ecco perché non è facile nominare semplicemente il miglior algoritmo.

Una domanda migliore è: qual è il miglior algoritmo di classificazione che ha le proprietà X, Y e Z.

Prima dividiamo l'intero set di dati in training set e test set. Applica l'algoritmo KNN nell'insieme di allenamento e convalida incrociata con l'insieme di prova.

Immaginiamo di avere un insieme di allenamento xtrain e un insieme di prova xtest

ora crea il modello con il valore k 1 e predice con i dati dell'insieme di prova e controlla la precisione e altri parametri poi ripeti lo stesso processo dopo aver aumentato il valore k di 1 ogni volta.

Qui sto aumentando il valore k di 1 da 1 a 29 e stampando la precisione con il valore k rispettato.

w=precisione e i=valore k

Qui il mio obiettivo era la massima precisione quindi ho preso il valore k come 13 (in cui la precisione era massima dopo l'esecuzione del codice)

Così in base al vostro obiettivo o requisito selezionate il valore k.