הצגת המקור של הדף "ניתוח אשכולות ספקטרלי"

'''ניתוח אשכולות ספקטרלי''' הוא שיטה לפתרון בעיית [[ניתוח אשכולות]] באמצעות שימוש ב[[ערך עצמי |ערכים העצמיים]] ([[ספקטרום של מטריצה |ספקטרום]]) של [[מטריצת לפלסיאן|מטריצת הלפלסיאן]] המתארת את המידע.
במקרה ובו הקלט ניתן כ[[גרף (תורת הגרפים) |גרף]], מטריצת הלפלסיאן נחשבת כקלט של האלגוריתם (מאחר שקיימת התאמה אחת ויחידה בין גרף בעל ''<math>n</math>'' צמתים לבין מטריצת לפלסיאן מסדר <math>n \times n</math>), אמנם במקרים רבים הקלט אינו מתקבל כך, (אלא למשל אוסף נקודות במימד ''<math>R^m</math>'') ונדרשת בניית גרף כשלב מקדים לשימוש באלגוריתם.
קודקודי הגרף מייצגים את המידע אותו רוצים לנתח, וקשתות הגרף מייצגות את הקשר בין הפרטים בגרף.

==הגדרת הבעיה==
===תיאור הבעיה===
ניתוח המידע לאשכולות שקול לחלוקת הגרף לתת [[קבוצות זרות]] זו לזו, נרצה למצוא חלוקה שאכן מחלקת את המידע בצורה "טבעית" כלשהי, כלומר אינטואיטיבית קל להבין כי נרצה למצוא חלוקה כזו שבה הקשרים בין חברי קבוצות שונות רופפים עד לא קיימים, ובנוסף הקשרים שבין חברי כל קבוצה זה לזה חזקים, דרך נוספת שעל פיה ניתן לחלק את המידע היא אוסף קבוצות אשר הקשרים ביניהן רופפים, וכן גודלן דומה זה לזה.

[[File:Mincut vs ideal cut.png|thumb|שמאל|ממוזער|250px|הקשת הירוקה מחלקת את הגרף על פי חתך מינימלי, הקשת הכתומה מחלקת לשתי קבוצות טבעיות יותר]]

יש לשים לב כי בעוד התנאי הראשון הוא בעצם בעיית החתך המינימלי {{אנ|minimum cut}}, אשר ידועה כבעיה הניתנת לפתרון בזמן ריצה פולינומי, קיומו אינו מספיק לפתרון אופטימלי לבעיית הניתוח מאחר שפעמים רבות תוצאתו היא פיצול קודקוד אחד (או קבוצה קטנה של קודקודים) משאר הגרף, ובהוספת התנאי השני מתקבלת בעיה [[NP-קשיות|NP-קשה]]{{הערה|Wagner, D. and Wagner, F. (1993). Between min cut and graph bisection}}.
קירוב לפתרון בעיה זו ניתן להיעשות על ידי שימוש במטריצת הלפלסיאן של הגרף.

===הגדרה פורמלית===
בצורה פורמלית ניתן לתאר את הבעיה באחת מהדרכים הבאות - בהינתן [[גרף ממושקל]] ולא מכוון ''<math>G=(V,E,w)</math>'', ומספר ''<math>k</math>'' נרצה למצוא חלוקה המביאה למינימום את אחת משתי פונקציות המטרה הבאות:

<math>RatioCut(A_1,...,A_k):=\sum_{i\,=\,1}^k\frac{cut(A_i,{\overline{A_i}})}{|A_i|}</math>

<math>nCut(A_1,...,A_k):=\sum_{i\,=\,1}^k\frac{cut(A_i,{\overline{A_i}})}{vol(A_i)}</math>

