الگوریتم DENCLUE چیست؟ آموزش، پیاده‌سازی و کاربرد در خوشه‌بندی داده‌ها

1. مقدمه

در بخش قبل، الگوریتم DENCLUE از دیدگاه نظری، بر اساس تخمین چگالی هسته (Kernel Density Estimation) و مفهوم جاذب‌های چگالی بررسی شد. در این بخش هدف، پیاده‌سازی عملی الگوریتم و بررسی عملکرد آن روی داده‌های واقعی است.

از آنجا که DENCLUE به‌صورت پیش‌فرض در کتابخانه‌های رایج یادگیری ماشین مانند Scikit-learn وجود ندارد، در این فصل یک پیاده‌سازی ساده و قابل فهم از الگوریتم با Python ارائه می‌شود. ابتدا ابزارها و کتابخانه‌های موردنیاز معرفی شده، سپس مراحل اجرای الگوریتم و نحوه تحلیل خروجی بررسی خواهد شد.

در ادامه، عملکرد الگوریتم روی دیتاست‌های واقعی ارزیابی می‌شود تا کاربرد DENCLUE در مسائل واقعی خوشه‌بندی مشخص شود.

.

۲. محیط اجرا، کتابخانه‌ها و آماده‌سازی داده ورودی

۲.۱ محیط اجرا و ابزارهای موردنیاز

برای پیاده‌سازی الگوریتم DENCLUE از زبان Python استفاده می‌شود. کتابخانه‌های موردنیاز شامل ابزارهای محاسبات عددی، آماده‌سازی داده، نمایش نتایج و ارزیابی خوشه‌بندی هستند.

کتابخانه	کاربرد در پیاده‌سازی
NumPy	انجام محاسبات ماتریسی، فاصله اقلیدسی و محاسبات مربوط به تابع چگالی
Pandas	خواندن، مدیریت و پردازش دیتاست‌های واقعی
Matplotlib	نمایش گرافیکی خوشه‌ها و نتایج الگوریتم
Scikit-learn	استانداردسازی داده‌ها، کاهش ابعاد و محاسبه معیارهای ارزیابی
SciPy	انجام محاسبات علمی و بهینه‌سازی‌های احتمالی

.

۲.۲ کتابخانه‌های مورد استفاده

کدهای این فصل با کتابخانه‌های زیر اجرا می‌شوند:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
from sklearn.decomposition import PCA

۲.۳ آماده‌سازی داده ورودی

الگوریتم DENCLUE با داده‌های عددی و فضای پیوسته کار می‌کند. داده ورودی باید به صورت یک ماتریس ویژگی تعریف شود:

در این ساختار:

• هر سطر نشان‌دهنده یک نمونه داده است.
• هر ستون نشان‌دهنده یک ویژگی است.

از آنجا که DENCLUE بر اساس فاصله اقلیدسی و محاسبه چگالی کار می‌کند، قبل از اجرای الگوریتم داده‌ها باید استانداردسازی شوند:

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

۳. پیاده‌سازی الگوریتم DENCLUE در Python

۳.۱ مراحل پیاده‌سازی الگوریتم

قبل از ارائه کد، مراحل اجرای الگوریتم به صورت خلاصه:

• مرحله ۱: دریافت و آماده‌سازی داده‌ها
  • داده ورودی به صورت ماتریس ویژگی دریافت می‌شود.
  • هر نمونه به عنوان یک نقطه در فضای چندبعدی در نظر گرفته می‌شود.
• مرحله ۲: استانداردسازی داده‌ها
  • برای جلوگیری از تأثیر نامتناسب ویژگی‌ها، داده‌ها با استفاده از StandardScaler مقیاس‌بندی می‌شوند.
• مرحله ۳: محاسبه میزان تأثیر نقاط داده
  • برای هر نقطه، میزان تأثیر سایر نقاط با استفاده از تابع هسته گاوسی محاسبه می‌شود.
  • نقاط نزدیک‌تر تأثیر بیشتری در مقدار چگالی دارند.
• مرحله ۴: محاسبه چگالی هر نقطه
  • مجموع تأثیر تمام نقاط اطراف، مقدار چگالی نقطه را مشخص می‌کند.
  • نقاط موجود در نواحی پرتراکم دارای مقدار چگالی بیشتری هستند.
