使用 MLIB 进行 K-Means 聚类简介

K-means 聚类是无监督 机器学习支持的算法之一，因此在继续使用 K-means 之前，让我们了解无监督学习方法的背景知识。在这种方法中，与监督方法不同，我们没有预定义的标签，因此我们不绘制预测，而是从中生成集群/组，以便可以根据提供给模型的特征对数据进行分割。

图片来源：Bookdown

K-Means 聚类遵循什么方法？

如前所述，该算法是无监督学习的一部分，因此我们将根据不同数量的集群对数据进行分割，而不是进行预测。K-means 遵循一些重要的数学步骤：

步骤 1：选择簇数，有几种方法可以选择合适的簇数，如肘法和领域知识。

第 2 步：分配 K 个点，或者我们也可以说从数据集中随机分配质心。

第 3 步：在最后一步中，每个 K 点将靠近其最近的质心进行调整，最终将形成集群/组。

好的！理论已经讲完了，现在让我们动手在 Spark 的官方聚类数据集上实现 K-means 聚类。虽然这个数据集非常小而且很奇特，但我们可以使用 PySpark 的 MLIB 解释 K-means 聚类的每个概念。

启动 Spark 对象

在任何与 spark 相关的项目中，这一步是我们必须做的第一件事，即创建和实例化 PySpark 环境，以便我们可以访问实现K-means 聚类算法所需的所有实用程序和函数。

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('intro_cluster').getOrCreate()
spark

输出：

推断：首先是从 PySpark 的 SQL 模块调用 SparkSession 对象，然后我们使用 builder() 函数合并的 getOrCreate() 函数创建了 intro_cluster 会话。

from pyspark.ml.clustering import KMeans

推理：在 PySpark 中，我们从分类类中导入所有分类算法，如决策树分类器、GBT 分类器、随机森林分类器和逻辑回归，就像我们从聚类类中导入KMeans对象一样。

读取数据集

如前所述，这是spark 在其官方 GitHub 存储库中提供的数据集，该数据集非常小，因此不应期望得到真实世界的结果，但肯定有助于理解实际实现 k 的概念- 表示聚类。

dataset_kmeans = spark.read.format("libsvm").load("sample_kmeans_data.txt")
dataset_kmeans.show()

输出：

推论：这里注意到我们是在将数据集转换为lib-svm格式后读取数据集，因为数据集是lib-svm的形式，然后它变得容易加载。稍后我们将使用show 函数查看数据集。

dataset_kmeans.head(5)

输出：

[Row(label=0.0, features=SparseVector(3, {})),
 Row(label=1.0, features=SparseVector(3, {0: 0.1, 1: 0.1, 2: 0.1})),
 Row(label=2.0, features=SparseVector(3, {0: 0.2, 1: 0.2, 2: 0.2})),
 Row(label=3.0, features=SparseVector(3, {0: 9.0, 1: 9.0, 2: 9.0})),
 Row(label=4.0, features=SparseVector(3, {0: 9.1, 1: 9.1, 2: 9.1}))]

推论：还有另一种方法可以偷看数据集，即返回所有列名及其对应值的head 函数。请注意，要素作为SparseVector返回。

dataset_kmeans.printSchema()

输出：

root
 |-- label: double (nullable = true)
 |-- features: vector (nullable = true)

推论：如果想知道数据集的 Schema 是什么样的，可以使用print schema () 函数。这里它返回了两列，一列是标签，另一列是向量格式的特征列。

执行

正如我们所知，我们不会在 K-means 中预测任何标签，而是我们过去常常创建一个集群以尽可能最好的方式分割数据，但这里是复杂的部分，因为没有 100% 的最佳方法来找到最好的集群的数量，一个应该有惊人的领域知识或肘法，有时为了更简单的问题，我们可以试一试hit and trial 方法，这就是我们要在这里做的：

1. 当 clusters = 2时，即数据集将分为两组。
2. 当 clusters = 3时，即数据集将被分成三组。

当集群 = 2

kmeans_2_cluster = KMeans().setK(2).setSeed(1)

推论：上面的代码是我们如何通过set()方法设置簇数的方式。请注意，我们正在使用resolved ()函数以及 KMeans 来为每个组选择数据的随机数，因此如果我们设置一个适当的数字，那么每次执行后它将采用相同的随机分布。

first_model = kmeans_2_cluster.fit(dataset_kmeans)

推理：现在我们正在拟合 KMeans 模型，即基于可用数据集训练模型。请注意，我们正在为训练提供完整的数据，因为我们没有标签，因此拆分数据集没有意义。

predictions_first_model = first_model.transform(dataset_kmeans)
predictions_first_model.show()

输出：

推论：现在是时候做一些预测了（这里让我们根据输入数据做一个相关的集群），为此，我们在整个数据集上使用了变换方法。当我们看到输出时，我们可以看到有两组，一组标记为 1 ，另一组标记为 2。

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

推论：建立模型是一回事，测试和评估它更重要，因为它可以让我们考虑这个模型是好用还是需要任何改变。因此，我们使用聚类评估器对象来获得一些 Kmeans 评估方法。

silhouette_2_clusters = evaluator.evaluate(predictions_first_model)
print("Silhouette evaluation results = " + str(silhouette_2_clusters))

输出：

Silhouette evaluation results = 0.9997530305375207

推论：轮廓是一种统计方法，用于检查数据集群内的一致性。它的系数值范围在[-1,1]之间，系数越正，数据点在该特定簇内的越多越好。

two_centroid = first_model.clusterCenters()
print("Center of clusters: ")
for c in two_centroid:
    print(c)

输出：

Center of clusters: 
[9.1 9.1 9.1]
[0.1 0.1 0.1]

推论：了解每个集群的中心/质心非常重要，因为它们有助于我们了解它们彼此之间的可分离性。在输出中，可以看到有两个集群，因为我们选择 K（集群）的数量为2。

当集群 = 3

kmeans_3_clusters = KMeans().setK(3).setSeed(1)
second_model = kmeans_3_clusters.fit(dataset_kmeans)
predictions_second_model = second_model.transform(dataset_kmeans)

推论：现在是时候检查当我们选择拥有三个集群时我们的模型将如何执行，因为这个过程几乎相同，我们将K 值设置为 3即3 个组，然后我们将拟合/训练完整的数据（我已经讨论过的原因）最后绘制预测变换方法来拯救。

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

silhouette_3_clusters = evaluator.evaluate(predictions_second_model)
print("Silhouette evaluation results = " + str(silhouette_3_clusters))

输出：

Silhouette evaluation results = 0.6248737134600261

推论：在这里，如果我们比较集群为 2 时的轮廓距离，那么可以得出结论，我们应该只使用 2 个集群，因为它会给我们更好的结果。

three_centroid = second_model.clusterCenters()
print("Center of clusters: ")
for c in three_centroid:
    print(c)

输出：

Center of clusters: 
[9.1 9.1 9.1]
[0.05 0.05 0.05]
[0.2 0.2 0.2]

推论：用3-K 值构建模型的唯一目的是比较两者并选择可能的最佳 K 值，在这里我们可以看到一个三质心值。

K-Means 聚类结论

我们正处于最后阶段。在本节中，我们将通过实际实施来完成本文迄今为止所做的一切。从介绍 K-means 算法及其操作方式开始，我们通过比较两种不同的情况，选择了最好的一种。

1. 首先，我们讨论K-Means 算法的工作原理，然后建立一个 PySpark 平台，以便我们可以实现它并获得实践经验。
2. 然后我们从 PySpark 文档示例中读取了官方数据集，并分析了 Schema并对其有一个基本的了解。
3. 最后，我们在两种情况下（当集群为 2 和 3时）构建 K-means 模型，在查看评估结果后，我们得出结论，对于该特定数据，当集群为 2 时，它的表现更好。