כאשר מגדירים:
* <math>A_i</math> היא תת-קבוצה של צמתים בגרף, מתקיים <math>A_i\cap A_j=\empty</math>, <math>\cup_{i=1}^nA_i=V</math>
* <math>|A_i|</math> הוא מספר הצמתים ברכיב <math>A_i</math>.
* <math>vol(A_i)</math> הוא סכום ערכי הקשתות המחברות את צמתי <math>A_i</math> זה לזה.
* <math>cut(A_i,{\overline{A_i}})</math> הוא סכום ערכי הקשתות המחברות בין הקבוצה <math>A_i</math> לבין שאר הגרף.
* <math>k</math> הוא מספר האשכולות, כלומר מספר תת-הקבוצות שאליהן נחלק את הגרף.
'''ההבדל בין שתי הפונקציות הוא''' שבעוד <math>RatioCut</math> "מענישה" [[גרף קשיר#רכיבי קשירות|רכיבי קשירות]] בעלי מספר צמתים נמוך, ובשימוש בה נצפה לתוצאה של אשכולות בעלי מספר צמתים דומה, <math>nCut</math> "מענישה" רכיבי קשירות בעלי סכום קשתות נמוך, ולכן נצפה לקשרים חזקים בתוך כל אשכול.
[[קובץ:Ncut vs ratiocut.png|ממוזער|הקו האדום מחלק על פי nCut והקו הירוק על פי RatioCut]]
בדוגמה שבתמונה ניתן להראות על ידי חישוב כי שתי פונקציות המטרה יביאו לחלוקה שונה, שימוש בפונקציה <math>RatioCut</math> יוביל ל"שבירת" הקשת שערכה 14, לצורך חלוקת הגרף לשתי הקבוצות (השוות בגודלן) <math>\{1,2,3\} , \{4,5,6\}</math>. לעומת זאת, השימוש בפונקציה <math>nCut</math> יוביל לחלוקה לקבוצות <math>\{1,2\} , \{3,4,5,6\}</math>, מאחר שגודל הקבוצות לא רלוונטי אלא סכום הקשתות, ותחת חישוב זה שבירת הקשת בעלת משקל 13 עדיפה על הקשת הכבדה יותר.

ניתן להניח כי ההבדלים בין הגישות נובעים מסיבות היסטוריות, <math>RatioCut</math> פורסמה בהקשר של חלוקה של רכיבי [[מעגל חשמלי]] לתת קבוצות{{הערה|Hagen and Kahng, 1992|כיוון=}} אשר נוח "לטפל" בכל אחת בפני עצמה, בהקשר זה חשוב לדאוג שהקבוצות תהיינה בעלות גודל דומה וכן שלא יהיו קשרים חזקים בין קבוצה לקבוצה (לדוגמה, כדי שיהיה אפשר למקם כל תת-קבוצה במקום בלתי תלוי ככל האפשר בשאר המעגל החשמלי). לעומתה, <math>nCut</math> פורסמה בהקשר של [[סגמנטציה (מחשוב)|סגמנטציה]]{{הערה|Shi and Malik, 2000|כיוון=}}, ובהקשר זה חשוב לשים לב לכלול באותו אשכול אך ורק פרטים הקשורים זה לזה.

==[[מטריצת לפלסיאן|מטריצת הלפלסיאן]]==
===הגדרת מטריצת הלפלסיאן===
מטריצת הלפלסיאן מוגדרת בצורה הבאה:

''<math>L:=D-A</math>''

כאשר ''<math>A</math>'' היא [[מטריצת שכנות|מטריצה השכנות]] של הגרף (במקרה של גרף לא ממושקל) או [[מטריצת הדמיון]]{{אנ|similarity matrix}} של הגרף (במקרה של גרף ממושקל), וכן ''<math>D</math>'' היא [[מטריצה אלכסונית]] שבה האיבר ''<math>D_{ii}</math>'' הוא הדרגה של האיבר ה''<math>i</math>'', כלומר מתקיים <math>\sum_{i\,=\,1}^nA_{ij}=D_{jj}</math>

'''למטריצת הלפלסיאן קיימות שתי גרסאות מנורמלות:'''

מטריצת לפלסיאן סימטרית מנורמלת ('''symmetric normalized Laplacian matrix''') מוגדרת כך:

<math display="block">L^{\text{sym}} := D^{-1/2} L D^{-1/2}= I - D^{-1/2} A D^{-1/2}</math>

מטריצת לפלסיאן מנורמלת של מהלך אקראי ('''random-walk normalized Laplacian matrix''') מוגדרת כך:<math display="block">L^{\text{rw}} := D^{-1}L = I - D^{-1}A</math>תוצאת הנרמול הי מטריצה שבה ערכי האלכסון הם 1, והשימוש במטריצה מנורמלת ייעשה כדי להביא למינימום את פונקציית המטרה ''<math>ncut</math>'', יש לציין כי ב[[גרף רגולרי]] בדרך כלל לא נדרש נרמול, שכן תוצאת השימוש מטריצה הלא מנורמלת יהיה דומה מאוד למנורמלת.

===שימוש במטריצת הלפלסיאן===
מתכונות מטריצת הלפלסיאן הלא מנורמלת, ניתן להוכיח{{הערה|להוכחה המלאה ראו A Tutorial on Spectral Clustering by Ulrike von Luxburg בפרק 5.2}} כי בהינתן תת-הגרף ''<math>A_j</math>'' וכן [[וקטור אינדיקטור]]{{אנ|Indicator vector}} מנורמל ''<math>h</math>'' של תת-גרף זה:

<math display="block">h_{i}:=
\begin{cases}
1/\sqrt{|A_{j}|} & \mbox{if}\ v_i \mbox{ in } A_j \\
0 & \mbox{otherwise}
\end{cases}
</math>מתקיים השוויון הבא:<math display="block">h'Lh = \frac{cut(A_j,{\overline{A_j}})}{|A_j|}</math>

ובאופן כללי, עבור מטריצה ''<math>H</math>'' מגודל ''<math>n\times k</math>'' אשר עמודותיה הן וקטורים אינדיקטורים נקבל את השוויון הבא:<math display="block">Trace(H'LH) = \sum_{i\,=\,1}^k\frac{cut(A_i {\overline{A_i}})}{|A_i|}</math>כלומר, מציאת מינימום לפונקציה <math>RatioCut</math> שקולה למציאת מינימום לביטוי <math>Trace(H'LH)</math> תחת ההנחה שעמודות <math>H</math> הן וקטורים אינדיקטורים וכן שהן אורתונורמליות זו לזו.

בעיה זו אמנם עדיין NP-קשה, אך ניתן למצוא פתרון מקורב לבעיה זו אם מסירים את הדרישה שהעמודות הן אינדיקטורים, ומניחים רק שהן אורתונורמליות, וזוהי כבר בעיה ידועה אשר פתרונה נתון על ידי הווקטורים העצמיים המתאימים ל-<math>k</math> הערכים העצמיים הקטנים ביותר של המטריצה <math>L</math>, וסיבוכיות החישוב שלה פולינמיאלית. באופן דומה ניתן למצוא את הווקטורים העצמיים המתאימים ל-<math>k</math> הערכים העצמיים הקטנים ביותר של מטריצת הלפלסיאן המנורמלת ''<math>L^{rw}</math>'' כדי לקרב את פונקציית המטרה <math>nCut</math>{{הערה|להוכחה המלאה ראו A Tutorial on Spectral Clustering by Ulrike von Luxburg בפרק 5.3}}.

'''ניתן להבין קירוב זה בצורה אינטואיטיבית''' - קל להראות כי עבור גרף בעל <math>k</math> רכיבי קשירות, הפתרון האופטימלי עבור <math>k</math> אשכולות יהיה חלוקת הגרף לאותם <math>k</math> רכיבי קשירות, והווקטורים העצמיים המתאימים לערך העצמי 0 הם אינדיקטורים של רכיבי הקשירות{{הערה|ליתר דיוק יש לומר כי המרחב הנפרש על ידי הווקטורים העצמיים זהה למרחב הנפרש על ידי אינדיקטורים, מאחר שלא ניתן לשייך וקטור עצמי אחד מסוים אל ערך עצמי בעל ריבוי גאומטרי גדול מאחד אלא יש לדבר על המרחב הווקטורי המתאים לערך העצמי}}, כמו כן אלו הם הערכים העצמיים הקטנים ביותר, מאחר שידוע כי הערכים העצמיים של מטריצת הלפלסיאן אינם שליליים. כעת עבור גרף דומה המכיל בנוסף "רעש קטן", כלומר קשתות מעטות בין רכיב קשירות אחד למשנהו, נוכל לצפות שהערכים העצמיים ישתנו מעט, והמרחב הווקטורי הנפרש על ידי הווקטורים העצמיים המתאימים להם ישתנה מעט אף הוא, כלומר ניתן להבין כי בהינתן רעש קטן, קירוב הפתרון יהיה בסביבת הפתרון המקורי{{הערה|davis and kahan, 1970}}.

חשוב לציין כי אין ערובה לכך שקירוב זה אכן יניב את הפתרון לבעיה המקורית (המניחה שהווקטורים הם אינדיקטורים), דוגמאות קלאסיות לכך נסקרו בספרות במהלך השנים{{הערה|ראו לדוגמה Guattery and Miller, 1978}}. ובנוסף, בעוד פתרון הבעיה המקורית הוא אוסף אינדיקטורים המחלק את המידע ל<math>k</math> קבוצות בצורה מפורשת, קירוב הפתרון כבר מכריח אותנו לנתח את הווקטורים העצמיים בעזרת אלגוריתם נוסף (למשל בעזרת [[אלגוריתם k-מרכזים]]).

===דוגמאות===
להלן דוגמה לגרף בעלי 2 רכיבי קשירות, וכן גרף זהה עם תוספת של רעש ההופך אותו לבעל רכיב קשירות אחד,



{|class="wikitable" style="text-align:center;margin:auto;"
|-
! גרף
! מטריצת לפלסיאן
! 2 וקטורים עצמיים ראשונים
|-
|[[File:4 nodes 2 components.png|thumb]]
|<math>\left(\begin{array}{rrrrrr}
 20 & -20 & 0 & 0\\
 -20 & 20 & 0 & 0\\
 0 & 0 & 30 & -30\\
 0 & 0 & -30 & 30\\
\end{array}\right)</math>
|<math>\left(\begin{array}{rrrr}
 0 \\ 0 \\ 1 \\ 1
\end{array}\right)</math><math>\left(\begin{array}{rrrr}
 1 \\ 1 \\ 0 \\ 0
\end{array}\right)</math>
|}

{|class="wikitable" style="text-align:center;margin:auto;"
|-
! גרף
! מטריצת לפלסיאן
! 2 וקטורים עצמיים ראשונים
|-
|[[File:4 nodes 1 component.png|thumb]]
|<math>\left(\begin{array}{rrrrrr}
 21 & -20 & 0 & -1\\
 -20 & 20 & 0 & 0\\
 0 & 0 & 30 & -30\\
 -1 & 0 & -30 & 31\\
\end{array}\right)</math>
|<math>\left(\begin{array}{rrrr}
 -0.991 \\ -1.042 \\ 1.034 \\ 1
\end{array}\right)</math><math>\left(\begin{array}{rrrr}
 1 \\ 1 \\ 1 \\ 1
\end{array}\right)</math>
|}

ניתן לראות בגרף השני את הקשת המחברת את הצומת הראשון והשלישי כרעש קטן, ואכן הווקטורים העצמיים פורשים מרחב קרוב למרחב הנפרש על ידי האינדיקטורים של "רכיבי הקשירות" שכן מתקיים:<math> \frac{v_1+v_2}{2}=\left(\begin{array}{rrrr}
 0.0045 \\ -0.021 \\ 1.017 \\ 1
\end{array}\right) , \frac{v_1-v_2}{2}=\left(\begin{array}{rrrr}
 0.9955 \\ 1.021 \\ -0.017 \\ 0
\end{array}\right)</math>

===הווקטור העצמי הראשון===
חשוב לציין כי במרבית המקרים הקלט המתקבל הוא גרף קשיר, ומכאן 0 הוא ערך עצמי מריבוי 1, והווקטור העצמי המתאים לו יהיה וקטור אינדיקטור של כל צמתי הגרף, כלומר - <math>v=(1,1,...,1)</math>.

שימוש בוקטור זה לא מוסיף מידע על הקשר בין צמתי הגרף, ולכן ניתן לא להשתמש בו כאשר מחלקים את הגרף לאשכולות. לדוגמה, עבור חלוקה לשני אשכולות, ניתן להסתכל ישירות על הווקטור העצמי השני הקטן ביותר (הנקרא Fiedler Vector), ולחלק את הגרף על פיו, אשכול אחד יהיה קבוצת הצמתים בעלי ערך חיובי בוקטור, והאשכול השני יהיו קבוצת הצמתים בעלי ערך שלילי.

==אלגוריתם בסיסי==
כפי שהוזכר, בגרף בעל <math>k</math> רכיבי קשירות, הפתרון המתקבל עבור <math>k</math> הווקטורים העצמיים הראשונים פורש את אותו המרחב הנפרש גם כן על ידי האינדיקטורים של רכיבי הקשירות, ועל כן מציאת <math>k</math> האשכולות תתקבל על ידי יצירת מטריצה בגודל <math>k\times n</math> מהווקטורים העצמיים, והבאתה [[דירוג מטריצות#הגדרות בסיסיות |לצורתה הקנונית]].

אמנם בדרך כלל הגרף יכיל רעש, או שמראש מספר האשכולות לא יהיה ידוע, ועל כן מספר רכיבי הקשירות יהיה שונה ממספר האשכולות ויידרש עיבוד נוסף של המידע, דרך נפוצה אחת היא שימוש באלגוריתם k-מרכזים. בנוסף, במקרים רבים קלט המערכת אינו מטריצת לפלסיאן אלא, למשל, אוסף נקודות במימד גבוה כלשהו, במקרה כזה נדרש להגדיר פונקציית סמיכות המציינת את עוצמת הקשר בין כל שני איברים כדי ליצור את מטריצת הלפלסיאן. האלגוריתם השלם יכלול את השלבים הבאים:

* יצירת גרף ומטריצת לפלסיאן מהמידע
* חישוב <math>k</math> הווקטורים העצמיים הראשונים של המטריצה
*הטלת מטריצת הווקטורים הללו למרחב <math>R^k</math>, השורה ה<math>l</math> של מטריצה זו היא הטלת הצומת <math>l</math> בגרף אל <math>R^k</math>
*הפעלת אלגוריתם לניתוח אשכולות במרחב זה (לדוגמה אלגוריתם k-מרכזים).
להלן קטע קוד המממש את האלגוריתם המתואר{{הערה|קוד זה עוקב אחר השלבים המרכזיים של האלגוריתם התאורטי, ברמה המעשית ניתן להשתמש בספריות ייעודיות כגון sklearn.cluster.SpectralClustering}}<syntaxhighlight lang="python">
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_circles, make_blobs
from sklearn.cluster import KMeans
from sklearn.neighbors import NearestNeighbors
from scipy.linalg import eigh

# Step 0: Generate a dataset (Circles + Blobs)
np.random.seed(42)
X_circles, y_circles = make_circles(n_samples=400, factor=0.5, noise=0.05)
X_blobs, y_blobs = make_blobs(n_samples=100, centers=[(-1.5, -1.5)], cluster_std=0.1)
X = np.vstack((X_circles, X_blobs))
y_true = np.hstack((y_circles, y_blobs + 2)) # Adjust labels for clarity

# Step 1: Create the graph Laplacian matrix using epsilon-neighborhood
epsilon = 0.2
nbrs = NearestNeighbors(radius=epsilon).fit(X)
adj_matrix = nbrs.radius_neighbors_graph(X, mode='connectivity').toarray()
D = np.diag(np.sum(adj_matrix, axis=1))
L = D - adj_matrix

# Step 2: Compute the eigenvectors of the Laplacian matrix
eigenvalues, eigenvectors = eigh(L)
eigenvectors = eigenvectors[:, 0:3]

# Step 3+4: Analyze the data with k-means
kmeans = KMeans(n_clusters=3, random_state=42)
labels = kmeans.fit_predict(eigenvectors)

# Draw the original labels and clustering labels
plt.figure(figsize=(14, 6))

plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], c=y_true)
plt.title('Original Data (True Labels)')


plt.subplot(1, 2, 2)
plt.scatter(X[:, 0], X[:, 1], c=labels)
plt.title('Spectral Clustering Result')


plt.tight_layout()
plt.show()
</syntaxhighlight>

===מעבר מדאטה במימד גבוה ל[[מטריצת שכנות]]===
קיימות מספר שיטות ליצור גרף בהינתן אוסף נקודות, הבולטות שבהן הן:
* גרסה של [[אלגוריתם שכן קרוב]] - נגדיר קשת <math>U_{ij}</math> אם <math>i</math> הוא אחד מ<math>k</math> השכנים הקרובים של <math>j</math>, חשוב לציין כי:
** הערך <math>k</math> נתון לבחירה, ככל שיהיה גדול יותר כך הגרף יכיל יותר קשתות.
** הגרף המתקבל בדרך זו הוא מכוון, וזו תופעה שאיננה רצויה, לכן ניתן לבחור האם להגדיר קשת רק במקרים שבהם שתי הקשתות <math>U_{ij}</math>, <math>U_{ji}</math> קיימות (אלגוריתם שכן קרוב הדדי), או גם במקרים שבהם לפחות אחת משתי הקשתות קיימות.
** הגרף המתקבל איננו ממושקל
* סביבת <math>\epsilon</math> - נגדיר קשת <math>U_{ij}</math> אם המרחק בין שני הצמתים קטן או שווה ל-<math>\epsilon</math>, נשים לב כי:
** הערך <math>\epsilon</math> נתון לבחירה, ככל שיהיה גדול יותר כך הגרף יכיל יותר קשתות.
** הגרף המתקבל בדרך זו איננו מכוון ואיננו ממושקל.
* שימוש [[מטריקה|במטריקת מרחק]] המודדת קרבה בין שתי נקודות, פונקציה שכיחה בהקשר זה היא - <math>s(x_i,x_j)=e^{\frac{-||x_i-x_j||^2}{2\sigma^2}}</math>, בשימוש במטריקה זו:
** הערך <math>\sigma</math> נתון לבחירה, ככל שיהיה גדול יותר כך נקודות בסביבה רחוקה יותר יחוברו בקשת בעלת משקל גבוה.
** הגרף המתקבל הוא ממושקל ואיננו מכוון.
** הגרף המתקבל הוא [[גרף שלם|שלם]], ועל כן מטריצת הלפלסיאן לא תהיה [[מטריצה דלילה|דלילה]], וזמני החישוב יהיו ארוכים יותר.

==מאפיינים מרכזיים בהשוואה לשיטות שונות==
===סוג הקלט===
חשוב לשים לב כי האלגוריתם מתבסס על דמיון וקירבה בין איברים, ולכן ניתן להשתמש בקלט בעל אופי מגוון. בניגוד ל[[אלגוריתם k-מרכזים]] או אלגוריתם [[DBSCAN]]{{אנ|DBSCAN}} לדוגמה, אשר מתאימים יותר לקלט ממימד <math>R^n</math>, כאן ניתן להשתמש גם [[פונקציה בוליאנית|בערכים בוליאנים]] (כאשר ניתן להגדיר מטריקת מרחק המסתמכת על [[מרחק ג'אקרד]] לדוגמה).

===אופן החישוב===
השלבים ה"כבדים" הם יצירת מטריצת הלפלסיאן, וחישוב הווקטורים העצמיים. עבור <math>n</math> נקודות קלט, בניית מטריצת לפלסיאן מלאה פרופורציונלית למספר הקשתות - כלומר סיבוכיות של <math>\mathcal{O}(n^2)</math>, ומספר פעולות החישוב עבור כל הווקטורים העצמיים במדויק פרופורציונלי ל<math>n^3</math>.

חשוב לציין כי לשימוש מעשי נדרש רק קירוב של הווקטורים העצמיים, ובנוסף ביישומים רבים, תחת הנחות ריאליות של ידע מקדים על הקלט ניתן להגביל את מספר הקשתות של כל צומת, ובכך עבור <math>k</math> וקטורים עצמיים ניתן להוריד את הסיבוכיות עד לסדר גודל של <math>\mathcal{O}(k*n^{1.5})</math> בעזרת שימוש ב[[אלגוריתם לנצוש]]{{הערה|למעשה השילוב של הסתפקות בקירוב הווקטורים העצמיים עם הגבלת מספר הקשתות המחוברות לכל צומת הוא שהופך את השימוש באלגוריתם לנצוש לאטרקטיבי מאחר שזמן החישוב של אלגוריתם זה יורד משמעותית עבור מטריצות דלילות, בהיעדר הנחה זו ניתן להגיע לסיבוכיות של <math>k*n^2</math> עבור <math>k</math> הווקטורים העצמיים הראשונים}}{{הערה|ראו בהרחבה בshi and malik, 2000, פרק 3.1}}. לכן זמן הריצה תלוי מאוד באופי הקלט ואופן מימוש האלגוריתם.

עוד יש לציין כי מספר הממדים של הקלט איננו משפיע על זמני הריצה של שלבים אלה בצורה ישירה, מה שמבדיל אותו מאלגוריתמים רבים אשר יעילותם פוחתת וזמני הריצה שלהם עולים משמעותית תחת קלט של מידע ממימד גבוה.

===התפלגות הקלט===
אחד היתרונות המרכזיים של האלגוריתם הוא העובדה שאין הנחות יסוד על האשכולות. בניגוד ל-[[k-מרכזים (אלגוריתם)|<math>k</math>-מרכזים]] המניח שכל אשכול הוא בעל צורה כללית של [[ספירה (גאומטריה)|ספירה]], או [[DBSCAN]] המניח צפיפות אחידה באשכול, כאן פונקציית המטרה לא מתייחסת בצורה ישירה לתכונות גלובליות אלה של האשכול.

==ראו גם==
* [[ניתוח אשכולות]]
* [[מטריצת לפלסיאן]]
* [[בעיית החתך המינימלי]]{{אנ|minimum cut}}

==קישורים חיצוניים==

* [https://people.csail.mit.edu/dsontag/courses/ml14/notes/Luxburg07_tutorial_spectral_clustering.pdf מאמר מקיף] מאת פרופסור ulrike von luxburg.
* [https://www.youtube.com/watch?v=zLuVrqlYKyg&list=PLiAulSm0XXgtkxss6TXOEffq3RhrsbYbV סדרת סרטונים בנושא] מאוניברסיטת סטנפורד
* [https://scikit-learn.org/stable/auto_examples/cluster/plot_segmentation_toy.html תרגול קוד פייתון בסיסי עבור סגמנטציה] מאת {{אנ|scikit-learn|scikit-learn}}
* תיעוד ספריית [https://scikit-learn.org/0.15/modules/generated/sklearn.cluster.SpectralClustering.html sklearn.cluster.SpectralClustering]

==הערות שוליים==
{{הערות שוליים}}

[[קטגוריה:כריית מידע]]