• مرحله ۵: حرکت نقاط به سمت جاذب چگالی
  • با استفاده از فرآیند صعود گرادیان، هر نقطه به سمت بیشترین مقدار چگالی حرکت می‌کند.
  • این فرآیند تا رسیدن به نقطه همگرایی ادامه پیدا می‌کند.
• مرحله ۶: استخراج جاذب‌های چگالی
  • نقاطی که به یک جاذب مشترک همگرا می‌شوند، در یک خوشه قرار می‌گیرند.
• مرحله ۷: حذف نقاط نویزی
  • اگر چگالی جاذب کمتر از آستانه تعیین‌شده باشد، نقاط مربوطه به عنوان نویز علامت‌گذاری می‌شوند.
• مرحله ۸: نمایش و تحلیل خروجی
  • برچسب خوشه‌ها، نقاط نویزی و جاذب‌های نهایی نمایش داده می‌شوند.

.

۳.۲ پیاده‌سازی کامل الگوریتم DENCLUE با Python

import numpy as np
import matplotlib.pyplot as plt

class DENCLUE:
    """
    پیاده سازی ساده و آموزشی الگوریتم DENCLUE
    بر اساس Kernel Density Estimation و Gradient Ascent
    """

    def __init__(self, bandwidth=0.5, epsilon=1e-5, density_threshold=0.1):

        self.bandwidth = bandwidth
        self.epsilon = epsilon
        self.density_threshold = density_threshold

        self.labels_ = None
        self.attractors_ = None
        self.densities_ = None

    def gaussian_influence(self, x, data):

        # فاصله اقلیدسی بین نقطه و تمام داده‌ها
        distances = np.linalg.norm(data - x, axis=1)

        # تابع نفوذ گاوسی
        influence = np.exp(
            -(distances ** 2) /
            (2 * self.bandwidth ** 2)
        )

        return influence


    def calculate_density(self, x, data):

        influence = self.gaussian_influence(x, data)

        # مقدار چگالی تخمینی
        density = np.mean(influence)

        return density


    def gradient_ascent(self, x, data):

        current_point = np.copy(x)

        while True:

            weights = self.gaussian_influence(
                current_point,
                data
            )

            # حرکت به سمت مرکز جرم وزنی
            new_point = np.sum(
                data * weights[:, np.newaxis],
                axis=0
            ) / np.sum(weights)

            # شرط توقف
            if np.linalg.norm(new_point - current_point) < self.epsilon:
                break

            current_point = new_point

        return current_point


    def fit(self, X):

        X = np.array(X)

        n_samples = X.shape[0]

        attractors = []
        densities = []

        # پیدا کردن جاذب هر نقطه
        for i in range(n_samples):

            attractor = self.gradient_ascent(
                X[i],
                X
            )

            attractors.append(attractor)

            densities.append(
                self.calculate_density(
                    attractor,
                    X
                )
            )

        self.attractors_ = np.array(attractors)
        self.densities_ = np.array(densities)


        # تخصیص خوشه‌ها
        labels = -np.ones(n_samples)

        cluster_centers = []

        cluster_id = 0

        for i in range(n_samples):

            # نقاط کم چگال نویز هستند
            if self.densities_[i] < self.density_threshold:
                continue

            assigned = False

            for j, center in enumerate(cluster_centers):

                if np.linalg.norm(
                    self.attractors_[i] - center
                ) < self.bandwidth:

                    labels[i] = j
                    assigned = True
                    break


            if not assigned:

                cluster_centers.append(
                    self.attractors_[i]
                )

                labels[i] = cluster_id

                cluster_id += 1

        self.labels_ = labels

        return self


# ==========================================================
# اجرای الگوریتم DENCLUE
# ==========================================================

# ایجاد داده آزمایشی
np.random.seed(42)

# خوشه اول
cluster1 = np.random.normal(
    loc=[2, 2],
    scale=0.4,
    size=(50, 2)
)

# خوشه دوم
cluster2 = np.random.normal(
    loc=[7, 7],
    scale=0.5,
    size=(50, 2)
)

# نقاط نویزی
noise = np.random.uniform(
    low=0,
    high=10,
    size=(15, 2)
)

# ترکیب داده‌ها
X = np.vstack(
    [
        cluster1,
        cluster2,
        noise
    ]
)