这是本文的回购链接。我希望你喜欢我关于 MLIB 中树方法简介的文章。如果您有任何意见或问题，请在下方评论。

资料来源：https ://www.analyticsvidhya.com/blog/2022/07/introduction-to-k-means-clustering-using-mlib/

#mlib 

MLIB を使用した K-Means クラスタリングの概要

K-means クラスタリングは、教師なし 機械学習がサポートするアルゴリズムの 1 つです。そのため、K-means を使用する前に、教師なし学習方法の背景知識を持っておきましょう。この方法では、教師付き方法とは異なり、事前定義されたラベルがないため、予測を描画しませんが、モデルに供給される機能に従ってデータをセグメント化できるように、それらからクラスター/グループを作成します。

画像ソース：ブックダウン

K-Means クラスタリングはどのようなアプローチに従いますか?

前述のように、このアルゴリズムは教師なし学習の一部であるため、予測を行う代わりに、さまざまな数のクラスターに基づいてそのデータをセグメント化します。K-means は、議論することが重要ないくつかの数学的手順に従います。

ステップ 1:クラスターの数を選択します。適切な数のクラスターを選択するには、エルボ法やドメイン知識など、いくつかの方法があります。

ステップ 2: K ポイントの割り当て、またはデータセットから重心をランダムに割り当てることもできます。

ステップ 3:最後のステップで、各 K ポイントは、最終的にクラスター/グループを形成する最も近い重心に向かって厳密に調整されます。

わかった！十分な理論があるので、Spark の公式クラスタリングデータセットに K-means クラスタリングを実装してみましょう。このデータセットは非常に小さく独特ですが、PySpark の MLIB を使用して K-means クラスタリングの各概念を説明できます。

Spark オブジェクトの開始

Spark関連のプロジェクトのこのステップは、 K-means クラスタリング アルゴリズムを実装するために必要なすべてのユーティリティと関数にアクセスできるように、PySpark 環境を作成してインスタンス化することによって最初に行う必要があります。

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('intro_cluster').getOrCreate()
spark

出力：

推論:何よりもまず、SparkSession オブジェクトが PySpark の SQL モジュールから呼び出され、次に builder() 関数によって組み込まれた getOrCreate() 関数を使用して intro_cluster セッションを作成しました。

from pyspark.ml.clustering import KMeans

推論: PySpark では、クラスタリングクラスからKMeansオブジェクトをインポートするのと同じ方法で、決定木分類器、GBT 分類器、ランダム フォレスト分類器、ロジスティック回帰などのすべての分類アルゴリズムを分類クラスからインポートします。

データセットの読み取り

前述のように、これは公式の GitHub リポジトリで Spark によって提供されるデータセットであり、このデータセットは非常に小さいため、実際の結果を期待するべきではありませんが、k を実際に実装する概念を理解するのに役立つことは間違いありません。 -クラスタリングを意味します。

dataset_kmeans = spark.read.format("libsvm").load("sample_kmeans_data.txt")
dataset_kmeans.show()

出力：

推論:ここでは、データセットが lib-svm の形式であるため、lib-svm の形式に変換した後にデータセットを読み取っていることに注意してください。これにより、読み込みが容易になります。後で、show 関数を使用してデータセットを確認します。

dataset_kmeans.head(5)

出力：

[Row(label=0.0, features=SparseVector(3, {})),
 Row(label=1.0, features=SparseVector(3, {0: 0.1, 1: 0.1, 2: 0.1})),
 Row(label=2.0, features=SparseVector(3, {0: 0.2, 1: 0.2, 2: 0.2})),
 Row(label=3.0, features=SparseVector(3, {0: 9.0, 1: 9.0, 2: 9.0})),
 Row(label=4.0, features=SparseVector(3, {0: 9.1, 1: 9.1, 2: 9.1}))]

推論:データセットのスニーク ピークを持つ別の方法が 1 つあります。つまり、すべての列名とそれに対応する値を返すhead 関数です。機能がSparseVectorとして返されていることに注意してください。

dataset_kmeans.printSchema()

出力：

root
 |-- label: double (nullable = true)
 |-- features: vector (nullable = true)

推論:データセットのスキーマがどのように見えるかを知りたい場合は、print schema () 関数を使用できます。ここでは、1 つはラベル、もう1 つは特徴列の 2 つの列をベクター形式で返しています。

実装

K-means ではラベルを予測しないことがわかっているため、代わりにクラスターを作成してデータを可能な限り最善の方法でセグメント化しましたが、最適なものを見つける 100% 最適な方法はないため、ここでは複雑な部分が生じます。クラスターの数は、いずれかが驚くべきドメイン知識を持っている必要があります。または、エルボ メソッドを使用する必要があります。問題がより簡単な場合は、ヒットして試してみることができます。これが、ここで行うことです。

1. clusters = 2の場合、つまり、データセットが 2 つのグループに分けられる場合。
2. クラスター = 3の場合、つまり、データセットが 3 つのグループに分割される場合。

クラスタ数 = 2 の場合

kmeans_2_cluster = KMeans().setK(2).setSeed(1)

推論:上記のコードは、set()メソッドからクラスターの数を設定する方法です。Settle ()関数と KMeans を使用して、各グループのデータの乱数を選択していることに注意してください。適切な数を設定すると、実行されるたびに同じ乱数分布になります。

first_model = kmeans_2_cluster.fit(dataset_kmeans)

推論: KMeans モデルを適合させます。つまり、利用可能なデータセットに基づいてモデルをトレーニングします。ラベルがないため、トレーニング用に完全なデータを供給しているため、データセットを分割しても意味がないことに注意してください。

predictions_first_model = first_model.transform(dataset_kmeans)
predictions_first_model.show()

出力：

推論:いくつかの予測を行う時が来ました (ここでは、入力データに基づいて関連するクラスターを作成しましょう)。そのために、データセット全体で変換メソッドを使用しています。出力を見ると、1 と 2 のタグが付けられた 2 つのグループがあることがわかります。

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

推論:モデルを構築することは 1 つのことであり、それをテストして評価することは、このモデルがうまくいくかどうか、または変更が必要かどうかを検討できるようになるため、より重要です。したがって、クラスタリング エバリュエーター オブジェクトを使用して、いくつかの Kmeans 評価メソッドを取得しています。

silhouette_2_clusters = evaluator.evaluate(predictions_first_model)
print("Silhouette evaluation results = " + str(silhouette_2_clusters))

出力：

Silhouette evaluation results = 0.9997530305375207

推論:シルエットは、データのクラスター内の一貫性をチェックする統計的手法です。その係数値の範囲は[-1,1]の間で、係数が正であるほど、データ ポイントがその特定のクラスター内に多く含まれます。

two_centroid = first_model.clusterCenters()
print("Center of clusters: ")
for c in two_centroid:
    print(c)

出力：

Center of clusters: 
[9.1 9.1 9.1]
[0.1 0.1 0.1]

推論:各クラスターの中心/重心について知ることは、それらが互いにどれだけ分離可能かを知るのに役立つため、非常に重要です。出力では、K (クラスター) の数を2として選択したため、2 つのクラスターがあることがわかります。

クラスタ数 = 3 の場合

kmeans_3_clusters = KMeans().setK(3).setSeed(1)
second_model = kmeans_3_clusters.fit(dataset_kmeans)
predictions_second_model = second_model.transform(dataset_kmeans)

