Úvod

Kombinácia sietí Isolation Forest a Long Short-Term Memory (LSTM) predstavuje výkonný prístup k detekcii anomálií, ktorý využíva silné stránky metód učenia bez dohľadu aj s dohľadom. Táto implementácia demonštruje, ako môžu tieto algoritmy spolupracovať na vytvorení robustného systému detekcie anomálií.

Izolačný les + súbor LSTM na detekciu anomálií

import numpy ako np

importovať pandas ako pd

from sklearn.ensemble import IsolationForest

z tensorflow.keras.models import Sequential

z tensorflow.keras.layers import LSTM, Dense, Dropout

from sklearn.preprocessing import StandardScaler

import matplotlib.pyplot as plt

from typing import Tuple, List, Optional

čas dovozu

trieda AnomalyDetectionEnsemble:

def __init__(self,

sequence_length: int = 10,

isolation_forest_contamination: float = 0.1,

lstm_units: int = 50,

ensemble_threshold: float = 0,5):

"""

Inicializácia detektora anomálií súboru

Príznaky:

sequence_length: Dĺžka sekvencií pre LSTM

isolation_forest_contamination: Očakávaný podiel anomálií

lstm_units: Počet jednotiek LSTM

ensemble_threshold: Prahová hodnota pre kombinovanie predpovedí

"""

self.sequence_length = sequence_length

self.isolation_forest = IsolationForest(

kontaminácia=isolation_forest_contamination,

random_state=42

       )

self.lstm_model = self._build_lstm_model(lstm_units)

self.scaler = StandardScaler()

self.ensemble_threshold = ensemble_threshold

def _build_lstm_model(self, lstm_units: int) -> Sekvenčné:

"""Zostavte model LSTM na predpovedanie sekvencií"""