# ساخت مدل
model = DENCLUE(
    bandwidth=0.7,
    epsilon=1e-5,
    density_threshold=0.15
)

# آموزش مدل
model.fit(X)


# ==========================================================
# نمایش خروجی
# ==========================================================

print("برچسب هر نمونه:")
print(model.labels_)

# تعداد خوشه‌ها
clusters = set(model.labels_)

clusters.discard(-1)

print("\nتعداد خوشه‌های شناسایی شده:")
print(len(clusters))

# تعداد نویز
noise_count = np.sum(model.labels_ == -1)

print("\nتعداد نقاط نویزی:")
print(noise_count)


# ==========================================================
# رسم نتیجه
# ==========================================================

plt.figure(figsize=(8,6))

plt.scatter(
    X[:,0],
    X[:,1],
    c=model.labels_,
    cmap="viridis",
    s=50
)

# نمایش جاذب‌ها

plt.scatter(
    model.attractors_[:,0],
    model.attractors_[:,1],
    marker="x",
    color="red",
    s=100,
    label="Density Attractors"
)

plt.title(
    "DENCLUE Clustering Result"
)

plt.xlabel(
    "Feature 1"
)

plt.ylabel(
    "Feature 2"
)

plt.legend()

plt.grid()

plt.show()

خروجی:

۴. مثال آموزشی کوچک

در این بخش، عملکرد الگوریتم DENCLUE روی یک مجموعه داده کوچک بررسی می‌شود. هدف این مثال، مشاهده نحوه تشکیل خوشه‌ها، پیدا کردن جاذب‌های چگالی و شناسایی نقاط نویزی است.

۴.۱ تعریف داده نمونه

فرض کنید مجموعه‌ای از نقاط دوبعدی داریم که شامل دو ناحیه متراکم و یک نقطه پرت است.

ساختار داده:

• گروه اول: نقاط نزدیک به مرکز (1,1) که یک خوشه متراکم را تشکیل می‌دهند.
• گروه دوم: نقاط نزدیک به مرکز (5,5) که خوشه دوم را ایجاد می‌کنند.
• نقطه نویزی: نقطه (10,10) که به دلیل فاصله زیاد از سایر نقاط، چگالی پایینی دارد.

داده ورودی:

X_toy = np.array([
    [1, 1],
    [1.2, 1.1],
    [0.9, 0.8],

    [5, 5],
    [5.1, 4.9],
    [4.8, 5.2],

    [10, 10]
])

۴.۲ اجرای الگوریتم DENCLUE

در این مرحله، داده‌های نمونه به مدل DENCLUE داده می‌شوند. الگوریتم برای هر نقطه، مسیر حرکت به سمت بیشترین چگالی را محاسبه کرده و جاذب مربوط به آن را پیدا می‌کند.

# ایجاد مدل DENCLUE
model = DENCLUE(
    bandwidth=1.0,
    epsilon=1e-5,
    density_threshold=0.1
)

# اجرای الگوریتم روی داده نمونه
model.fit(X_toy)

# نمایش برچسب خوشه‌ها
print("Cluster Labels:")
print(model.labels_)

خروجی:

۴.۳ تحلیل نتیجه

پس از اجرای الگوریتم DENCLUE، خروجی نشان می‌دهد که داده‌ها به سه گروه تقسیم شده‌اند:

• سه نقطه اول که در اطراف (1,1) قرار دارند، به یک جاذب چگالی مشترک همگرا شده و یک خوشه تشکیل داده‌اند.
• سه نقطه بعدی که در محدوده (5,5) قرار دارند، در خوشه دوم قرار گرفته‌اند.
• نقطه (10,10) به دلیل فاصله زیاد از سایر نقاط، به یک ناحیه چگالی مستقل همگرا شده و الگوریتم آن را به عنوان یک خوشه جداگانه شناسایی کرده است.

در این اجرای خاص، مقدار پارامترهای الگوریتم مانند bandwidth و density_threshold باعث شده است که نقطه پرت به جای حذف شدن، یک جاذب مستقل ایجاد کند. این موضوع اهمیت انتخاب مناسب پارامترهای DENCLUE را نشان می‌دهد.

.

4.4.تفسیر خروجی:

