Main file for hds-deep

hds-deep.py

@@ -0,0 +1,223 @@
+import numpy as np
+from sklearn.base import BaseEstimator, OutlierMixin
+from sklearn.preprocessing import RobustScaler
+from sklearn.neighbors import NearestNeighbors, KDTree
+from sklearn.decomposition import PCA
+
+
+class HDS(BaseEstimator, OutlierMixin):
+    def __init__(
+        self,
+        scales=(5, 10, 20),
+        contamination=0.12,
+        memory_capacity=500,
+        random_state=42,
+    ):
+        self.scales = scales
+        self.contamination = contamination
+        self.memory_capacity = memory_capacity
+        self.random_state = random_state
+        
+        self.rag_memory_keys = None
+        self.rag_memory_vals = None
+
+    @staticmethod
+    def _rank_score(values):
+        values = np.asarray(values, dtype=float)
+        order = np.argsort(values, kind="mergesort")
+        ranks = np.empty(len(values), dtype=float)
+        ranks[order] = np.arange(len(values), dtype=float)
+        if len(values) > 1:
+            ranks /= len(values) - 1
+        return ranks
+
+    def _update_rag_memory(self, Z, scores):
+        if self.rag_memory_keys is None:
+            self.rag_memory_keys = Z.copy()
+            self.rag_memory_vals = scores.copy()
+        else:
+            if len(self.rag_memory_keys) > self.memory_capacity:
+                self.rag_memory_keys = self.rag_memory_keys[-self.memory_capacity:]
+                self.rag_memory_vals = self.rag_memory_vals[-self.memory_capacity:]
+            self.rag_memory_keys = np.vstack([self.rag_memory_keys, Z])
+            self.rag_memory_vals = np.concatenate([self.rag_memory_vals, scores])
+
+    def _rag_retrieval_co_thought(self, Z):
+        if self.rag_memory_keys is None:
+            return np.zeros(len(Z))
+        sim_matrix = np.dot(Z, self.rag_memory_keys.T)
+        top_k_indices = np.argsort(sim_matrix, axis=1)[:, -5:]
+        retrieved_signals = np.zeros(len(Z))
+        for i in range(len(Z)):
+            retrieved_signals[i] = np.mean(self.rag_memory_vals[top_k_indices[i]])
+        return self._rank_score(retrieved_signals)
+
+    def _deterministic_attention_engine(self, tokens_matrix):
+        cov = np.cov(tokens_matrix, rowvar=False) + 1e-5 * np.eye(tokens_matrix.shape[1])
+        inv_cov = np.linalg.pinv(cov)
+        
+        attention_energy = np.array([np.dot(row, np.dot(inv_cov, row.T)) for row in tokens_matrix])
+        attention_weights = 1.0 / (1.0 + attention_energy)
+        
+        fused_scores = np.dot(tokens_matrix, np.array([0.30, 0.55, 0.15])) * (1.0 + attention_weights)
+        return self._rank_score(fused_scores)
+
+    def fit(self, X, y=None):
+        X = np.asarray(X, dtype=float)
+        if X.ndim != 2:
+            raise ValueError("X must be a 2D array.")
+        if len(X) < 8:
+            raise ValueError("At least 8 samples are required.")
+        if not np.isfinite(X).all():
+            raise ValueError("X contains NaN or infinite values.")
+        if not 0 <= self.contamination < 0.5:
+            raise ValueError("contamination must be in [0, 0.5).")
+
+        self._fit_X = X.copy()
+        self.scaler_ = RobustScaler()
+        Z = self.scaler_.fit_transform(X)
+
+        self.n_samples_in_ = len(Z)
+        self.n_features_in_ = Z.shape[1]
+
+        self.scales_ = sorted({max(2, min(int(k), len(Z) - 1)) for k in self.scales})
+        sg_list = []
+        cov_matrix = np.cov(Z, rowvar=False) + 1e-5 * np.eye(self.n_features_in_)
+        inv_cov = np.linalg.pinv(cov_matrix)
+        
+        for k in self.scales_:
+            nbrs = NearestNeighbors(n_neighbors=k + 1, metric="euclidean").fit(Z)
+            distances, _ = nbrs.kneighbors(Z)
+            euc_radius = np.maximum(distances[:, -1], 1e-12)
+            mah_radius = np.array([np.sqrt(np.dot(row.T, np.dot(inv_cov, row))) for row in Z])
+            hybrid_global = 0.5 * euc_radius + 0.5 * mah_radius
+            sg_list.append(self._rank_score(hybrid_global))
+            
+        self.S_G_ = np.mean(sg_list, axis=0)
+
+        n_samples = len(Z)
+        k_ln = min(max(15, self.n_features_in_ * 3), n_samples - 1)
+        nbrs_ln = NearestNeighbors(n_neighbors=k_ln + 1, metric="euclidean").fit(Z)
+        _, indices_ln = nbrs_ln.kneighbors(Z)
+
+        local_recon_errors = np.zeros(n_samples)
+        global_pca = PCA(n_components=max(1, self.n_features_in_ - 1), random_state=self.random_state)
+        global_pca.fit(Z)
+        global_errors = np.linalg.norm(Z - global_pca.inverse_transform(global_pca.transform(Z)), axis=1)
+
+        for i in range(n_samples):
+            neighbors_idx = indices_ln[i]
+            local_data = Z[neighbors_idx]
+            if len(local_data) <= self.n_features_in_:
+                local_recon_errors[i] = global_errors[i]
+                continue
+            n_comp_local = max(1, min(self.n_features_in_ - 1, len(local_data) - 2))
+            local_pca = PCA(n_components=n_comp_local, random_state=self.random_state)
+            try:
+                local_pca.fit(local_data)
+                z_i = Z[i].reshape(1, -1)
+                z_proj = local_pca.transform(z_i)
+                z_recon = local_pca.inverse_transform(z_proj)
+                local_recon_errors[i] = np.linalg.norm(z_i - z_recon)
+            except Exception:
+                local_recon_errors[i] = global_errors[i]
+
+        hybrid_residuals = 0.6 * local_recon_errors + 0.4 * global_errors
+        self.train_residuals_ = hybrid_residuals
+        self.S_LN_ = self._rank_score(hybrid_residuals)
+
+        self.kdtree_ = KDTree(Z, leaf_size=max(10, n_samples // 10))
+        node_depths = []
+        for z_i in Z:
+            dist, _ = self.kdtree_.query(z_i.reshape(1, -1), k=min(10, n_samples))
+            node_depths.append(dist[0][-1])
+        
+        self.train_tn_raw_ = np.array(node_depths)
+        self.S_TN_ = self._rank_score(self.train_tn_raw_)
+
+        tokens = np.column_stack([self.S_G_, self.S_LN_, self.S_TN_])
+        attention_scores = self._deterministic_attention_engine(tokens)
+
+        self._update_rag_memory(Z, attention_scores)
+        rag_context = self._rag_retrieval_co_thought(Z)
+        
+        self.decision_scores_ = self._rank_score(0.75 * attention_scores + 0.25 * rag_context)
+
+        threshold_index = int(np.floor((1 - self.contamination) * len(self.decision_scores_)))
+        threshold_index = min(max(threshold_index, 0), len(self.decision_scores_) - 1)
+        self.threshold_ = np.sort(self.decision_scores_)[threshold_index]
+        self.labels_ = np.where(self.decision_scores_ >= self.threshold_, -1, 1)
+
+        return self
+
+    def score_samples(self, X):
+        X = np.asarray(X, dtype=float)
+        Z = self.scaler_.transform(X)
+        ref = self.scaler_.transform(self._fit_X)
+        n_query = len(Z)
+
+        cov_matrix = np.cov(ref, rowvar=False) + 1e-5 * np.eye(self.n_features_in_)
+        inv_cov = np.linalg.pinv(cov_matrix)
+        
+        sg_list = []
+        for k in self.scales_:
+            k_eff = min(k, len(ref))
+            nbrs = NearestNeighbors(n_neighbors=k_eff, metric="euclidean").fit(ref)
+            distances, _ = nbrs.kneighbors(Z)
+            euc_radius = np.maximum(distances[:, -1], 1e-12)
+            mah_radius = np.array([np.sqrt(np.dot(row.T, np.dot(inv_cov, row))) for row in Z])
+            hybrid_global = 0.5 * euc_radius + 0.5 * mah_radius
+            
+            train_nbrs = NearestNeighbors(n_neighbors=min(k + 1, len(ref)), metric="euclidean").fit(ref)
+            train_dist, _ = train_nbrs.kneighbors(ref)
+            train_euc = np.maximum(train_dist[:, -1], 1e-12)
+            train_mah = np.array([np.sqrt(np.dot(row.T, np.dot(inv_cov, row))) for row in ref])
+            train_hybrid = 0.5 * train_euc + 0.5 * train_mah
+            
+            global_rank = np.searchsorted(np.sort(train_hybrid), hybrid_global) / len(train_hybrid)
+            sg_list.append(global_rank)
+        S_G_q = np.mean(sg_list, axis=0)
+
+        k_ln = min(max(15, self.n_features_in_ * 3), len(ref))
+        nbrs_ln = NearestNeighbors(n_neighbors=k_ln + 1, metric="euclidean").fit(ref)
+        _, indices_ln = nbrs_ln.kneighbors(Z)
+
+        global_pca = PCA(n_components=max(1, self.n_features_in_ - 1), random_state=self.random_state).fit(ref)
+        global_errors_q = np.linalg.norm(Z - global_pca.inverse_transform(global_pca.transform(Z)), axis=1)
+
+        local_recon_errors_q = np.zeros(n_query)
+        for i in range(n_query):
+            neighbors_idx = indices_ln[i]
+            local_data = ref[neighbors_idx]
+            if len(local_data) <= self.n_features_in_:
+                local_recon_errors_q[i] = global_errors_q[i]
+                continue
+            n_comp_local = max(1, min(self.n_features_in_ - 1, len(local_data) - 2))
+            local_pca = PCA(n_components=n_comp_local, random_state=self.random_state)
+            try:
+                local_pca.fit(local_data)
+                z_i = Z[i].reshape(1, -1)
+                z_proj = local_pca.transform(z_i)
+                z_recon = local_pca.inverse_transform(z_proj)
+                local_recon_errors_q[i] = np.linalg.norm(z_i - z_recon)
+            except Exception:
+                local_recon_errors_q[i] = global_errors_q[i]
+
+        hybrid_residuals_q = 0.6 * local_recon_errors_q + 0.4 * global_errors_q
+        S_LN_q = np.searchsorted(np.sort(self.train_residuals_), hybrid_residuals_q) / len(self.train_residuals_)
+
+        q_dist, _ = self.kdtree_.query(Z, k=min(10, len(ref)))
+        S_TN_q = np.searchsorted(np.sort(self.train_tn_raw_), q_dist[:, -1]) / len(self.train_tn_raw_)
+
+        tokens_q = np.column_stack([S_G_q, S_LN_q, S_TN_q])
+        attention_scores_q = self._deterministic_attention_engine(tokens_q)
+
+        rag_context_q = self._rag_retrieval_co_thought(Z)
+        return self._rank_score(0.75 * attention_scores_q + 0.25 * rag_context_q)
+
+    def predict(self, X):
+        return np.where(self.score_samples(X) >= self.threshold_, -1, 1)
+
+    def fit_predict(self, X, y=None):
+        self.fit(X, y)
+        return self.labels_