model = Sekvenčný([

LSTM(lstm_units, input_shape=(self.sequence_length, 1), return_sequences=True),

Dropout(0,2),

LSTM(lstm_units // 2),

Dropout(0,2),

Husté(1)

])

model.compile(optimizer='adam', loss='mse')

vrátiť model

def _prepare_sequences(self, data: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:

"""Pripraviť sekvencie na trénovanie LSTM"""

X, y = [], []

pre i v rozsahu(len(data) - self.sequence_length):

X.append(data[i:i + self.sequence_length])

y.append(data[i + self.sequence_length])

return np.array(X), np.array(y)

def fit(self, data: np.ndarray, epochs: int = 50, verbose: int = 1) -> None:

"""

Fitovanie oboch modelov na tréningových údajoch

Príznaky:

údaje: 1D pole údajov časových radov

epochs: Počet epoch pre trénovanie LSTM

verbose: Úroveň verbálnosti pre školenie

"""

# Údaje o mierke

scaled_data = self.scaler.fit_transform(data.reshape(-1, 1))

# Fit Izolačný les

self.isolation_forest.fit(scaled_data)

# Pripravte sekvencie a prispôsobte LSTM

X, y = self._prepare_sequences(scaled_data)

self.lstm_model.fit(

X, y,

epochs=epochs,

verbose=verbose,

validation_split=0.2

       )

def predict(self, data: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:

"""

Predpovedanie anomálií pomocou oboch modelov

Návraty:

Tuple of (ensemble predictions, isolation forest scores, lstm scores)

"""

# Údaje o mierke

scaled_data = self.scaler.transform(data.reshape(-1, 1))

# Izolačný les predpovedí (-1 pre anomálie, 1 pre normálne)

if_predictions = self.isolation_forest.predict(scaled_data)

if_scores = self.isolation_forest.score_samples(scaled_data)

# Predpovede LSTM

X, _ = self._prepare_sequences(scaled_data)

lstm_predictions = self.lstm_model.predict(X, verbose=0)

lstm_scores = np.abs(scaled_data[self.sequence_length:] - lstm_predictions.reshape(-1, 1))

# Normalizácia skóre

if_scores = (if_scores - np.min(if_scores)) / (np.max(if_scores) - np.min(if_scores))

lstm_scores = (lstm_scores - np.min(lstm_scores)) / (np.max(lstm_scores) - np.min(lstm_scores))

# Kombinovať predpovede

ensemble_scores = 0,5 * (1 - if_scores) + 0,5 * lstm_scores.flatten()

ensemble_predictions = (ensemble_scores > self.ensemble_threshold).astype(int)

return ensemble_predictions, if_scores, lstm_scores.flatten()

def generate_synthetic_data(n_points: int = 1000) -> Tuple[np.ndarray, np.ndarray]:

"""Generovanie syntetických časových radov s anomáliami"""

# Generovanie normálnych údajov

t = np.linspace(0, 10, n_points)

normal_data = np.sin(t) + np.random.normal(0, 0.1, n_body)

# Pridať anomálie

anomálie = np.zero(n_body)

anomaly_indices = np.random.choice(n_points, size=int(0.05 * n_points), replace=False)

normal_data[anomaly_indices] += np.random.normal(0, 0.5, len(anomaly_indices))

anomálie[anomaly_indices] = 1

return normal_data, anomalies

def plot_results(data: np.ndarray,

true_anomalies: np.ndarray,

predicted_anomalies: np.ndarray,

if_scores: np.ndarray,

lstm_scores: np.ndarray) -> None:

"""Vykresliť výsledky detekcie anomálií"""

plt.figure(figsize=(15, 10))

# Vykresliť pôvodné údaje a anomálie

plt.subplot(3, 1, 1)

plt.plot(data, label='Pôvodné údaje')

plt.scatter(np.where(true_anomalies == 1)[0],

data[true_anomalies == 1],

color='red', label='True Anomalies')

plt.scatter(np.where(predicted_anomalies == 1)[0],

data[predicted_anomalies == 1],

color='green', marker='x', label='Predpovedané anomálie')

plt.legend()

plt.title('Časový rad s anomáliami')

# Skóre izolačného lesa

plt.subplot(3, 1, 2)

plt.plot(if_scores, label='Isolation Forest Scores')

plt.legend()

plt.title('Skóre anomálií izolačného lesa')

# Vykresliť skóre LSTM

plt.subplot(3, 1, 3)

plt.plot(lstm_scores, label='Chyba rekonštrukcie LSTM')

plt.legend()

plt.title('LSTM Anomaly Scores')

plt.tight_layout()

plt.show()

def demonstrate_ensemble():

"""Demonštrácia detektora anomálií v súbore"""

# Generovanie syntetických údajov

print("Generovanie syntetických údajov...")

data, true_anomalies = generate_synthetic_data()

# Vytvoriť a trénovať súbor

print("\nTraining ensemble detector...")

detektor = AnomalyDetectionEnsemble()

detector.fit(data, epochs=20, verbose=0)

# Vykonajte predpovede

vytlačiť("Predpovedanie...")

predictions, if_scores, lstm_scores = detector.predict(data)

# Vypočítať metriky

true_positives = np.sum((predictions == 1) & (true_anomalies == 1))

false_positives = np.sum((predictions == 1) & (true_anomalies == 0))

false_negatives = np.sum((predictions == 0) & (true_anomalies == 1))

presnosť = true_positives / (true_positives + false_positives)

recall = true_positives / (true_positives + false_negatives)

f1_score = 2 * (precision * recall) / (precision + recall)

print("\nResults:")

   print(f”Precision: {precision:.3f}”)

   print(f”Recall: {recall:.3f}”)

   print(f”F1 Score: {f1_score:.3f}”)

# Vykresliť výsledky

plot_results(data, true_anomalies, predictions, if_scores, lstm_scores)

if __name__ == "__main__":

demonstrate_ensemble()

Návrh algoritmu

Súbor kombinuje silné stránky dvoch rôznych prístupov k detekcii anomálií. Algoritmus Isolation Forest vyniká pri identifikácii globálnych odľahlých hodnôt prostredníctvom rekurzívneho delenia, zatiaľ čo sieť LSTM zachytáva komplexné časové vzory a závislosti v sekvencii údajov. Táto kombinácia umožňuje detekciu bodových anomálií aj kontextových anomálií v rámci časových radov údajov.

Podrobnosti o implementácii

Implementácia obsahuje niekoľko kľúčových prvkov:

1. Predbežné spracovanie údajov: Systém implementuje štandardizáciu a prípravu sekvencií na trénovanie LSTM, čím zabezpečuje optimálny výkon pre oba algoritmy.

2. Izolačný les: V tomto prípade sa globálne odľahlé body identifikujú na základe princípu izolácie, pričom anomálie sa zvyčajne izolujú ľahšie ako normálne body.

3. Architektúra LSTM: V komponente pod dohľadom sa používa hlboká sieť LSTM s výpadkovými vrstvami, aby sa zabránilo nadmernému prispôsobeniu a zachytili sa časové závislosti v údajoch.

4. Integrácia súboru: Systém kombinuje predpovede z oboch modelov pomocou váženého prístupu, čo umožňuje flexibilné prispôsobenie vplyvu každého modelu na konečnú predpoveď.

Optimalizácia výkonu

Implementácia obsahuje niekoľko optimalizácií na zvýšenie výkonu:

- Efektívna príprava sekvencie na trénovanie LSTM

- Vektorové operácie na výpočet skóre

- Vyvážené vypadávajúce vrstvy na zabránenie nadmernému prispôsobeniu

- Normalizovaný bodovací systém pre konzistentnú integráciu súboru

Vizualizácia a analýza

Systém poskytuje komplexné možnosti vizualizácie:

- Grafy časových radov so zvýraznenými anomáliami

- Rozdelenie skóre jednotlivých modelov

- Výsledky predpovedí súboru

Budúci vývoj

Prebiehajúci výskum naďalej zlepšuje schopnosti súboru prostredníctvom:

- Pokročilá optimalizácia architektúry

- Adaptívne mechanizmy váženia

- Vylepšené techniky normalizácie skóre

- Rozšírené možnosti vizualizácie

Záver

Súbor Isolation Forest-LSTM predstavuje výkonný prístup k detekcii anomálií, ktorý kombinuje silné stránky učenia pod dohľadom aj bez dohľadu. Organizácie môžu túto implementáciu využiť na vývoj robustných systémov detekcie anomálií prispôsobených ich špecifickým potrebám.

Technická podpora

Podrobné pokyny k implementácii a technickú dokumentáciu vám poskytne náš tím pre systémy umelej inteligencie na adrese [email protected]. Naši odborníci vám pomôžu s vývojom riešení detekcie anomálií na mieru, ktoré spĺňajú vaše špecifické požiadavky a zároveň zabezpečujú optimálny výkon.

Decent Cybersecurity poskytuje pokročilé riešenia AI na detekciu anomálií na celom svete. Naše systémy zabezpečujú presnú detekciu pri zachovaní výpočtovej efektivity.

Po spustení tohto kódu sa:

1. Generovanie syntetických časových radov s vloženými anomáliami

2. Trénovanie detektora súboru

3. Vypracujte predpovede na základe testovacích údajov

4. Zobrazenie výkonnostných ukazovateľov

5. Generovanie vizualizácií zobrazujúcich pôvodné údaje, skutočné anomálie, predpovedané anomálie a skóre jednotlivých modelov

Výstup bude obsahovať metriky presnosti, odvolania a skóre F1 spolu s tromi grafmi zobrazujúcimi:

1. Pôvodný časový rad s vyznačenými skutočnými a predpokladanými anomáliami

2. Skóre anomálií v izolačnom lese

3. Chybové skóre rekonštrukcie LSTM

Výsledok vykonania:

Generovanie syntetických údajov...

Tréningový detektor súborov...