• Cluster 0:شامل سه نقطه اطراف (1,1)
• Cluster 1:شامل سه نقطه اطراف (5,5)
• Cluster 2:شامل نقطه (10,10) که به دلیل مقدار پارامترهای انتخاب‌شده، به عنوان یک ناحیه چگالی مستقل شناسایی شده است.

.

۵. مطالعه موردی اول: شناسایی گروه‌های مشابه دانه‌های گندم با DENCLUE

۵.۱ معرفی مسئله

در این مطالعه، الگوریتم DENCLUE برای خوشه‌بندی نمونه‌های دانه گندم استفاده می‌شود. هدف، شناسایی گروه‌هایی از دانه‌ها با ویژگی‌های مشابه بر اساس ساختار چگالی داده‌ها است.

از آنجا که DENCLUE یک روش یادگیری بدون نظارت است، در فرآیند خوشه‌بندی از برچسب واقعی نمونه‌ها استفاده نمی‌شود و الگوریتم تنها بر اساس فاصله و توزیع داده‌ها، گروه‌های مشابه را پیدا می‌کند.

۵.۲ معرفی دیتاست

دیتاست Seeds از مخزن UCI Machine Learning Repository دریافت شده است.

مشخصات:

ویژگی	مقدار
تعداد نمونه‌ها	210
تعداد ویژگی‌ها	7
نوع داده	عددی
حوزه کاربرد	کشاورزی و تشخیص الگوی محصولات
هدف	خوشه‌بندی انواع دانه گندم

.

۵.۳ کد اجرای مطالعه موردی

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.metrics import silhouette_score

# ==========================================
# دریافت دیتاست Seeds از UCI
# ==========================================

url = (
    "https://archive.ics.uci.edu/ml/"
    "machine-learning-databases/00236/"
    "seeds_dataset.txt"
)

columns = [
    "Area",
    "Perimeter",
    "Compactness",
    "Kernel_Length",
    "Kernel_Width",
    "Asymmetry",
    "Groove_Length",
    "Class"
]

df = pd.read_csv(
    url,
    sep=r"\s+",
    names=columns
)

print("Dataset Shape:")
print(df.shape)


# ==========================================
# حذف برچسب واقعی
# فقط ویژگی‌ها برای DENCLUE
# ==========================================

X = df.drop(
    "Class",
    axis=1
)


# ==========================================
# استانداردسازی
# ==========================================

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)


# ==========================================
# کاهش بعد برای نمایش
# ==========================================

pca = PCA(
    n_components=2
)

X_pca = pca.fit_transform(
    X_scaled
)


print("\nPCA Variance:")
print(
    pca.explained_variance_ratio_.sum()
)


# ==========================================
# اجرای DENCLUE
# ==========================================

model = DENCLUE(

    bandwidth=0.45,

    epsilon=1e-5,

    density_threshold=0.03,

    attractor_radius=0.18

)

model.fit(
    X_pca
)


# ==========================================
# خروجی
# ==========================================

print("\nNumber of clusters:")

clusters = set(
    model.labels_
)

clusters.discard(-1)

print(
    len(clusters)
)


print("\nNumber of noise points:")

print(
    np.sum(
        model.labels_ == -1
    )
)


# ==========================================
# Silhouette
# ==========================================

valid = model.labels_ != -1

if len(set(model.labels_[valid])) > 1:

    score = silhouette_score(
        X_pca[valid],
        model.labels_[valid]
    )

    print("\nSilhouette Score:")

    print(
        round(score,3)
    )


# ==========================================
# رسم خروجی
# ==========================================

plt.figure(
    figsize=(8,6)
)

plt.scatter(
    X_pca[:,0],
    X_pca[:,1],
    c=model.labels_,
    cmap="viridis",
    s=50
)

plt.scatter(
    model.attractors_[:,0],
    model.attractors_[:,1],
    marker="x",
    color="red",
    s=80,
    label="Density Attractors"
)

plt.title(
    "DENCLUE Clustering - Seeds Dataset"
)

plt.xlabel(
    "PCA Component 1"
)

plt.ylabel(
    "PCA Component 2"
)

plt.legend()

plt.grid()

plt.show()

خروجی:

۵.۴ تحلیل نتایج اجرای الگوریتم DENCLUE

