[REFACT]: Validation Method 수정

- 기존 DBI K값 2에서 optimal하게 나오는 경우가 있었음.
- 이에 따라 silhouette 로 변경

Author: jungseokyoung-cloud

Sources/Clustering/Cluster.swift

@@ -16,6 +16,8 @@ final class Cluster<T: ClusterData> {
 	var group: LinkedList<T>
 
 	private var sumOfLocation: Location
+
+	var size: Int { group.size }
 
 	// MARK: - Initalizers
 	init(centroid: Location) {
@@ -58,12 +60,18 @@ extension Cluster {
 		if group.size == 0 { return }
 		centroid = sumOfLocation / Double(group.size)
 	}
-	
+}
+
+// MARK: - Validation 로직
+extension Cluster {
 	/// Cluster의 Centriod로부터 분산을 리턴합니다.
-	func deviation() -> Double {
+	func deviation(from data: T) -> Double {
+		// 해당 데이터가 클러스터내에 위치한다면, -1을 해줍니다.
+		let divisor = group.contain(data) ? group.size - 1 : group.size
+		
 		return group.allValues()
 			.map { $0.location }
-			.reduce(0) { $0 + centroid.distance(with: $1) } / Double(group.size)
+			.reduce(0) { $0 + data.location.distance(with: $1) } / Double(divisor)
 	}
 }
 

Sources/Clustering/Clustering.swift

@@ -37,7 +37,9 @@ extension Clustering {
 	) {
 		queue.cancelAllOperations()
 
-		let kMeansResults = kRange.map { k -> KMeans in
+		let kMeansResults = kRange
+			.filter { $0 <= data.count && $0 >= 2 }
+			.map { k -> KMeans in
 			let kMeans = KMeans(k: k, data: data, maxIterations: maxIterations)
 			queue.addOperation(kMeans)
 			return kMeans
@@ -59,7 +61,7 @@ extension Clustering {
 
 	/// Optimal한 Clustering을 리턴합니다..
 	private func getOptimalClustering(_ kMeansResults: [KMeans<DataType>]) -> KMeans<DataType>? {
-		kMeansResults.min(by: { $0.dbi < $1.dbi })
+		kMeansResults.max(by: { $0.silhouetteScore < $1.silhouetteScore })
 	}
 
 	private func convertToClusterResults(_ clusters: [Cluster<DataType>]) -> [ClusterResult<DataType>] {

Sources/Clustering/KMeans.swift

@@ -20,9 +20,10 @@ final class KMeans<T: ClusterData>: Operation {
 
 	/// Cluster들의 Centriods
 	var centroids: [Location] { clusters.map { $0.centroid } }
-	
-	private(set) var dbi = Double.greatestFiniteMagnitude
-	
+
+	/// Clustering의 Silhouette 점수
+	private(set) var silhouetteScore: Double = 0
+
 	override var isAsynchronous: Bool { true }
 
 	// MARK: - Initializers
@@ -39,7 +40,7 @@ final class KMeans<T: ClusterData>: Operation {
 		guard !isCancelled else { return }
 
 		run()
-		daviesBouldInIndex()
+		setSilhouetteScore()
 	}
 }
 
@@ -157,25 +158,65 @@ private extension KMeans {
 	}
 }
 
-// MARK: DBI Method
-extension KMeans {
-	func daviesBouldInIndex() {
-		var sum: Double = 0
-		let deviations = clusters.map { $0.deviation() }
-		
-		for i in 0..<clusters.count {
-			var maxValue: Double = 0
-			for j in 0..<clusters.count where i != j {
-				let sumOfDevations = deviations[i] + deviations[j]
-				
-				let distanceCenters = clusters[i].centroid.distance(with: clusters[j].centroid)
-				
-				maxValue = max(maxValue, sumOfDevations / distanceCenters)
+// MARK: - Validation Method
+private extension KMeans {
+	/// silhouetteScore을 계산하여 silhouetteScore 변수에 대입합니다.
+	/// 시간 복잡도 : `O(n^2)`
+	func setSilhouetteScore() {
+		self.silhouetteScore = -1
+		
+		clusters.forEach { cluster in
+			if cluster.size == 0 {
+				silhouetteScore = max(silhouetteScore, 0)
+			} else {
+				silhouetteScore = max(silhouetteScore, meanSilhouetteCoefficient(at: cluster))
 			}
-			
-			sum += maxValue
 		}
+	}
+	
+	/// cluster의 평균 Silhouette 계수를 리턴합니다.
+	func meanSilhouetteCoefficient(at cluster: Cluster<T>) -> Double {
+		let cohesionCoefficients = cohesionCoefficients(cluster)
+		var minSeparationCoefficients = [Double](
+			repeating: .greatestFiniteMagnitude,
+			count: cluster.size
+		)
 
-		dbi = sum / Double(clusters.count)
+		clusters.filter { $0 != cluster }
+			.forEach { otherCluster in
+				minSeparationCoefficients = zip(
+					seperationCoefficients(cluster, with: otherCluster),
+					minSeparationCoefficients
+				)
+				.map { min($0.0, $0.1) }
+			}
+		
+		let zipCoefficients = zip(cohesionCoefficients, minSeparationCoefficients)
+		
+		let dividend = zipCoefficients.map { $1 - $0 }
+		let divisor = zipCoefficients.map { max($0, $1) }
+		
+		let sumOfSilhouetteIndex = zip(dividend, divisor)
+			.map { $0 / $1 }
+			.reduce(0) { $0 + $1 }
+		
+		return sumOfSilhouetteIndex / Double(cluster.size)
+	}
+	
+	/// 해당 클러스터 내의 모든점의 cohesion 계수를 리턴합니다.
+	/// 각 점이 속한 클러스터간의 응집도를 판별합니다.
+	func cohesionCoefficients(_ cluster: Cluster<T>) -> [Double] {
+		cluster.group.allValues()
+			.map { cluster.deviation(from: $0) }
+	}
+	
+	/// 클러스터내의 모든점의 seperation 계수를 리턴합니다.
+	/// `with`파라미터를 통해 전달한 클러스터 간의 응집도를 판별합니다.
+	func seperationCoefficients(
+		_ cluster: Cluster<T>,
+		with other: Cluster<T>
+	) -> [Double] {
+		cluster.group.allValues()
+			.map { other.deviation(from: $0) }
 	}
 }

Sources/Clustering/LinkedList/LinkedList.swift

@@ -16,8 +16,8 @@ final class LinkedList<T: Equatable> {
 	private var tail: Node<T>?
 
 	/// 연결리스트의 현재 노드를 리턴합니다.
-	var now: Node<T>?
-	
+	private var now: Node<T>?
+
 	/// 연결리스트의 사이즈를 리턴합니다.
 	private(set) var size: Int
 
@@ -158,6 +158,11 @@ extension LinkedList {
 		return -1
 	}
 
+	/// 해당 값을 가진 노드가 있는지 여부를 리턴합니다.
+	func contain(_ target: T) -> Bool {
+		indexOf(target) != -1 ? true : false
+	}
+	
 	/// `other`을 현재 링크 리스트 뒤에 병합합니다.
 	func merge(other: LinkedList<T>) {
 		self.tail?.moveBetween(tail?.prev, and: other.head)