8 masinõppe rühmitamise algoritme, mida kõik andmeteadlased peaksid teadma

Masinõppel on kolm erinevat lähenemist, sõltuvalt teie andmetest. Võite minna juhendatud õppega, pooljuhendatud õppega või järelevalveta õppimisega.

Juhendatud õppes olete sildistanud andmed, nii et teil on väljundeid, millest teate kindlasti oma sisendite õigeid väärtusi. See on nagu autohindade teadmine selliste omaduste põhjal nagu mark, mudel, stiil, jõuülekanne ja muud omadused.

Pooljuhendatud õppimisega on teil suur andmekogum, kus osa andmetest on sildistatud, kuid enamus neist pole.

See hõlmab suurt hulka reaalmaailma andmeid, sest võib olla kallis saada ekspert igale andmepunktile silt. Saate selle lahendada, kasutades juhendatava ja järelevalveta õppimise kombinatsiooni.

Järelevalveta õppimine tähendab, et teil on andmekogum, mis on täielikult sildistamata. Te ei tea, kas andmetes on mingeid mustreid peidetud, nii et jätate algoritmile ülesandeks leida kõik, mis võimalik.

Seal tulevad klastrialgoritmid. See on üks meetoditest, mida saate kasutada järelevalveta õpiprobleemide korral.

Mis on klastrialgoritmid?

Klasterdamine on järelevalveta masinõppe ülesanne. Selle meetodi toimimise tõttu võite kuulda ka seda, mida nimetatakse klastrianalüüsiks.

Klastrialgoritmi kasutamine tähendab, et annate algoritmile palju sisendandmeid ilma siltideta ja lasete tal leida võimalikest andmetest rühmitused.

Neid rühmitusi nimetatakse klastriteks . Klaster on rühm andmepunkte, mis on üksteisega sarnased, lähtudes nende seosest ümbritsevate andmepunktidega. Klasterdamist kasutatakse näiteks funktsioonide väljatöötamiseks või mustrite avastamiseks.

Kui alustate andmetega, millest midagi ei tea, võib klastrite tegemine olla hea koht ülevaate saamiseks.

Klastrialgoritmide tüübid

Igasuguseid ainulaadseid andmeid käsitlevaid klastrialgoritme on erinevat tüüpi.

Tiheduspõhine

Tiheduspõhises rühmituses rühmitatakse andmed suurte andmepunktide kontsentratsioonide piirkondade järgi, mida ümbritsevad andmepunktide madala kontsentratsiooniga alad. Põhimõtteliselt leiab algoritm kohad, mis on tihedad andmepunktidest, ja kutsub need klastrid.

Selle juures on tore see, et klastrid võivad olla mis tahes kujuga. Te ei ole oodatud tingimustega piiratud.

Selle tüübi klastrialgoritmid ei ürita kobaratele hälbeid määrata, mistõttu neid ignoreeritakse.

Jaotuspõhine

Jaotuspõhise klastrite lähenemise korral peetakse kõiki andmepunkte klastri osaks, lähtudes tõenäosusest, et nad kuuluvad antud klastrisse.

See töötab nii: on keskpunkt ja kui andmepunkti kaugus keskusest suureneb, väheneb tõenäosus, et see on selle klastri osa.

Kui te pole kindel oma andmete jaotuse võimalikkuses, peaksite kaaluma teist tüüpi algoritme.

Tsentroidipõhine

Tsentroidpõhine klasterdamine on see, mida te kõige rohkem kuulete. See on veidi tundlik teile antud esialgsete parameetrite suhtes, kuid see on kiire ja tõhus.

Seda tüüpi algoritmid eraldavad andmepunktid andmetes sisalduva mitme tsentriidi alusel. Iga andmepunkt määratakse klastrile, lähtudes selle ruudukujulisest kaugusest tsentroidist. See on kõige sagedamini kasutatav klastrite tüüp.

Hierarhiline

Hierarhilistel alustel klastreid kasutatakse tavaliselt hierarhilistes andmetes, nagu saaksite ettevõtte andmebaasist või taksonoomiatest. See ehitab klastrite puu, nii et kõik on korraldatud ülevalt alla.

See on piiravam kui muud klastrite tüübid, kuid sobib suurepäraselt teatud tüüpi andmekogumite jaoks.

Millal klastreid kasutada

Kui teil on silt siltideta, on väga tõenäoline, et kasutate mingit järelevalveta õppealgoritmi.