پس از اجرای الگوریتم DENCLUE روی دیتاست Seeds، نتایج نشان داد که الگوریتم توانسته است ساختار داده‌ها را بر اساس میدان چگالی به چند ناحیه مجزا تقسیم کند.

خروجی الگوریتم نشان می‌دهد که ۴ خوشه مختلف در داده‌ها شناسایی شده است. هر خوشه شامل نمونه‌هایی است که بر اساس ویژگی‌های هندسی دانه‌های گندم، مانند مساحت، طول و عرض هسته و سایر ویژگی‌های استخراج‌شده، شباهت بیشتری با یکدیگر دارند.

در این آزمایش، هیچ نمونه‌ای به عنوان نویز شناسایی نشد. این موضوع نشان می‌دهد که تمامی نمونه‌های موجود در دیتاست در یکی از نواحی با چگالی مناسب قرار گرفته‌اند و داده پرت قابل توجهی در مجموعه وجود نداشته است.

مقدار Silhouette Score برابر با 0.438 به دست آمد که نشان‌دهنده تفکیک قابل قبول بین خوشه‌های ایجادشده است. این مقدار بیان می‌کند که اگرچه تعدادی از نمونه‌ها در مرز بین خوشه‌ها قرار دارند، اما ساختار کلی داده‌ها به اندازه کافی برای تشکیل گروه‌های مجزا مناسب است.

نمودار خروجی نیز نشان می‌دهد که نقاط داده در چند ناحیه متراکم قرار گرفته‌اند. علامت‌های قرمز نشان‌دهنده جاذب‌های چگالی (Density Attractors) هستند که مرکز نواحی با بیشترین تراکم داده را نمایش می‌دهند. هر نقطه داده در فرآیند Gradient Ascent به سمت یکی از این جاذب‌ها حرکت کرده و در نهایت به خوشه مربوط به آن اختصاص یافته است.

در این مطالعه موردی، الگوریتم DENCLUE توانست بدون استفاده از برچسب‌های واقعی داده و بدون تعیین تعداد خوشه‌ها از قبل، ساختار موجود در داده‌های دانه‌های گندم را بر اساس توزیع چگالی شناسایی کند. این ویژگی، یکی از مزیت‌های اصلی روش‌های خوشه‌بندی مبتنی بر چگالی نسبت به روش‌هایی مانند K-Means است.

.

۶. مطالعه موردی دوم: خوشه‌بندی ویژگی‌های فیزیکی صدف‌ها با الگوریتم DENCLUE

۶.۱ معرفی مسئله

یکی از کاربردهای مهم الگوریتم‌های خوشه‌بندی مبتنی بر چگالی، گروه‌بندی نمونه‌هایی است که ساختار مشخصی در فضای ویژگی دارند اما تعداد خوشه‌ها از قبل مشخص نیست.

در این مطالعه، الگوریتم DENCLUE برای خوشه‌بندی داده‌های مربوط به صدف‌ها (Abalone) استفاده می‌شود. هدف، شناسایی گروه‌هایی از نمونه‌ها با ویژگی‌های فیزیکی مشابه بر اساس توزیع چگالی داده‌ها است.

در این فرآیند، برچسب واقعی نمونه‌ها در اختیار الگوریتم قرار نمی‌گیرد و DENCLUE تنها با استفاده از ویژگی‌های عددی ورودی، نواحی پرتراکم داده را شناسایی می‌کند.

۶.۲ معرفی دیتاست

• دیتاست مورد استفاده: Abalone Dataset
• منبع: UCI Machine Learning Repository
• این دیتاست شامل اندازه‌گیری‌های فیزیکی مربوط به صدف‌ها است و در مسائل تحلیل داده و یادگیری ماشین استفاده می‌شود.

مشخصات دیتاست:

ویژگی	مقدار
تعداد نمونه‌ها	4177
تعداد ویژگی‌ها	8
نوع داده	عددی
حوزه کاربرد	زیست‌شناسی و تحلیل ویژگی‌های موجودات دریایی
هدف	گروه‌بندی نمونه‌های مشابه

ویژگی‌های مورد استفاده:

• Length
• Diameter
• Height
• Whole Weight
• Shucked Weight
• Viscera Weight
• Shell Weight