推論:ここで、3 つのクラスターを持つことを選択した場合にモデルがどのように機能するかを確認します。そのため、プロセスはここでほぼ同じです。K 値を 3 つ、つまり3 つのグループとして設定し、完全なデータを適合/トレーニングします(すでに説明した理由) 最後に、予測を描画するための変換方法が助けになります。

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

silhouette_3_clusters = evaluator.evaluate(predictions_second_model)
print("Silhouette evaluation results = " + str(silhouette_3_clusters))

出力：

Silhouette evaluation results = 0.6248737134600261

推論:ここで、クラスターが 2 の場合のシルエット距離を比較すると、より良い結果が得られるため、2 つのクラスターのみを使用する必要があると結論付けることができます。

three_centroid = second_model.clusterCenters()
print("Center of clusters: ")
for c in three_centroid:
    print(c)

出力：

Center of clusters: 
[9.1 9.1 9.1]
[0.05 0.05 0.05]
[0.2 0.2 0.2]

推論: 3-K 値を使用してモデルを構築する唯一の目的は、両方を比較して、可能な限り最良の K 値を選択することです。

K-Means クラスタリングのまとめ

このセクションでは、実際の実装に関して、この記事でこれまで行ってきたことをすべて説明します。K-means アルゴリズムとその操作方法の紹介から、2 つの異なるケースを比較し、最適なものを選択しました。

1. 最初に、K-Means アルゴリズムがどのように機能するかについて説明し、次に PySpark プラットフォームをセットアップして、それを実装して実践的な経験を得られるようにします。
2. 次に、PySpark のドキュメントの例から公式のデータセットを読み、スキーマを分析して、同じことの基本的な理解を得ました。
3. 最後に、2 つのケース (クラスターが 2 と 3の場合)で K 平均法モデルを構築し、評価結果を確認した後、クラスターが 2 の場合のこの特定のデータのパフォーマンスが優れていると結論付けました。

この記事へのレポリンクは次のとおりです。MLIB のツリー メソッドの紹介に関する私の記事が気に入っていただければ幸いです。ご意見やご質問がありましたら、以下にコメントしてください。

ソース: https://www.analyticsvidhya.com/blog/2022/07/introduction-to-k-means-clustering-using-mlib/

#mlib 

introduction Au Clustering K-Means à L'aide De MLIB

Le clustering K- means est l'un des algorithmes pris en charge par l' apprentissage automatique non supervisé . Par conséquent, avant d'aller de l'avant avec K-means, ayons une connaissance de base de la méthode d'apprentissage non supervisé. Dans cette méthode, nous n'avons pas d' étiquettes prédéfinies contrairement à la méthode supervisée , nous ne tirons donc pas de prédictions, mais nous en faisons des clusters/groupes afin que les données puissent être segmentées en fonction des caractéristiques qui alimentent le modèle.

Source de l'image : Bookdown

Quelle approche le clustering K-Means suit-il ?

Comme indiqué, cet algorithme fait partie de l'apprentissage non supervisé, donc au lieu de faire des prédictions, nous segmenterons ces données en fonction du nombre différent de clusters. Les K-means suivent quelques étapes mathématiques dont il est important de discuter :

Étape 1 : sélectionnez le nombre de clusters, et il existe plusieurs façons de sélectionner le nombre approprié de clusters, comme la méthode du coude et la connaissance du domaine .

Étape 2 : Attribuer les points K ou nous pouvons également dire attribuer au hasard les centroïdes de l'ensemble de données.

Étape 3 : Dans la dernière étape, chaque point K sera ajusté étroitement vers son centroïde le plus proche qui formera éventuellement les clusters/groupes .

D'accord! Assez de théories, mettons maintenant la main à la pâte pour implémenter le clustering K-means sur l'ensemble de données de clustering officiel de Spark . Bien que cet ensemble de données soit très petit et suffisamment particulier pour que nous puissions expliquer chaque concept de clustering K-means à l'aide de MLIB de PySpark.

Lancement de l'objet Spark

Cette étape de tout projet lié à Spark est la première chose que nous devons faire en créant et en instanciant l'environnement PySpark afin que nous puissions accéder à tous ses utilitaires et fonctions nécessaires à la mise en œuvre de l' algorithme de clustering K-means.

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('intro_cluster').getOrCreate()
spark

Production:

Inférence : d'abord et avant tout, l'objet SparkSession est appelé à partir du module SQL de PySpark, puis nous avons créé la session intro_cluster à l'aide de la fonction getOrCreate() incorporée par la fonction builder().

from pyspark.ml.clustering import KMeans

Inférence : dans PySpark, nous importons tous les algorithmes de classification tels que le classificateur d' arbre de décision, le classificateur GBT, le classificateur de forêt aléatoire et la régression logistique à partir de la classe de classification de la même manière que nous importons l' objet KMeans à partir de la classe de clustering .

Lecture du jeu de données

Comme mentionné précédemment, il s'agit de l'ensemble de données fourni par l'étincelle dans leur référentiel GitHub officiel , cet ensemble de données est assez petit , il ne faut donc pas s'attendre à des résultats réels, mais il peut sûrement aider à comprendre le concept de mise en œuvre pratique du k -signifie le regroupement.

dataset_kmeans = spark.read.format("libsvm").load("sample_kmeans_data.txt")
dataset_kmeans.show()

Production:

Inférence : notez ici que nous lisons l'ensemble de données après l'avoir converti au format de lib-svm car l'ensemble de données est sous la forme de lib-svm, puis il devient facile à charger. Plus tard, nous examinons l'ensemble de données à l'aide de la fonction show .

dataset_kmeans.head(5)

Production:

[Row(label=0.0, features=SparseVector(3, {})),
 Row(label=1.0, features=SparseVector(3, {0: 0.1, 1: 0.1, 2: 0.1})),
 Row(label=2.0, features=SparseVector(3, {0: 0.2, 1: 0.2, 2: 0.2})),
 Row(label=3.0, features=SparseVector(3, {0: 9.0, 1: 9.0, 2: 9.0})),
 Row(label=4.0, features=SparseVector(3, {0: 9.1, 1: 9.1, 2: 9.1}))]

Inférence : Il existe une autre méthode pour avoir un aperçu de l'ensemble de données, c'est-à-dire la fonction head qui renvoie tous les noms de colonnes avec leurs valeurs correspondantes. Notez que les entités sont renvoyées en tant que SparseVector .

dataset_kmeans.printSchema()

Production:

root
 |-- label: double (nullable = true)
 |-- features: vector (nullable = true)

Inférence : si l'on veut savoir à quoi ressemble le schéma de l'ensemble de données, on peut utiliser la fonction d'impression du schéma (). Ici, il a renvoyé deux colonnes, l'une est l' étiquette et l'autre est la colonne des caractéristiques au format vectoriel .

Mise en œuvre

Comme nous savons que nous ne prédisons aucune étiquette dans K-means, nous avions plutôt l'habitude de créer un cluster pour segmenter les données de la meilleure façon possible, mais voici la partie complexe car il n'y a pas de moyens optimaux à 100% pour trouver le meilleur nombre de clusters , l'un ou l'autre devrait avoir l'incroyable connaissance du domaine ou la méthode du coude , parfois pour le problème le plus simple, nous pouvons essayer de frapper et de tester la méthode , c'est ce que nous allons faire ici :

1. Lorsque clusters = 2 , c'est-à-dire lorsque l'ensemble de données sera séparé en deux groupes.
2. Lorsque clusters = 3 , c'est-à-dire lorsque l'ensemble de données sera séparé en trois groupes.

Quand grappes = 2

kmeans_2_cluster = KMeans().setK(2).setSeed(1)