Seal on palju erinevaid järelevalveta õppimisvõtteid, nagu närvivõrgud, tugevdav õppimine ja klastrid. Konkreetne algoritmi tüüp, mida soovite kasutada, sõltub teie andmete välimusest.

Võimalik, et proovite leida anomaaliate tuvastamiseks klastreid, et proovida leida oma andmete hälbeid. See aitab leida need klastrite rühmad ja näidata piire, mis määraksid kindlaks, kas andmepunkt on varjatud väärtus või mitte.

Kui te pole kindel, milliseid funktsioone oma masinõppemudeli jaoks kasutada, avastab klasterdamine mustrid, mida saate kasutada andmete väljapaistmiseks.

Klasterdamine on eriti kasulik selliste andmete uurimiseks, millest te midagi ei tea. Võib kuluda aega, et välja selgitada, mis tüüpi klastrialgoritm kõige paremini töötab, kuid kui seda teete, saate hindamatu ülevaate oma andmetest. Võimalik, et leiate seoseid, mida te poleks kunagi mõelnud.

Mõned reaalses maailmas klasterdamise rakendused hõlmavad pettuste avastamist kindlustuses, raamatukogudes raamatute kategoriseerimist ja klientide segmenteerimist turunduses. Seda saab kasutada ka suuremate probleemide korral, nagu maavärinate analüüs või linnaplaneerimine.

8 parimat klastrialgoritmi

Nüüd, kui teil on klastrialgoritmide toimimise ja erinevate saadaolevate tüüpide taust, saame rääkida tegelikest algoritmidest, mida tavaliselt praktikas näete.

Rakendame need algoritmid Pythoni sklearn'i teegi näidisandmekogumile.

Me kasutad make_classification andmekogumi sklearn raamatukogu näidata, kuidas erinevad klastrite algoritmid ei sobi kõigile klastrite probleeme.

Kõigi järgnevate näidete koodi leiate siit.

K - tähendab klastrialgoritmi

K-tähendab klastreerimine on kõige sagedamini kasutatav klastrialgoritm. See on tsentroidpõhine algoritm ja kõige lihtsam järelevalveta õpialgoritm.

See algoritm püüab minimeerida klastri andmepunktide erinevust. Samuti tutvustatakse enamikule inimestele järelevalveta masinõpet.

K-keskmisi saab kõige paremini kasutada väiksemate andmekogumite korral, kuna see kordub kõigi andmepunktide vahel. See tähendab, et andmepunktide klassifitseerimine võtab rohkem aega, kui andmekogumis on neid palju.

Kuna k-tähendus tähendab klastrite andmepunkte, siis see ei skaleeru hästi.

Rakendamine:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import KMeans # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model kmeans_model = KMeans(n_clusters=2) # assign each data point to a cluster dbscan_result = dbscan_model.fit_predict(training_data) # get all of the unique clusters dbscan_clusters = unique(dbscan_result) # plot the DBSCAN clusters for dbscan_cluster in dbscan_clusters:     # get data points that fall in this cluster     index = where(dbscan_result == dbscan_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the DBSCAN plot pyplot.show()

DBSCAN-i klastrialgoritm

DBSCAN tähistab müras olevate rakenduste tiheduspõhist ruumilist klastrit. See on tihedusepõhine klastrialgoritm, erinevalt k-keskmistest.

See on hea algoritm andmehulga piirjoonte leidmiseks. See leiab meelevaldse kujuga klastreid, mis põhinevad andmepunktide tihedusel erinevates piirkondades. See eraldab piirkonnad madala tihedusega piirkondade kaupa, nii et see suudab tuvastada suure tihedusega klastrite vahelised kõrvalarvud.

Veider kujuga andmetega töötamisel on see algoritm parem kui k-tähendus.

Klastrite määratlemise määramiseks kasutab DBSCAN kahte parameetrit: minPts (minimaalne arv andmepunkte, mis tuleb kokku koondada, et ala saaks pidada tihedaks ) ja eps (kaugus, mida kasutatakse andmepunkti leidmiseks teiste andmepunktidega sama ala).

Õigete algparameetrite valimine on selle algoritmi toimimiseks kriitilise tähtsusega.