ویژگی جنسیت (Sex) از فرآیند خوشه‌بندی حذف می‌شود، زیرا داده‌ای دسته‌ای است.

.

۶.۳ آماده‌سازی داده‌ها

مراحل اجرای الگوریتم:

• دریافت دیتاست Abalone
• حذف ویژگی غیرعددی Sex
• استانداردسازی ویژگی‌ها
• کاهش ابعاد داده برای نمایش دوبعدی
• اجرای الگوریتم DENCLUE
• تحلیل خوشه‌های ایجادشده

.

۶.۴ کد اجرای مطالعه موردی

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.metrics import silhouette_score


# ==========================================
# دریافت دیتاست Abalone
# ==========================================

url = (
    "https://archive.ics.uci.edu/ml/"
    "machine-learning-databases/abalone/abalone.data"
)

columns = [
    "Sex",
    "Length",
    "Diameter",
    "Height",
    "Whole_weight",
    "Shucked_weight",
    "Viscera_weight",
    "Shell_weight",
    "Rings"
]

df = pd.read_csv(
    url,
    names=columns
)

print("Dataset Shape:")
print(df.shape)


# ==========================================
# انتخاب ویژگی‌های عددی
# ==========================================

features = [
    "Length",
    "Diameter",
    "Height",
    "Whole_weight",
    "Shucked_weight",
    "Viscera_weight",
    "Shell_weight"
]

X = df[features]


# ==========================================
# استانداردسازی داده‌ها
# ==========================================

scaler = StandardScaler()

X_scaled = scaler.fit_transform(
    X
)


# ==========================================
# کاهش بعد
# ==========================================

pca = PCA(
    n_components=2
)

X_pca = pca.fit_transform(
    X_scaled
)

print("\nPCA Variance:")
print(
    pca.explained_variance_ratio_.sum()
)


# ==========================================
# اجرای DENCLUE
# ==========================================

model = DENCLUE(

    bandwidth=0.35,

    epsilon=1e-5,

    density_threshold=0.04,

    attractor_radius=0.18

)

model.fit(
    X_pca
)


# ==========================================
# خروجی
# ==========================================

print("\nNumber of clusters:")

clusters = set(
    model.labels_
)

clusters.discard(-1)

print(
    len(clusters)
)


print("\nNumber of noise points:")

print(
    np.sum(
        model.labels_ == -1
    )
)


# ==========================================
# ارزیابی
# ==========================================

valid = model.labels_ != -1

if len(set(model.labels_[valid])) > 1:

    score = silhouette_score(
        X_pca[valid],
        model.labels_[valid]
    )

    print("\nSilhouette Score:")

    print(
        round(score,3)
    )


# ==========================================
# نمایش نمودار
# ==========================================

plt.figure(
    figsize=(9,6)
)

plt.scatter(
    X_pca[:,0],
    X_pca[:,1],
    c=model.labels_,
    cmap="viridis",
    s=20
)

plt.scatter(
    model.attractors_[:,0],
    model.attractors_[:,1],
    marker="x",
    color="red",
    s=70,
    label="Density Attractors"
)

plt.title(
    "DENCLUE Clustering - Abalone Dataset"
)

plt.xlabel(
    "PCA Component 1"
)

plt.ylabel(
    "PCA Component 2"
)

plt.legend()

plt.grid()

plt.show()

خروجی:

۶.۵ تحلیل نتایج اجرای الگوریتم DENCLUE

پس از اجرای الگوریتم DENCLUE روی دیتاست Abalone، نتایج نشان داد که الگوریتم توانسته است ساختار چگالی موجود در داده‌ها را شناسایی کرده و نمونه‌ها را در سه گروه اصلی دسته‌بندی کند.

بر اساس خروجی مدل، ۳ خوشه اصلی از داده‌ها استخراج شد. این خوشه‌ها بر اساس شباهت نمونه‌ها در ویژگی‌های فیزیکی صدف‌ها، شامل طول، قطر، ارتفاع و وزن‌های مختلف تشکیل شده‌اند. در این فرآیند، هیچ‌گونه اطلاعات مربوط به گروه‌بندی واقعی داده‌ها در اختیار الگوریتم قرار نگرفت و خوشه‌ها تنها بر اساس توزیع داده‌ها در فضای ویژگی ایجاد شدند.

