Comprendre le processus ETL avec des données en temps réel : extraction, transformation, chargement et visualisation

Le processus ETL (Extract, Transform, Load) est fondamental pour gérer efficacement les données, en particulier dans les applications qui nécessitent une prise de décision rapide basée sur des données en temps réel. Dans cet article, nous explorerons le processus ETL à l'aide d'un exemple pratique impliquant des transactions de crypto-monnaie en temps réel à partir de l'API Binance. Le code Python fourni illustre comment extraire des données commerciales, les transformer dans un format utilisable, les charger dans une base de données SQLite et visualiser les données avec un tracé en temps réel.

Exemple de projet ETL : https://github.com/vcse59/FeatureEngineering/tree/main/Real-Time-CryptoCurrency-Price-Tracker

1. Extrait
La première étape du processus ETL est l'extraction, qui implique la collecte de données provenant de diverses sources. Dans ce cas, les données sont extraites via une connexion WebSocket à l'API Binance Testnet. Cette connexion permet la diffusion en temps réel des transactions BTC/USDT.

Voici comment l'extraction est implémentée dans le code :

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

Chaque message reçu contient des données commerciales essentielles, notamment le prix, la quantité et l'horodatage, qui sont au format JSON.

2. Transformer
Une fois les données extraites, elles subissent le processus de transformation. Cette étape nettoie et structure les données pour les rendre plus utiles. Dans notre exemple, la transformation comprend la conversion de l'horodatage des millisecondes dans un format lisible et l'organisation des données en types appropriés pour un traitement ultérieur.

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

trade_time = datetime.fromtimestamp(timestamp / 1000.0)

Cela garantit que le prix et la quantité sont stockés sous forme de flottants et que l'horodatage est converti en un objet datetime pour une manipulation et une analyse plus faciles.

3. Charger
La dernière étape est le chargement, où les données transformées sont stockées dans une base de données cible. Dans notre code, la base de données SQLite sert de support de stockage pour les données commerciales.

Le processus de chargement est géré par la fonction suivante :

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()

Cette fonction se connecte à la base de données SQLite, crée une table si elle n'existe pas et insère les données commerciales.

4. Visualiser
En plus de stocker les données, il est essentiel de les visualiser pour une meilleure compréhension et prise de décision. Le code fourni comprend une fonction pour tracer les transactions en temps réel :

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

Cette fonction génère deux sous-parcelles : une pour le prix et une autre pour la quantité. Il utilise la bibliothèque matplotlib pour visualiser les données de manière dynamique, permettant aux utilisateurs d'observer les tendances du marché en temps réel.

Conclusion
Cet exemple met en évidence le processus ETL, démontrant comment les données peuvent être extraites d'une API WebSocket, transformées pour analyse, chargées dans une base de données et visualisées pour un retour immédiat. Ce cadre est crucial pour créer des applications qui doivent prendre des décisions éclairées basées sur des données en temps réel, telles que les plateformes de trading et les outils d'analyse de marché.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!