Den ETL-Prozess mit Echtzeitdaten verstehen: Extraktion, Transformation, Laden und Visualisierung

Der ETL-Prozess (Extrahieren, Transformieren, Laden) ist von grundlegender Bedeutung für die effiziente Verwaltung von Daten, insbesondere in Anwendungen, die eine schnelle Entscheidungsfindung auf der Grundlage von Echtzeitdaten erfordern. In diesem Artikel untersuchen wir den ETL-Prozess anhand eines praktischen Beispiels mit Echtzeit-Kryptowährungsgeschäften über die Binance-API. Der bereitgestellte Python-Code veranschaulicht, wie Handelsdaten extrahiert, in ein verwendbares Format umgewandelt, in eine SQLite-Datenbank geladen und die Daten mit Echtzeitplots visualisiert werden.

Beispiel-ETL-Projekt: https://github.com/vcse59/FeatureEngineering/tree/main/Real-Time-CryptoCurrency-Price-Tracker

1. Extrahieren
Der erste Schritt des ETL-Prozesses ist die Extraktion, bei der Daten aus verschiedenen Quellen gesammelt werden. In diesem Fall werden die Daten über eine WebSocket-Verbindung zur Binance Testnet API extrahiert. Diese Verbindung ermöglicht das Echtzeit-Streaming von BTC/USDT-Trades.

So wird die Extraktion im Code implementiert:

 with websockets.connect(url) as ws:
    response = await ws.recv()
    trade_data = json.loads(response)

Jede empfangene Nachricht enthält wichtige Handelsdaten, einschließlich Preis, Menge und Zeitstempel, die als JSON formatiert sind.

2. Verwandeln
Sobald die Daten extrahiert sind, werden sie dem Transformationsprozess unterzogen. Dieser Schritt bereinigt und strukturiert die Daten, um sie nützlicher zu machen. In unserem Beispiel umfasst die Transformation die Konvertierung des Zeitstempels von Millisekunden in ein lesbares Format und die Organisation der Daten in geeignete Typen für die weitere Verarbeitung.

price = float(trade_data['p'])
quantity = float(trade_data['q'])
timestamp = int(trade_data['T'])

trade_time = datetime.fromtimestamp(timestamp / 1000.0)

Dadurch wird sichergestellt, dass Preis und Menge als Floats gespeichert werden und der Zeitstempel zur einfacheren Bearbeitung und Analyse in ein Datum/Uhrzeit-Objekt umgewandelt wird.

3. Laden
Der letzte Schritt ist das Laden, bei dem die transformierten Daten in einer Zieldatenbank gespeichert werden. In unserem Code dient die SQLite-Datenbank als Speichermedium für die Handelsdaten.

Der Ladevorgang wird durch die folgende Funktion verwaltet:

def save_trade_to_db(price, quantity, timestamp):
    conn = sqlite3.connect('trades.db')
    cursor = conn.cursor()
    # Create a table if it doesn't exist
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS trades (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            price REAL,
            quantity REAL,
            timestamp TEXT
        )
    ''')
    # Insert the trade data
    cursor.execute('''
        INSERT INTO trades (price, quantity, timestamp)
        VALUES (?, ?, ?)
    ''', (price, quantity, trade_time))
    conn.commit()
    conn.close()

Diese Funktion stellt eine Verbindung zur SQLite-Datenbank her, erstellt eine Tabelle, falls diese nicht vorhanden ist, und fügt die Handelsdaten ein.

4. Visualisieren
Neben der Speicherung von Daten ist es für ein besseres Verständnis und eine bessere Entscheidungsfindung unerlässlich, diese zu visualisieren. Der bereitgestellte Code enthält eine Funktion zum Plotten der Trades in Echtzeit:

def plot_trades():
    if len(trades) > 0:
        timestamps, prices, quantities = zip(*trades)

        plt.subplot(2, 1, 1)
        plt.cla()  # Clear the previous plot for real-time updates
        plt.plot(timestamps, prices, label='Price', color='blue')
        plt.ylabel('Price (USDT)')
        plt.legend()
        plt.title('Real-Time BTC/USDT Prices')
        plt.xticks(rotation=45)

        plt.subplot(2, 1, 2)
        plt.cla()  # Clear the previous plot for real-time updates
        plt.plot(timestamps, quantities, label='Quantity', color='orange')
        plt.ylabel('Quantity')
        plt.xlabel('Time')
        plt.legend()
        plt.xticks(rotation=45)

        plt.tight_layout()  # Adjust layout for better spacing
        plt.pause(0.1)  # Pause to update the plot

Diese Funktion generiert zwei Unterdiagramme: eines für den Preis und eines für die Menge. Es verwendet die Matplotlib-Bibliothek, um die Daten dynamisch zu visualisieren, sodass Benutzer Markttrends in Echtzeit beobachten können.

Fazit
Dieses Beispiel beleuchtet den ETL-Prozess und zeigt, wie Daten aus einer WebSocket-API extrahiert, zur Analyse umgewandelt, in eine Datenbank geladen und für sofortiges Feedback visualisiert werden können. Dieses Framework ist von entscheidender Bedeutung für die Erstellung von Anwendungen, die fundierte Entscheidungen auf der Grundlage von Echtzeitdaten treffen müssen, wie z. B. Handelsplattformen und Marktanalysetools.

Das obige ist der detaillierte Inhalt vonDen ETL-Prozess mit Echtzeitdaten verstehen: Extraktion, Transformation, Laden und Visualisierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!