Inférence : le code ci-dessus indique comment nous définissons le nombre de clusters à partir de la méthode set() . Notez que nous utilisons la fonction réglé () ainsi que KMeans pour choisir le nombre aléatoire de données pour chaque groupe, donc si nous définissons un nombre approprié, après chaque exécution, il prendra la même distribution aléatoire .

first_model = kmeans_2_cluster.fit(dataset_kmeans)

Inférence : nous ajustons maintenant le modèle KMeans, c'est-à-dire que nous entraînons le modèle en fonction de l'ensemble de données disponible. Notez que nous alimentons les données complètes pour la formation car nous n'avons pas les étiquettes, il est donc inutile de diviser l'ensemble de données .

predictions_first_model = first_model.transform(dataset_kmeans)
predictions_first_model.show()

Production:

Inférence : Il est maintenant temps de faire quelques prédictions (créons ici un cluster pertinent basé sur les données d'entrée) et pour cela, nous utilisons la méthode de transformation sur l'ensemble de données. Lorsque nous avons vu la sortie, nous pouvons voir qu'il y a deux groupes, l'un est étiqueté comme 1 et l'autre comme 2 .

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

Inférence : Construire le modèle est une chose et le tester et l'évaluer est plus important car cela nous permettra de déterminer si ce modèle est bon ou s'il a besoin de modifications. Par conséquent, nous utilisons l'objet évaluateur de clustering pour obtenir des méthodes d'évaluation Kmeans.

silhouette_2_clusters = evaluator.evaluate(predictions_first_model)
print("Silhouette evaluation results = " + str(silhouette_2_clusters))

Production:

Silhouette evaluation results = 0.9997530305375207

Inférence : La silhouette est une méthode statistique qui vérifie la cohérence au sein des groupes de données . Sa valeur de coefficient est comprise entre [-1,1] plus le coefficient est positif, mieux c'est, plus le point de données se trouve dans ce groupe particulier.

two_centroid = first_model.clusterCenters()
print("Center of clusters: ")
for c in two_centroid:
    print(c)

Production:

Center of clusters: 
[9.1 9.1 9.1]
[0.1 0.1 0.1]

Inférence : Connaître le centre/centroïde de chaque cluster est très important car ils nous aident à savoir à quel point ils sont séparables les uns des autres . Dans la sortie, on peut voir qu'il y a deux clusters car nous choisissons le nombre de K (clusters) comme 2 .

Quand grappes = 3

kmeans_3_clusters = KMeans().setK(3).setSeed(1)
second_model = kmeans_3_clusters.fit(dataset_kmeans)
predictions_second_model = second_model.transform(dataset_kmeans)

Inférence : Il est maintenant temps de vérifier comment notre modèle fonctionnera lorsque nous choisirons d'avoir trois clusters et pour cela, le processus est presque le même ici, nous allons définir la valeur K comme 3, c'est-à -dire 3 groupes, puis nous ajusterons/formerons les données complètes ( la raison que j'ai déjà discutée) enfin pour dessiner des prédictions , la méthode de transformation vient à la rescousse.

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

silhouette_3_clusters = evaluator.evaluate(predictions_second_model)
print("Silhouette evaluation results = " + str(silhouette_3_clusters))

Production:

Silhouette evaluation results = 0.6248737134600261

Inférence: Ici, si nous comparons la distance Silhouette lorsque les clusters étaient 2, on peut en conclure que nous ne devrions utiliser que 2 clusters car cela nous donne de meilleurs résultats.

three_centroid = second_model.clusterCenters()
print("Center of clusters: ")
for c in three_centroid:
    print(c)

Production:

Center of clusters: 
[9.1 9.1 9.1]
[0.05 0.05 0.05]
[0.2 0.2 0.2]

Inférence : Le seul but de la construction du modèle avec une valeur 3-K est de comparer les deux et de choisir la meilleure valeur K possible ici, nous pouvons voir une valeur à trois centroïdes.

Conclusion sur le clustering K-Means

Nous sommes dans la phase finale les garsDans cette section, nous passerons en revue tout ce que nous avons fait jusqu'à présent dans cet article en termes de mise en œuvre pratique. De l'introduction à l'algorithme K-means et à son mode de fonctionnement, nous sommes passés par la comparaison de deux cas différents et choisi le meilleur.

1. Tout d'abord, nous discutons du fonctionnement de l' algorithme K-Means , puis nous mettons en place une plate-forme PySpark afin que nous puissions l'implémenter et obtenir une expérience pratique.
2. Ensuite, nous avons lu l' ensemble de données officiel de l'exemple de documentation PySpark et avons également analysé le schéma et obtenu une compréhension de base de celui-ci.
3. Puis enfin, nous construisons le modèle K-means sur deux cas (lorsque les clusters sont 2 et 3 ) et après avoir vu les résultats de l'évaluation, nous avons conclu que pour ces données particulières, lorsque les clusters étaient 2, les performances étaient meilleures .

Voici le lien du dépôt vers cet article. J'espère que vous avez aimé mon article sur Introduction aux méthodes arborescentes dans MLIB. Si vous avez des opinions ou des questions, commentez ci-dessous.

Source : https://www.analyticsvidhya.com/blog/2022/07/introduction-to-k-means-clustering-using-mlib/

#mlib 

Introdução Ao Cluster K-Means Usando MLIB

O agrupamento K- means é um dos algoritmos que o aprendizado de máquina não supervisionado suporta, portanto, antes de avançar com o K-means, vamos ter conhecimento prévio do método de aprendizado não supervisionado. Neste método, não temos rótulos predefinidos ao contrário do método supervisionado , portanto, não desenhamos previsões, mas fazemos clusters/grupos deles para que os dados possam ser segmentados de acordo com os recursos que são alimentados ao modelo.

Fonte da imagem: Bookdown

Qual abordagem o agrupamento K-Means segue?

Como discutido, esse algoritmo faz parte do aprendizado não supervisionado, portanto, em vez de fazer previsões, segmentaremos esses dados com base no número diferente de clusters. K-means segue alguns passos matemáticos que são importantes para discutir:

Etapa 1: selecione o número de clusters e há algumas maneiras de selecionar o número apropriado de clusters, como o método cotovelo e o conhecimento do domínio .

Passo 2: Atribuindo os K pontos ou podemos dizer também atribuindo aleatoriamente os centroides do conjunto de dados.

Passo 3: No último passo cada ponto K será ajustado próximo ao seu centróide mais próximo que eventualmente formará os clusters/grupo .

Ok! Chega de teorias agora vamos sujar as mãos na implementação do cluster K-means no conjunto de dados de cluster oficial do Spark . Embora esse conjunto de dados seja muito pequeno e peculiar, ainda assim podemos explicar cada conceito de agrupamento K-means usando o MLIB do PySpark.

Iniciando o objeto Spark

Esta etapa em qualquer projeto relacionado ao Spark é a primeira coisa que precisamos fazer criando e instanciando o ambiente PySpark para que possamos acessar todos os seus utilitários e funções necessários para implementar o algoritmo de clustering K-means.

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('intro_cluster').getOrCreate()
spark

Resultado:

Inferência: Em primeiro lugar, o objeto SparkSession é chamado do módulo SQL do PySpark, então criamos a sessão intro_cluster usando a função getOrCreate() incorporada pela função builder().

from pyspark.ml.clustering import KMeans

Inferência: No PySpark, importamos todos os algoritmos de classificação como classificador de árvore de decisão, classificador GBT, classificador de floresta aleatória e regressão logística da classe de classificação da mesma forma que importamos o objeto KMeans da classe de cluster .

Lendo o conjunto de dados

Como mencionado anteriormente, este é o conjunto de dados fornecido pelo spark em seu repositório oficial do GitHub , esse conjunto de dados é bastante pequeno , então não se deve esperar resultados do mundo real, mas certamente pode ajudar a entender o conceito de implementação prática do k -significa agrupamento.

dataset_kmeans = spark.read.format("libsvm").load("sample_kmeans_data.txt")
dataset_kmeans.show()

Resultado:

Inferência: Aqui observe que estamos lendo o conjunto de dados após convertê-lo no formato de lib-svm , pois o conjunto de dados está no formato de lib-svm e então fica fácil de carregar. Mais tarde, estamos olhando para o conjunto de dados usando a função show .

dataset_kmeans.head(5)

Resultado:

[Row(label=0.0, features=SparseVector(3, {})),
 Row(label=1.0, features=SparseVector(3, {0: 0.1, 1: 0.1, 2: 0.1})),
 Row(label=2.0, features=SparseVector(3, {0: 0.2, 1: 0.2, 2: 0.2})),
 Row(label=3.0, features=SparseVector(3, {0: 9.0, 1: 9.0, 2: 9.0})),
 Row(label=4.0, features=SparseVector(3, {0: 9.1, 1: 9.1, 2: 9.1}))]

Inferência: Existe um outro método para dar uma espiada no conjunto de dados, ou seja, a função head que retorna todos os nomes das colunas com seus valores correspondentes. Observe que os recursos estão sendo retornados como SparseVector .

dataset_kmeans.printSchema()

Resultado:

root
 |-- label: double (nullable = true)
 |-- features: vector (nullable = true)

Inferência: Se alguém quiser saber como é o esquema do conjunto de dados, pode usar a função de esquema de impressão (). Aqui ele retornou duas colunas, uma é o rótulo e a outra é a coluna de recursos no formato vetorial .

Implementação

Como sabemos que não prevemos nenhum rótulo no K-means, costumávamos fazer um cluster para segmentar os dados da melhor maneira possível, mas aqui vem a parte complexa, pois não há maneiras 100% ideais de encontrar o melhor número de clusters qualquer um deve ter o conhecimento de domínio incrível ou o método cotovelo , às vezes para o problema mais fácil, podemos dar uma chance ao método de acerto e teste , é isso que vamos fazer aqui:

1. Quando clusters = 2 , ou seja, quando o conjunto de dados será separado em dois grupos.
2. Quando clusters = 3 , ou seja, quando o conjunto de dados será separado em três grupos.

Quando clusters = 2

kmeans_2_cluster = KMeans().setK(2).setSeed(1)

Inferência: O código acima é a maneira como definimos o número de clusters do método set() . Observe que estamos usando a função liquid () , bem como o KMeans para escolher o número aleatório de dados para cada grupo, portanto, se definirmos um número apropriado, após cada execução, ele terá a mesma distribuição aleatória .

first_model = kmeans_2_cluster.fit(dataset_kmeans)

Inferência: Agora estamos ajustando o modelo KMeans, ou seja, treinando o modelo com base no conjunto de dados disponível. Observe que estamos alimentando os dados completos para treinamento , pois não temos os rótulos, portanto, não faz sentido dividir o conjunto de dados .

predictions_first_model = first_model.transform(dataset_kmeans)
predictions_first_model.show()

Resultado:

Inferência: Agora é hora de fazer algumas previsões (aqui vamos fazer um cluster relevante com base nos dados de entrada) e para isso, estamos usando o método transform em todo o conjunto de dados. Quando vimos a saída, podemos ver que existem dois grupos, um marcado como 1 e outro como 2 .

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

Inferência: Construir o modelo é uma coisa e testá-lo e avaliá-lo é mais importante, pois nos permitirá considerar se esse modelo é bom ou precisa de alterações. Portanto, estamos usando o objeto avaliador de agrupamento para obter alguns métodos de avaliação do Kmeans.

silhouette_2_clusters = evaluator.evaluate(predictions_first_model)
print("Silhouette evaluation results = " + str(silhouette_2_clusters))

Resultado:

Silhouette evaluation results = 0.9997530305375207

Inferência: A silhueta é um método estatístico que verifica a consistência dentro dos agrupamentos de dados . Seu valor de coeficiente varia entre [-1,1] quanto mais positivo o coeficiente, melhor quanto mais o ponto de dados estiver dentro desse cluster específico.

two_centroid = first_model.clusterCenters()
print("Center of clusters: ")
for c in two_centroid:
    print(c)

Resultado:

Center of clusters: 
[9.1 9.1 9.1]
[0.1 0.1 0.1]

Inferência: Conhecer o centro/centroide de cada cluster é muito importante, pois nos ajuda a saber o quão separáveis ​​eles são uns dos outros . Na saída, pode-se ver que existem dois clusters, pois escolhemos o número de K (clusters) como 2 .

Quando clusters = 3

kmeans_3_clusters = KMeans().setK(3).setSeed(1)
second_model = kmeans_3_clusters.fit(dataset_kmeans)
predictions_second_model = second_model.transform(dataset_kmeans)

Inferência: Agora é hora de verificar como nosso modelo irá se comportar quando escolhermos ter três clusters e para isso o processo é quase o mesmo aqui vamos definir o valor K como 3 ou seja 3 grupos então vamos ajustar/treinar os dados completos ( a razão que eu já discuti) no último método de transformação de previsões de desenho vem para resgatar.

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

silhouette_3_clusters = evaluator.evaluate(predictions_second_model)
print("Silhouette evaluation results = " + str(silhouette_3_clusters))

Resultado:

Silhouette evaluation results = 0.6248737134600261

Inferência: Aqui, se compararmos a distância da Silhouette quando os clusters eram 2, pode-se concluir que devemos usar apenas 2 clusters, pois isso nos dá melhores resultados.

three_centroid = second_model.clusterCenters()
print("Center of clusters: ")
for c in three_centroid:
    print(c)

Resultado:

Center of clusters: 
[9.1 9.1 9.1]
[0.05 0.05 0.05]
[0.2 0.2 0.2]

Inferência: O único propósito de construir o modelo com um valor de 3-K é comparar ambos e escolher o melhor valor de K possível aqui podemos ver um valor de três centróides.

Conclusão do agrupamento K-Means

Estamos no final do jogoNesta seção, veremos tudo o que fizemos até agora neste artigo em termos de implementação prática. Desde a introdução ao algoritmo K-means e sua forma de funcionamento, passamos a comparar dois casos diferentes e escolhemos o melhor.

1. Primeiramente, discutimos como o algoritmo K-Means funciona e, em seguida, configuramos uma plataforma PySpark para que possamos implementá-lo e obter uma experiência prática.
2. Em seguida, lemos o conjunto de dados oficial do exemplo de documentação do PySpark e também analisamos o Schema e obtivemos um entendimento básico do mesmo.
3. Então, por último, construímos o modelo K-means em dois casos (quando os clusters são 2 e 3 ) e depois de ver os resultados da avaliação concluímos que para esses dados específicos quando os clusters eram 2, ele teve um desempenho melhor .

Aqui está o link do repositório para este artigo. Espero que tenha gostado do meu artigo sobre Introdução aos métodos de árvore em MLIB. Se você tiver alguma opinião ou dúvida, comente abaixo.

Fonte: https://www.analyticsvidhya.com/blog/2022/07/introduction-to-k-means-clustering-using-mlib/

#mlib 

Giới Thiệu Về K-Means Clustering Sử Dụng MLIB

K- means clustering là một trong những thuật toán mà máy học không giám sát hỗ trợ, do đó trước khi tiếp tục với K-mean, chúng ta hãy có kiến ​​thức nền tảng về phương pháp học không giám sát. Trong phương pháp này, chúng tôi không có các nhãn được xác định trước không giống như phương pháp được giám sát , do đó chúng tôi không vẽ các dự đoán mà tạo các cụm / nhóm từ chúng để dữ liệu có thể được phân đoạn theo các tính năng được cung cấp cho mô hình.

Nguồn hình ảnh: Bookdown

Phương pháp phân cụm K-Means tuân theo cách tiếp cận nào?

Như đã thảo luận rằng thuật toán này là một phần của học tập không giám sát, vì vậy thay vì đưa ra dự đoán, chúng tôi sẽ phân đoạn dữ liệu đó dựa trên số lượng các cụm khác nhau. K-mean tuân theo một số bước toán học quan trọng cần thảo luận:

Bước 1: Chọn số lượng cụm, và có một số cách để chọn số lượng cụm thích hợp như phương pháp khuỷu tay và kiến ​​thức miền .

Bước 2: Gán điểm K hay cũng có thể nói là gán ngẫu nhiên các trọng tâm từ tập dữ liệu.

Bước 3: Trong bước cuối cùng, mỗi điểm K sẽ được điều chỉnh chặt chẽ về phía tâm gần nhất của nó mà cuối cùng sẽ tạo thành các cụm / nhóm .

Được chứ! Đủ các lý thuyết bây giờ chúng ta hãy bắt tay vào việc triển khai phân cụm K-means trên tập dữ liệu phân nhóm chính thức của Spark . Mặc dù tập dữ liệu này rất nhỏ và đặc biệt vẫn đủ để chúng ta có thể giải thích từng khái niệm về phân cụm K-mean bằng cách sử dụng MLIB của PySpark.

Khởi tạo Đối tượng Tia lửa

Bước này trong bất kỳ dự án nào liên quan đến tia lửa là điều đầu tiên chúng ta phải làm bằng cách tạo và khởi tạo môi trường PySpark để chúng ta có thể truy cập vào tất cả các tiện ích và chức năng của nó được yêu cầu để triển khai thuật toán phân cụm K-mean.

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('intro_cluster').getOrCreate()
spark

Đầu ra:

Suy luận: Đối tượng SparkSession đầu tiên và quan trọng nhất được gọi từ mô-đun SQL của PySpark, sau đó chúng tôi tạo phiên int_cluster bằng cách sử dụng hàm getOrCreate () được kết hợp bởi hàm builder ().

from pyspark.ml.clustering import KMeans

Suy luận: Trong PySpark, chúng tôi nhập tất cả các thuật toán phân loại như bộ phân loại cây quyết định, bộ phân loại GBT, bộ phân loại rừng ngẫu nhiên và hồi quy logistic từ lớp phân loại giống như cách chúng tôi nhập đối tượng KMeans từ lớp phân cụm .

Đọc tập dữ liệu

Như đã đề cập trước đó rằng đây là tập dữ liệu được cung cấp bởi spark trong kho lưu trữ GitHub chính thức của họ , tập dữ liệu này khá nhỏ nên người ta không nên mong đợi kết quả trong thế giới thực nhưng chắc chắn nó có thể giúp hiểu khái niệm thực tế triển khai k -means phân cụm.

dataset_kmeans = spark.read.format("libsvm").load("sample_kmeans_data.txt")
dataset_kmeans.show()

Đầu ra:

Suy luận: Ở đây lưu ý rằng chúng ta đang đọc tập dữ liệu sau khi chuyển đổi nó ở định dạng lib-svm vì tập dữ liệu ở dạng lib-svm và sau đó nó trở nên dễ dàng tải. Sau đó, chúng tôi sẽ xem xét tập dữ liệu bằng cách sử dụng hàm hiển thị .

dataset_kmeans.head(5)

Đầu ra:

[Row(label=0.0, features=SparseVector(3, {})),
 Row(label=1.0, features=SparseVector(3, {0: 0.1, 1: 0.1, 2: 0.1})),
 Row(label=2.0, features=SparseVector(3, {0: 0.2, 1: 0.2, 2: 0.2})),
 Row(label=3.0, features=SparseVector(3, {0: 9.0, 1: 9.0, 2: 9.0})),
 Row(label=4.0, features=SparseVector(3, {0: 9.1, 1: 9.1, 2: 9.1}))]

Suy luận: Có một phương pháp khác để xem trước tập dữ liệu, tức là hàm head trả về tất cả các tên cột với các giá trị tương ứng của chúng. Lưu ý rằng các tính năng đang được trả về dưới dạng SparseVector .

dataset_kmeans.printSchema()

Đầu ra:

root
 |-- label: double (nullable = true)
 |-- features: vector (nullable = true)

Suy luận: Nếu một người muốn biết Lược đồ của tập dữ liệu trông như thế nào thì họ có thể sử dụng hàm print schema (). Ở đây nó đã trả về hai cột một là nhãn và cột kia là cột tính năng ở định dạng vectơ .

Thực hiện

Như chúng tôi biết rằng chúng tôi không dự đoán bất kỳ nhãn nào trong K-means thay vào đó chúng tôi đã sử dụng để tạo một cụm để phân đoạn dữ liệu theo cách tốt nhất có thể, nhưng ở đây có phần phức tạp vì không có cách nào tối ưu 100% để tìm ra số lượng cụm hoặc một trong hai cụm nên có kiến ​​thức miền tuyệt vời hoặc phương pháp khuỷu tay , đôi khi đối với vấn đề dễ dàng hơn, chúng tôi có thể đưa ra một phương pháp để đánh trúng và thử nghiệm , đó là những gì chúng tôi sẽ làm ở đây:

1. Khi cluster = 2 tức là khi tập dữ liệu sẽ được tách thành hai nhóm.
2. Khi cluster = 3 tức là khi tập dữ liệu sẽ được tách thành ba nhóm.

Khi các cụm = 2

kmeans_2_cluster = KMeans().setK(2).setSeed(1)

Suy luận: Đoạn mã trên là cách chúng ta thiết lập số lượng cụm từ phương thức set () . Xin lưu ý rằng chúng tôi đang sử dụng hàm giải quyết () cũng như KMeans để chọn số lượng dữ liệu ngẫu nhiên cho mỗi nhóm, vì vậy nếu chúng tôi đặt một số thích hợp thì sau mỗi lần thực thi, nó sẽ có cùng một phân phối ngẫu nhiên .

first_model = kmeans_2_cluster.fit(dataset_kmeans)

Suy luận: Bây giờ chúng tôi đang điều chỉnh mô hình KMeans tức là đào tạo mô hình dựa trên tập dữ liệu có sẵn. Lưu ý rằng chúng tôi đang cung cấp dữ liệu hoàn chỉnh để đào tạo vì chúng tôi không có nhãn, do đó không có ích lợi gì khi chia nhỏ tập dữ liệu .

predictions_first_model = first_model.transform(dataset_kmeans)
predictions_first_model.show()

Đầu ra:

Suy luận: Bây giờ là lúc đưa ra một số dự đoán (ở đây chúng ta hãy tạo một cụm có liên quan dựa trên dữ liệu đầu vào) và đối với điều đó, chúng tôi đang sử dụng phương pháp biến đổi trên toàn bộ tập dữ liệu. Khi chúng tôi xem kết quả, chúng tôi có thể thấy rằng có hai nhóm, một nhóm được gắn thẻ là 1 và nhóm khác là 2 .

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

Suy luận: Xây dựng mô hình là một chuyện và việc thử nghiệm và đánh giá nó quan trọng hơn vì nó sẽ cho phép chúng ta xem xét liệu mô hình này có tốt để sử dụng hay cần bất kỳ thay đổi nào. Do đó, chúng tôi đang sử dụng đối tượng người đánh giá phân cụm để có được một số phương pháp đánh giá Kmeans.

silhouette_2_clusters = evaluator.evaluate(predictions_first_model)
print("Silhouette evaluation results = " + str(silhouette_2_clusters))

Đầu ra:

Silhouette evaluation results = 0.9997530305375207

Suy luận: Hình bóng là một phương pháp thống kê kiểm tra tính nhất quán trong các cụm dữ liệu . Giá trị hệ số của nó nằm trong khoảng [-1,1] hệ số càng dương càng tốt thì điểm dữ liệu nằm trong cụm cụ thể đó càng nhiều.

two_centroid = first_model.clusterCenters()
print("Center of clusters: ")
for c in two_centroid:
    print(c)

Đầu ra:

Center of clusters: 
[9.1 9.1 9.1]
[0.1 0.1 0.1]

Suy luận: Để biết về trung tâm / trung tâm của mỗi cụm là rất quan trọng vì chúng giúp chúng ta biết chúng tách biệt với nhau như thế nào . Trong đầu ra, người ta có thể thấy rằng có hai cụm khi chúng ta chọn số lượng K (cụm) là 2 .

Khi các cụm = 3

kmeans_3_clusters = KMeans().setK(3).setSeed(1)
second_model = kmeans_3_clusters.fit(dataset_kmeans)
predictions_second_model = second_model.transform(dataset_kmeans)

Suy luận: Bây giờ là lúc để kiểm tra xem mô hình của chúng ta sẽ hoạt động như thế nào khi chúng ta chọn có ba cụm và vì quá trình đó gần như giống nhau ở đây, chúng tôi sẽ đặt giá trị K là 3 tức là 3 nhóm sau đó chúng tôi sẽ phù hợp / đào tạo dữ liệu hoàn chỉnh ( lý do tôi đã thảo luận) cuối cùng để vẽ dự đoán phương pháp biến đổi đến để giải cứu.

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

silhouette_3_clusters = evaluator.evaluate(predictions_second_model)
print("Silhouette evaluation results = " + str(silhouette_3_clusters))

Đầu ra:

Silhouette evaluation results = 0.6248737134600261

Suy luận: Ở đây nếu chúng ta so sánh khoảng cách Silhouette khi các cụm là 2 thì người ta có thể kết luận rằng chúng ta chỉ nên đi với 2 cụm vì nó mang lại cho chúng ta kết quả tốt hơn.

three_centroid = second_model.clusterCenters()
print("Center of clusters: ")
for c in three_centroid:
    print(c)

Đầu ra:

Center of clusters: 
[9.1 9.1 9.1]
[0.05 0.05 0.05]
[0.2 0.2 0.2]

Suy luận: Mục đích duy nhất của việc xây dựng mô hình với giá trị 3-K là so sánh cả hai và chọn giá trị K tốt nhất có thể ở đây, chúng ta có thể thấy giá trị ba trung tâm.

Kết luận về K-Means Clustering

Chúng tôi đang ở trong trò chơi cuối cùng. Từ phần giới thiệu về thuật toán K-mean và cách hoạt động của nó, chúng tôi đã so sánh hai trường hợp khác nhau và chọn trường hợp tốt nhất.

1. Trước tiên, chúng tôi thảo luận về cách hoạt động của thuật toán K-Means và sau đó thiết lập nền tảng PySpark để chúng tôi có thể triển khai nó và có được trải nghiệm thực tế.
2. Sau đó, chúng tôi đọc tập dữ liệu chính thức từ ví dụ tài liệu PySpark và cũng phân tích Lược đồ và hiểu cơ bản về điều này.
3. Sau đó, cuối cùng, chúng tôi xây dựng mô hình K-mean trên hai trường hợp (khi các cụm là 2 và 3 ) và sau khi xem kết quả đánh giá, chúng tôi kết luận rằng đối với dữ liệu cụ thể này khi các cụm là 2, nó hoạt động tốt hơn .

Đây là liên kết repo đến bài viết này. Tôi hy vọng bạn thích bài viết của tôi về Giới thiệu các phương pháp cây trong MLIB. Nếu bạn có bất kỳ ý kiến ​​hoặc câu hỏi nào, hãy bình luận bên dưới.

Nguồn: https://www.analyticsvidhya.com/blog/2022/07/introduction-to-k-means-clustering-using-mlib/

#mlib 

Introducción A La Agrupación En Clústeres De K-Means Utilizando MLIB

El agrupamiento de K- means es uno de los algoritmos que admite el aprendizaje automático no supervisado , por lo tanto, antes de avanzar con K-means, tengamos un conocimiento previo del método de aprendizaje no supervisado. En este método, no tenemos etiquetas predefinidas a diferencia del método supervisado , por lo tanto, no dibujamos predicciones, sino que hacemos clústeres/grupos a partir de ellas para que los datos puedan segmentarse de acuerdo con las características que se alimentan al modelo.

Fuente de la imagen: Bookdown

¿Qué enfoque sigue el agrupamiento de K-Means?

Como se discutió, este algoritmo es parte del aprendizaje no supervisado, por lo que en lugar de hacer predicciones, segmentaremos esos datos en función de la diferente cantidad de grupos. K-means sigue algunos pasos matemáticos que es importante discutir:

Paso 1: seleccione la cantidad de grupos, y hay algunas formas de seleccionar la cantidad adecuada de grupos, como el método del codo y el conocimiento del dominio .

Paso 2: Asignar los puntos K o también podemos decir asignar aleatoriamente los centroides del conjunto de datos.

Paso 3: En el último paso, cada punto K se ajustará estrechamente hacia su centroide más cercano que eventualmente formará los grupos/grupos .

¡De acuerdo! Ya basta de teorías, vamos a ponernos manos a la obra para implementar el agrupamiento de K-means en el conjunto de datos de agrupamiento oficial de Spark . Aunque este conjunto de datos es muy pequeño y lo suficientemente peculiar como para que podamos explicar cada concepto de agrupación de K-means usando MLIB de PySpark.

Iniciando el objeto Spark

Este paso en cualquier proyecto relacionado con Spark es lo primero que tenemos que hacer al crear e instanciar el entorno PySpark para que podamos acceder a todas sus utilidades y funciones necesarias para implementar el algoritmo de agrupación en clústeres K-means.

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('intro_cluster').getOrCreate()
spark

Producción:

Inferencia: en primer lugar, se llama al objeto SparkSession desde el módulo SQL de PySpark, luego creamos la sesión intro_cluster usando la función getOrCreate() incorporada por la función builder().

from pyspark.ml.clustering import KMeans

Inferencia: en PySpark importamos todos los algoritmos de clasificación como el clasificador de árbol de decisión, el clasificador GBT, el clasificador de bosque aleatorio y la regresión logística de la clase de clasificación de la misma manera que importamos el objeto KMeans de la clase de agrupación .

Lectura del conjunto de datos

Como se mencionó anteriormente, este es el conjunto de datos proporcionado por Spark en su repositorio oficial de GitHub , este conjunto de datos es bastante pequeño , por lo que no se deben esperar resultados del mundo real, pero seguramente puede ayudar a comprender el concepto de implementar prácticamente el k -significa agrupamiento.

dataset_kmeans = spark.read.format("libsvm").load("sample_kmeans_data.txt")
dataset_kmeans.show()

Producción:

Inferencia: aquí observe que estamos leyendo el conjunto de datos después de convertirlo en el formato de lib-svm ya que el conjunto de datos tiene la forma de lib-svm y luego se vuelve fácil de cargar. Más tarde estamos viendo el conjunto de datos usando la función show .

dataset_kmeans.head(5)

Producción:

[Row(label=0.0, features=SparseVector(3, {})),
 Row(label=1.0, features=SparseVector(3, {0: 0.1, 1: 0.1, 2: 0.1})),
 Row(label=2.0, features=SparseVector(3, {0: 0.2, 1: 0.2, 2: 0.2})),
 Row(label=3.0, features=SparseVector(3, {0: 9.0, 1: 9.0, 2: 9.0})),
 Row(label=4.0, features=SparseVector(3, {0: 9.1, 1: 9.1, 2: 9.1}))]

Inferencia: hay otro método para echar un vistazo al conjunto de datos, es decir, la función principal que devuelve todos los nombres de columna con sus valores correspondientes. Tenga en cuenta que las características se devuelven como SparseVector .

dataset_kmeans.printSchema()

Producción:

root
 |-- label: double (nullable = true)
 |-- features: vector (nullable = true)

Inferencia: si uno quiere saber cómo se ve el esquema del conjunto de datos, puede usar la función de impresión de esquema (). Aquí ha devuelto dos columnas, una es la etiqueta y la otra es la columna de características en formato vectorial .

Implementación

Como sabemos que no predecimos ninguna etiqueta en K-means, en su lugar, solíamos hacer un clúster para segmentar los datos de la mejor manera posible, pero aquí viene la parte compleja, ya que no hay formas 100% óptimas para encontrar la mejor . cantidad de clústeres , cualquiera de los dos debe tener el increíble conocimiento del dominio o el método del codo , a veces para el problema más fácil, podemos darle una oportunidad al método de golpe y prueba , eso es lo que haremos aquí:

1. Cuando clusters = 2 , es decir, cuando el conjunto de datos se separará en dos grupos.
2. Cuando clusters = 3 , es decir, cuando el conjunto de datos se separará en tres grupos.

Cuando agrupaciones = 2

kmeans_2_cluster = KMeans().setK(2).setSeed(1)

Inferencia: el código anterior es la forma en que establecemos el número de grupos del método set() . Tenga en cuenta que estamos usando la función liquidada () así como KMeans para elegir el número aleatorio de datos para cada grupo, por lo que si establecemos un número apropiado, después de cada ejecución, tomará la misma distribución aleatoria .

first_model = kmeans_2_cluster.fit(dataset_kmeans)

Inferencia: ahora estamos ajustando el modelo KMeans, es decir, entrenando el modelo en función del conjunto de datos disponible. Tenga en cuenta que estamos alimentando los datos completos para el entrenamiento ya que no tenemos las etiquetas, por lo tanto, no tiene sentido dividir el conjunto de datos .

predictions_first_model = first_model.transform(dataset_kmeans)
predictions_first_model.show()

Producción:

Inferencia: ahora es el momento de hacer algunas predicciones (aquí hagamos un grupo relevante basado en los datos de entrada) y para eso, estamos usando el método de transformación en todo el conjunto de datos. Cuando vimos la salida, podemos ver que hay dos grupos, uno está etiquetado como 1 y otro como 2 .

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

Inferencia: construir el modelo es una cosa y probarlo y evaluarlo es más importante, ya que nos permitirá considerar si este modelo está listo para funcionar o si necesita algún cambio. Por lo tanto, estamos utilizando el objeto evaluador de agrupamiento para obtener algunos métodos de evaluación de Kmeans.

silhouette_2_clusters = evaluator.evaluate(predictions_first_model)
print("Silhouette evaluation results = " + str(silhouette_2_clusters))

Producción:

Silhouette evaluation results = 0.9997530305375207

Inferencia: la silueta es un método estadístico que verifica la consistencia dentro de los grupos de datos . El valor de su coeficiente oscila entre [-1,1] cuanto más positivo sea el coeficiente, mejor cuanto más se encuentre el punto de datos dentro de ese grupo en particular.

two_centroid = first_model.clusterCenters()
print("Center of clusters: ")
for c in two_centroid:
    print(c)

Producción:

Center of clusters: 
[9.1 9.1 9.1]
[0.1 0.1 0.1]

Inferencia: conocer el centro/centroide de cada grupo es muy importante ya que nos ayudan a saber qué tan separables son entre sí . En la salida, se puede ver que hay dos grupos, ya que elegimos el número de K (grupos) como 2 .

Cuando racimos = 3

kmeans_3_clusters = KMeans().setK(3).setSeed(1)
second_model = kmeans_3_clusters.fit(dataset_kmeans)
predictions_second_model = second_model.transform(dataset_kmeans)

Inferencia: ahora es el momento de verificar cómo funcionará nuestro modelo cuando elijamos tener tres grupos y para eso el proceso es casi el mismo aquí estableceremos el valor K como 3, es decir , 3 grupos , luego ajustaremos/entrenaremos los datos completos ( la razón que ya he discutido) al final para dibujar predicciones , el método de transformación viene al rescate.

from pyspark.ml.evaluation import ClusteringEvaluator
evaluator = ClusteringEvaluator()

silhouette_3_clusters = evaluator.evaluate(predictions_second_model)
print("Silhouette evaluation results = " + str(silhouette_3_clusters))

Producción:

Silhouette evaluation results = 0.6248737134600261

Inferencia: aquí, si comparamos la distancia de la silueta cuando los grupos eran 2, entonces se puede concluir que debemos ir con 2 grupos solo, ya que nos está dando mejores resultados.

three_centroid = second_model.clusterCenters()
print("Center of clusters: ")
for c in three_centroid:
    print(c)

Producción:

Center of clusters: 
[9.1 9.1 9.1]
[0.05 0.05 0.05]
[0.2 0.2 0.2]

Inferencia: El único propósito de construir el modelo con un valor de 3-K es comparar ambos y elegir el mejor valor de K posible. Aquí podemos ver un valor de tres centroides.

Conclusión sobre el agrupamiento de K-Means

Estamos en el final del juego, muchachos. En esta sección, repasaremos todo lo que hicimos hasta ahora en este artículo en términos de implementación práctica. A partir de la introducción al algoritmo K-means y su forma de operar, pasamos por comparar dos casos diferentes y elegimos el mejor.

1. En primer lugar, discutimos cómo funciona el algoritmo K-Means y luego configuramos una plataforma PySpark para que podamos implementarlo y obtener una experiencia práctica.
2. Luego, leemos el conjunto de datos oficial del ejemplo de documentación de PySpark y también analizamos el esquema y obtuvimos una comprensión básica del mismo.
3. Luego, por último, construimos el modelo de K-medias en dos casos (cuando los conglomerados son 2 y 3 ) y, después de ver los resultados de la evaluación, concluimos que para estos datos en particular, cuando los conglomerados eran 2, se desempeñó mejor .

Aquí está el enlace del repositorio a este artículo. Espero que les haya gustado mi artículo sobre Introducción a los métodos de árbol en MLIB. Si tiene alguna opinión o pregunta, comente a continuación.

Fuente: https://www.analyticsvidhya.com/blog/2022/07/introduction-to-k-means-clustering-using-mlib/

#mlib 

Introduction to K-Means Clustering using MLIB

K-means clustering is one of the algorithms which unsupervised machine learning supports hence before moving forward with K-means let’s have background knowledge of the unsupervised learning method. In this method, we don’t have predefined labels unlike the supervised method hence we don’t draw predictions but make clusters/groupss out of them so that the data could get segmented according to the features that are fed to the model.

See more at: https://www.analyticsvidhya.com/blog/2022/07/introduction-to-k-means-clustering-using-mlib/

#mlib