Rakendamine:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import DBSCAN # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model dbscan_model = DBSCAN(eps=0.25, min_samples=9) # train the model dbscan_model.fit(training_data) # assign each data point to a cluster dbscan_result = dbscan_model.predict(training_data) # get all of the unique clusters dbscan_cluster = unique(dbscan_result) # plot the DBSCAN clusters for dbscan_cluster in dbscan_clusters:     # get data points that fall in this cluster     index = where(dbscan_result == dbscan_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the DBSCAN plot pyplot.show()

Gaussi segu mudeli algoritm

Üks k-keskmise probleemidest on see, et andmed peavad järgima ümmargust vormingut. See, kuidas k-mean arvutab andmepunktide vahelise kauguse, on seotud ümmarguse teega, nii et mitte ümmargused andmed pole rühmitatud õigesti.

See on küsimus, mille Gaussi segu mudelid lahendavad. Selle toimimiseks pole vaja ümmarguse kujuga andmeid.

Gaussi segu mudel kasutab meelevaldse kujuga andmete sobitamiseks mitut Gaussi jaotust.

Selles hübriidmudelis on mitu üksikut Gaussi mudelit, mis toimivad varjatud kihtidena. Nii arvutab mudel tõenäosuse, et andmepunkt kuulub konkreetsesse Gaussi jaotusse ja see on see klaster, mille alla see kuulub.

Rakendamine:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.mixture import GaussianMixture # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model gaussian_model = GaussianMixture(n_components=2) # train the model gaussian_model.fit(training_data) # assign each data point to a cluster gaussian_result = gaussian_model.predict(training_data) # get all of the unique clusters gaussian_clusters = unique(gaussian_result) # plot Gaussian Mixture the clusters for gaussian_cluster in gaussian_clusters:     # get data points that fall in this cluster     index = where(gaussian_result == gaussian_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the Gaussian Mixture plot pyplot.show()

KASE algoritm

Tasakaalu iteratiivne redutseerimine ja klasterdamine hierarhiate (BIRCH) algoritmi abil töötab suuremahuliste andmekogumite puhul paremini kui k-keskmine algoritm.

See jagab andmed väikesteks kokkuvõteteks, mis on algsete andmepunktide asemel rühmitatud. Kokkuvõtted sisaldavad andmepunktide kohta võimalikult palju levitamisteavet.

Seda algoritmi kasutatakse tavaliselt koos teiste klastrialgoritmidega, kuna BIRCHi loodud kokkuvõtetes saab kasutada muid klastritehnikaid.

The main downside of the BIRCH algorithm is that it only works on numeric data values. You can't use this for categorical values unless you do some data transformations.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import Birch # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model birch_model = Birch(threshold=0.03, n_clusters=2) # train the model birch_model.fit(training_data) # assign each data point to a cluster birch_result = birch_model.predict(training_data) # get all of the unique clusters birch_clusters = unique(birch_result) # plot the BIRCH clusters for birch_cluster in birch_clusters:     # get data points that fall in this cluster     index = where(birch_result == birch_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the BIRCH plot pyplot.show() 

Affinity Propagation clustering algorithm

This clustering algorithm is completely different from the others in the way that it clusters data.

Each data point communicates with all of the other data points to let each other know how similar they are and that starts to reveal the clusters in the data. You don't have to tell this algorithm how many clusters to expect in the initialization parameters.

As messages are sent between data points, sets of data called exemplars are found and they represent the clusters.

An exemplar is found after the data points have passed messages to each other and form a consensus on what data point best represents a cluster.

When you aren't sure how many clusters to expect, like in a computer vision problem, this is a great algorithm to start with.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import AffinityPropagation # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model model = AffinityPropagation(damping=0.7) # train the model model.fit(training_data) # assign each data point to a cluster result = model.predict(training_data) # get all of the unique clusters clusters = unique(result) # plot the clusters for cluster in clusters:     # get data points that fall in this cluster     index = where(result == cluster)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the plot pyplot.show()

Mean-Shift clustering algorithm

This is another algorithm that is particularly useful for handling images and computer vision processing.

Mean-shift is similar to the BIRCH algorithm because it also finds clusters without an initial number of clusters being set.

This is a hierarchical clustering algorithm, but the downside is that it doesn't scale well when working with large data sets.

It works by iterating over all of the data points and shifts them towards the mode. The mode in this context is the high density area of data points in a region.