تعداد نقاط نویزی شناسایی‌شده توسط الگوریتم برابر با ۵ نمونه بود. این مقدار نشان می‌دهد که بخش بسیار کوچکی از داده‌ها در نواحی با چگالی پایین قرار داشته‌اند و الگوریتم توانسته است نمونه‌های غیرمعمول را از ساختار اصلی داده جدا کند.

مقدار Silhouette Score برابر با 0.458 به دست آمد که نشان‌دهنده کیفیت قابل قبول خوشه‌بندی است. این مقدار بیان می‌کند که فاصله نمونه‌های داخل هر خوشه نسبت به فاصله آن‌ها از خوشه‌های دیگر مناسب بوده و خوشه‌های ایجادشده دارای تفکیک نسبی هستند.

در نمودار خروجی مشاهده می‌شود که داده‌ها در سه ناحیه متراکم قرار گرفته‌اند. هر رنگ نشان‌دهنده یک خوشه شناسایی‌شده توسط DENCLUE است و علامت‌های قرمز محل جاذب‌های چگالی (Density Attractors) را نشان می‌دهند. این جاذب‌ها نقاطی هستند که بیشترین تراکم داده در اطراف آن‌ها وجود دارد و سایر نمونه‌ها در فرآیند Gradient Ascent به سمت آن‌ها حرکت کرده‌اند.

این مطالعه موردی نشان می‌دهد که الگوریتم DENCLUE می‌تواند بدون نیاز به تعیین تعداد خوشه‌ها از قبل، ساختارهای پنهان موجود در داده‌های واقعی را بر اساس مفهوم چگالی استخراج کند. همچنین توانایی این الگوریتم در شناسایی نقاط کم‌چگال، آن را برای داده‌هایی که دارای نمونه‌های غیرمعمول هستند مناسب می‌سازد.

نتیجه‌گیری

در این مطالعه، الگوریتم DENCLUE (Density-Based Clustering) به‌عنوان یکی از روش‌های خوشه‌بندی مبتنی بر چگالی مورد بررسی و پیاده‌سازی قرار گرفت. برخلاف روش‌های سنتی مانند K-Means که نیازمند تعیین تعداد خوشه‌ها از قبل هستند، DENCLUE با استفاده از تابع چگالی و مفهوم جاذب‌های چگالی (Density Attractors) قادر است ساختارهای پنهان موجود در داده‌ها را شناسایی کرده و نمونه‌ها را بر اساس میزان تراکم در نواحی مختلف دسته‌بندی کند. همچنین قابلیت تشخیص نقاط نویزی، یکی از مزیت‌های مهم این الگوریتم محسوب می‌شود.

در بخش عملی، عملکرد الگوریتم روی دو دیتاست واقعی بررسی شد. در دیتاست Seeds، الگوریتم توانست داده‌ها را در چهار خوشه مجزا گروه‌بندی کند و کیفیت خوشه‌بندی با استفاده از معیار Silhouette Score ارزیابی شد. همچنین در دیتاست Abalone، الگوریتم توانست سه خوشه اصلی را شناسایی کند و تنها تعداد محدودی از داده‌ها به‌عنوان نویز تشخیص داده شدند. مقدار Silhouette Score برابر با 0.458 نشان داد که خوشه‌های ایجادشده دارای تفکیک قابل قبول و ساختار منطقی هستند.

نتایج نشان داد که DENCLUE به دلیل وابستگی به ساختار چگالی داده‌ها، در مواجهه با داده‌های دارای توزیع غیرخطی و نمونه‌های پرت عملکرد مناسبی دارد. با این حال، کیفیت خروجی آن به انتخاب پارامترهایی مانند پهنای باند تابع چگالی و آستانه چگالی وابسته است و انتخاب نامناسب این پارامترها می‌تواند باعث ادغام بیش از حد خوشه‌ها یا افزایش نقاط نویزی شود.

در مجموع، الگوریتم DENCLUE یک روش قدرتمند برای کشف الگوهای پنهان در داده‌ها محسوب می‌شود و به‌ویژه در کاربردهایی که داده‌ها دارای ساختار پیچیده، نویز و تراکم‌های متفاوت هستند، می‌تواند نسبت به روش‌های مبتنی بر مرکزیت، انعطاف‌پذیری بیشتری ارائه دهد.