That's why you might hear this algorithm referred to as the mode-seeking algorithm. It will go through this iterative process with each data point and move them closer to where other data points are until all data points have been assigned to a cluster.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import MeanShift # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model mean_model = MeanShift() # assign each data point to a cluster mean_result = mean_model.fit_predict(training_data) # get all of the unique clusters mean_clusters = unique(mean_result) # plot Mean-Shift the clusters for mean_cluster in mean_clusters:     # get data points that fall in this cluster     index = where(mean_result == mean_cluster)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the Mean-Shift plot pyplot.show()

OPTICS algorithm

OPTICS stands for Ordering Points to Identify the Clustering Structure. It's a density-based algorithm similar to DBSCAN, but it's better because it can find meaningful clusters in data that varies in density. It does this by ordering the data points so that the closest points are neighbors in the ordering.

This makes it easier to detect different density clusters. The OPTICS algorithm only processes each data point once, similar to DBSCAN (although it runs slower than DBSCAN). There's also a special distance stored for each data point that indicates a point belongs to a specific cluster.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import OPTICS # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model optics_model = OPTICS(eps=0.75, min_samples=10) # assign each data point to a cluster optics_result = optics_model.fit_predict(training_data) # get all of the unique clusters optics_clusters = unique(optics_clusters) # plot OPTICS the clusters for optics_cluster in optics_clusters:     # get data points that fall in this cluster     index = where(optics_result == optics_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the OPTICS plot pyplot.show()

Agglomerative Hierarchy clustering algorithm

This is the most common type of hierarchical clustering algorithm. It's used to group objects in clusters based on how similar they are to each other.

This is a form of bottom-up clustering, where each data point is assigned to its own cluster. Then those clusters get joined together.

At each iteration, similar clusters are merged until all of the data points are part of one big root cluster.

Agglomerative clustering is best at finding small clusters. The end result looks like a dendrogram so that you can easily visualize the clusters when the algorithm finishes.

Implementation:

from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import AgglomerativeClustering # initialize the data set we'll work with training_data, _ = make_classification(     n_samples=1000,     n_features=2,     n_informative=2,     n_redundant=0,     n_clusters_per_class=1,     random_state=4 ) # define the model agglomerative_model = AgglomerativeClustering(n_clusters=2) # assign each data point to a cluster agglomerative_result = agglomerative_model.fit_predict(training_data) # get all of the unique clusters agglomerative_clusters = unique(agglomerative_result) # plot the clusters for agglomerative_cluster in agglomerative_clusters:     # get data points that fall in this cluster     index = where(agglomerative_result == agglomerative_clusters)     # make the plot     pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the Agglomerative Hierarchy plot pyplot.show()

Other types of clustering algorithms

We've covered eight of the top clustering algorithms, but there are plenty more than that available. There are some very specifically tuned clustering algorithms that quickly and precisely handle your data. Here are a few of the others that might be of interest to you.

There's another hierarchical algorithm that's the opposite of the agglomerative approach. It starts with a top-down clustering strategy. So it will start with one large root cluster and break out the individual clusters from there.

This is known as the Divisive Hierarchical clustering algorithm. There's research that shows this is creates more accurate hierarchies than agglomerative clustering, but it's way more complex.

Mini-Batch K-means is similar to K-means, except that it uses small random chunks of data of a fixed size so they can be stored in memory. This helps it run faster than K-means so it converges to a solution in less time.

The drawback to this algorithm is that the speed boost will cost you some cluster quality.

The last algorithm we'll briefly cover is Spectral Clustering. This algorithm is completely different from the others we've looked at.

It works by taking advantage of graph theory. This algorithm doesn't make any initial guesses about the clusters that are in the data set. It treats data points like nodes in a graph and clusters are found based on communities of nodes that have connecting edges.

Other thoughts

Watch out for scaling issues with the clustering algorithms. Your data set could have millions of data points, and since clustering algorithms work by calculating the similarities between all pairs of data points, you might end up with an algorithm that doesn’t scale well.

Conclusion

Clustering algorithms are a great way to learn new things from old data. Sometimes you'll be surprised by the resulting clusters you get and it might help you make sense of a problem.

Klastrite kasutamise järelevalveta õppimiseks on üks lahedamaid asju, et saate tulemusi kasutada juhendatud õppeprobleemides.

Klastrid võivad olla teie uued funktsioonid, mida kasutate täiesti erinevas andmekogumis! Klasterdamist saate kasutada peaaegu kõigi järelevalveta masinõppeprobleemide korral, kuid veenduge, et teaksite, kuidas tulemusi täpsuse huvides analüüsida.