Bild von Editor | Chatgpt

# Einführung

Lufttable Es bietet nicht nur eine versatile, breitblattähnliche Schnittstelle für die Datenspeicherung und -analyse, sondern bietet auch eine API für die programmatische Interaktion. Mit anderen Worten, Sie können es mit externen Werkzeugen und Technologien verbinden – zum Beispiel, Python – Um Datenpipelines zu erstellen oder Workflows zu verarbeiten, wodurch Ihre Ergebnisse in Ihre Airtable -Datenbank (oder einfach „Foundation“ in Airtable Jargon zurückgeführt werden.

Dieser Artikel zeigt, wie eine einfache ETL-ähnliche Pipeline mit der Airtable Python API erstellt wird. Wir halten uns an die kostenlose Stufe und stellen sicher, dass der Ansatz ohne bezahlte Funktionen funktioniert.

# Airtable Dataset Setup

Während die in diesem Artikel eingebaute Pipeline problemlos an eine Vielzahl von Datensätzen angepasst werden kann, für diejenigen, die neu zu Airtable sind und ein Airtable -Projekt und einen gespeicherten Datensatz als Ausgangspunkt benötigen, empfehlen wir Ihnen, dies zu folgen Jüngste Einführungs -Tutorial für Airtable und erstellen Sie einen tabellarischen Datensatz namens „Kunden“ mit 200 Zeilen und folgenden Spalten (siehe Bild):

Kunden Datensatz/Tabelle in Airtable | Bild des Autors

# Airtable-Python-Datenpipeline

Gehen Sie in Airtable zu Ihrem Benutzer Avatar-zum Zeitpunkt des Schreibens ist es der eingekreiste Avatar an der unteren linken Ecke der App-Schnittstelle-und wählen Sie „Builder Hub“. Klicken Sie im neuen Bildschirm (siehe Screenshot unten) auf „Private Entry Tokens“ und dann unter „Token erstellen“. Geben Sie ihm einen Namen und stellen Sie sicher, dass Sie mindestens diese beiden Bereiche hinzufügen: knowledge.information:learn Und knowledge.information:write. Wählen Sie ebenfalls die Foundation aus, in der sich die Tabelle Ihrer Kunden im Abschnitt „Zugriff“ befindet, damit Ihr Token den Zugriff auf diese Foundation konfiguriert hat.

Erstellen eines Airtable -API -Tokens | Bild des Autors

Sobald das Token erstellt wurde, kopieren und speichern Sie es sorgfältig an einem sicheren Ort, da es nur einmal angezeigt wird. Wir brauchen es später. Der Token beginnt mit pat gefolgt von einem langen alphanumerischen Code.

Ein weiterer wichtiger Informationen, das wir benötigen, um unsere Python-basierte Pipeline zu erstellen, die mit Airtable interagiert, ist die ID unserer Foundation. Gehen Sie zurück zu Ihrer Foundation in der Airtable -Webschnittstelle, und sobald Sie dort sehen, dass die URL im Browser eine Syntax hat: https://airtable.com/app(xxxxxx)/xxxx/xxxx. Der Teil, an dem wir kopieren möchten, ist die app(xxxx) ID enthalten zwischen zwei aufeinanderfolgenden Schrägstrichen (/): Das ist die Foundation -ID, die wir brauchen werden.

In der Hand und unter der Annahme, dass Sie bereits eine besiedelte Tabelle namens „Kunden“ in Ihrer Foundation haben, sind wir bereit, unser Python -Programm zu starten. Ich werde ein Notizbuch zum Codieren verwenden. Wenn Sie eine IDE verwenden, müssen Sie möglicherweise den Teil, in dem die drei Lufttable -Umgebungsvariablen definiert sind, geringfügig ändern, damit sie von einem lesen können .env Datei stattdessen. In dieser Model werden wir sie zur Einfachheit und Leichtigkeit der Illustration direkt in unserem Pocket book definieren. Beginnen wir mit der Set up der erforderlichen Abhängigkeiten:

!pip set up pyairtable python-dotenv

Als nächstes definieren wir die Lufttable -Umgebungsvariablen. Beachten Sie, dass Sie für die ersten beiden den Wert durch Ihren tatsächlichen Zugriffs -Token bzw. der Foundation -ID ersetzen müssen:

import os
from dotenv import load_dotenv # Mandatory provided that studying variables from a .env file
from pyairtable import Api, Desk
import pandas as pd

PAT = "pat-xxx" # Your PAT (Private Entry Token) is pasted right here
BASE_ID = "app-xxx" # Your Airtable Base ID is pasted right here
TABLE_NAME = "Clients"

api = Api(PAT)
desk = Desk(PAT, BASE_ID, TABLE_NAME)

Wir haben gerade eine Instanz der Python Airtable -API eingerichtet und einen Verbindungspunkt zur Kundentabelle in unserer Foundation instanziiert. So lesen wir den gesamten Datensatz, der in unserer Lufttabelle enthalten ist, und laden sie in a Pandas DataFrame. Sie müssen nur darauf achten, die genauen Spaltennamen aus der Quellentabelle für die String -Argumente innerhalb der Spalten zu verwenden get() Methodenaufrufe:

rows = ()
for rec in desk.all():  # honors 5 rps; auto-retries on 429s
    fields = rec.get("fields", {})
    rows.append({
        "id": rec("id"),
        "CustomerID": fields.get("CustomerID"),
        "Gender": fields.get("Gender"),
        "Age": fields.get("Age"),
        "Annual Earnings (okay$)": fields.get("Annual Earnings (okay$)"),
        "Spending Rating (1-100)": fields.get("Spending Rating (1-100)"),
        "Earnings class": fields.get("Earnings Class"),
    })

df = pd.DataFrame(rows)

Sobald die Daten geladen wurden, ist es Zeit, eine einfache Transformation anzuwenden. Der Einfachheit halber werden wir nur eine Transformation anwenden, aber wir könnten so viele wie nötig anwenden, wie wir es normalerweise tun würden, wenn wir Datensätze mit Pandas vorverarbeiten oder reinigen. Wir werden ein neues binäres Attribut erstellen, das genannt wird Is Excessive Worthum hochwertige Kunden zu bezeichnen, dh diejenigen, deren Einkommen und Ausgabenbewertungen beide hoch sind:

def high_value(row):
    strive:
        return (row("Spending Rating (1-100)") >= 70) and (row("Annual Earnings (okay$)") >= 70)
    besides TypeError:
        return False

df("Is Excessive Worth") = df.apply(high_value, axis=1)
df.head()

Resultierender Datensatz:

Airtable Knowledge Transformation mit Python und Pandas | Bild des Autors

Schließlich ist es an der Zeit, die Änderungen wieder auf Airtable zu schreiben, indem die mit der neuen Spalte verknüpften neuen Daten einbezogen werden. Es gibt eine kleine Einschränkung: Wir müssen zunächst manuell eine neue Spalte mit dem Namen „Excessive Worth“ in unserer Tabelle für Airtable -Kunden erstellen, wobei der Typ auf „Kontrollkästchen“ eingestellt ist (das Äquivalent zu binären kategorialen Attributen). Wenn diese leere Spalte erstellt wurde, führen Sie den folgenden Code in Ihrem Python -Programm aus, und die neuen Daten werden automatisch zu Airtable hinzugefügt!

updates = ()
for _, r in df.iterrows():
    if pd.isna(r("id")):
        proceed
    updates.append({
        "id": r("id"),
        "fields": {
            "Excessive Worth": bool(r("Is Excessive Worth"))
        }
    })

if updates:
    desk.batch_update(updates)

Zeit, wieder zu Airtable zu gehen und zu sehen, was sich in unserer Quellkunden -Tabelle geändert hat! Wenn Sie auf den ersten Blick keine Änderungen sehen und die neue Spalte immer noch leer erscheint, in Panik geraten Sie noch nicht. Nicht viele Kunden werden als „hoher Wert“ bezeichnet, und Sie müssen möglicherweise ein wenig nach unten scrollen, um einige mit einem grünen Zeckenschild zu sehen:

Aktualisierte Kundentabelle | Bild des Autors

Das struggle’s! Sie haben gerade Ihre eigene leichte ETL-ähnliche Datenpipeline auf der Grundlage einer bidirektionalen Wechselwirkung zwischen Airtable und Python erstellt. Intestine gemacht!

# Einpacken

Dieser Artikel konzentrierte sich auf die Präsentation von Datenfunktionen mit Airtable, einer vielseitigen und benutzerfreundlichen Cloud-basierten Plattform für Datenverwaltung und -analyse, die Funktionen von Tabellenkalkulationen und relationalen Datenbanken mit KI-betriebenen Funktionen kombiniert. Insbesondere haben wir gezeigt, wie man eine leichte Datentransformationspipeline mit der Airtable Python -API ausführt, die Daten von Airtable liest, sie umwandelt und sie wieder in Airtable lädt – alles innerhalb der Funktionen und Einschränkungen der freien Model von Airtable.

Iván Palomares Carrascosa ist ein Führer, Schriftsteller, Sprecher und Berater in KI, maschinellem Lernen, Deep Studying & LLMs. Er trainiert und führt andere darin, KI in der realen Welt zu nutzen.

Bild von Autor | Ideogramm

Daten sind der Vorteil, der unsere Arbeit als Datenfachleute antreibt. Ohne ordnungsgemäße Daten können wir unsere Aufgaben nicht ausführen, und unser Geschäft wird keinen Wettbewerbsvorteil erzielen. Daher ist die Sicherung geeigneter Daten für jeden Datenprofi von entscheidender Bedeutung, und Datenpipelines sind die für diesen Zweck entwickelten Systeme.

Datenpipelines sind Systeme, die Daten von einer Quelle in eine andere verschieben und umwandeln. Diese Systeme sind Teil der Gesamtinfrastruktur für jedes Unternehmen, das sich auf Daten stützt, da sie garantieren, dass unsere Daten zuverlässig und immer bereit sind.

Das Erstellen einer Datenpipeline magazine komplex klingen, aber einige einfache Instruments reichen aus, um zuverlässige Datenpipelines mit nur wenigen Codezeilen zu erstellen. In diesem Artikel werden wir untersuchen, wie Sie eine einfache Datenpipeline mit Python und Docker erstellen, die Sie in Ihren täglichen Datenarbeiten anwenden können.

Lassen Sie uns darauf eingehen.

Aufbau der Datenpipeline

Bevor wir unsere Datenpipeline erstellen, verstehen wir das Konzept von ETL, das für Extrakt, Transformation und Final steht. ETL ist ein Prozess, bei dem die Datenpipeline die folgenden Aktionen ausführt:

• Daten aus verschiedenen Quellen extrahieren.
• Verwandeln Sie Daten in ein gültiges Format.
• Laden Sie Daten in einen zugänglichen Speicherort.

ETL ist ein Standardmuster für Datenpipelines. Wir erstellen additionally dieser Struktur.

Mit Python und Docker können wir eine Datenpipeline rund um den ETL -Prozess mit einem einfachen Setup erstellen. Python ist ein wertvolles Instrument zur Orchestrierung von Datenflussaktivitäten, während Docker für die Verwaltung der Umgebung der Datenpipeline -Anwendung mithilfe von Containern nützlich ist.

Lassen Sie uns unsere Datenpipeline mit Python und Docker einrichten.

Schritt 1: Vorbereitung

Erstens müssen wir nicht versichern, dass Python und Docker in unserem System installiert sind (wir werden dies hier nicht abdecken).

Für unser Beispiel werden wir die verwenden Herzinfarktdatensatz von Kaggle als Datenquelle zur Entwicklung unseres ETL -Prozesses.

Mit allem werden wir die Projektstruktur vorbereiten. Insgesamt wird die einfache Datenpipeline das folgende Skelett haben:

simple-data-pipeline/
├── app/
│   └── pipeline.py
├── information/
│   └── Medicaldataset.csv
├── Dockerfile
├── necessities.txt
└── docker-compose.yml

Es gibt einen Hauptordner, der genannt wird simple-data-pipelinewas enthält:

• Ein app Ordner mit dem pipeline.py Datei.
• A information Ordner, der die Quelldaten enthält (Medicaldataset.csv).
• Der necessities.txt Datei für Umgebungsabhängigkeiten.
• Der Dockerfile Für die Docker -Konfiguration.
• Der docker-compose.yml Datei zum Definieren und Ausführen unserer Multi-Container-Docker-Anwendung.

Wir werden zuerst die ausfüllen necessities.txt Datei, die die für unser Projekt erforderlichen Bibliotheken enthält.

In diesem Fall werden wir nur die folgende Bibliothek verwenden:

Im nächsten Abschnitt werden die Datenpipeline mit unseren Beispieldaten eingerichtet.

Schritt 2: Richten Sie die Pipeline ein

Wir werden die Python einrichten pipeline.py Datei für den ETL -Prozess. In unserem Fall verwenden wir den folgenden Code.

import pandas as pd
import os

input_path = os.path.be a part of("/information", "Medicaldataset.csv")
output_path = os.path.be a part of("/information", "CleanedMedicalData.csv")

def extract_data(path):
    df = pd.read_csv(path)
    print("Knowledge Extraction accomplished.")
    return df

def transform_data(df):
    df_cleaned = df.dropna()
    df_cleaned.columns = (col.strip().decrease().substitute(" ", "_") for col in df_cleaned.columns)
    print("Knowledge Transformation accomplished.")
    return df_cleaned

def load_data(df, output_path):
    df.to_csv(output_path, index=False)
    print("Knowledge Loading accomplished.")

def run_pipeline():
    df_raw = extract_data(input_path)
    df_cleaned = transform_data(df_raw)
    load_data(df_cleaned, output_path)
    print("Knowledge pipeline accomplished efficiently.")

if __name__ == "__main__":
    run_pipeline()

Die Pipeline folgt dem ETL -Prozess, in dem wir die CSV -Datei laden, Datenumwandlungen wie fehlende Daten und Reinigen der Spaltennamen und die gelöschten Daten in eine neue CSV -Datei ausführen. Wir haben diese Schritte in eine einzelne eingepackt run_pipeline Funktion, die den gesamten Prozess ausführt.

Schritt 3: Richten Sie die Dockerfile ein

Mit der Python -Pipeline -Datei werden wir die füllen Dockerfile So richten Sie die Konfiguration für den Docker -Container mit dem folgenden Code ein:

FROM python:3.10-slim

WORKDIR /app
COPY ./app /app
COPY necessities.txt .

RUN pip set up --no-cache-dir -r necessities.txt

CMD ("python", "pipeline.py")

Im obigen Code geben wir an, dass der Container Python Model 3.10 als Umgebung verwendet. Als nächstes setzen wir das Arbeitsverzeichnis des Containers auf /app und kopieren Sie alles von unserem Einheimischen app Ordner in den Behälter app Verzeichnis. Wir kopieren auch die necessities.txt Datei und führen Sie die PIP -Set up im Container aus. Schließlich geben wir den Befehl an, um das Python -Skript auszuführen, wenn der Container startet.

Mit dem Dockerfile Bereit, wir werden die vorbereiten docker-compose.yml Datei zur Verwaltung der Gesamtausführung:

model: '3.9'

providers:
  data-pipeline:
    construct: .
    container_name: simple_pipeline_container
    volumes:
      - ./information:/information

Die obige YAML -Datei wird beim Ausführen das Docker -Bild über das verfügbare Verzeichnis erstellt Dockerfile. Wir montieren auch den Einheimischen information Ordner zum information Ordner im Container, sodass der Datensatz zu unserem Skript zugänglich ist.

Ausführung der Pipeline

Mit allen Dateien werden wir die Datenpipeline in Docker ausführen. Gehen Sie zum Projektroot -Ordner und führen Sie den folgenden Befehl in Ihrer Eingabeaufforderung aus, um das Docker -Bild zu erstellen und die Pipeline auszuführen.

docker compose up --build

Wenn Sie dies erfolgreich ausführen, sehen Sie wie Folgendes ein Informationsprotokoll:

 ✔ data-pipeline                           Constructed                                                                                   0.0s 
 ✔ Community simple_docker_pipeline_default  Created                                                                                 0.4s 
 ✔ Container simple_pipeline_container     Created                                                                                 0.4s 
Attaching to simple_pipeline_container
simple_pipeline_container  | Knowledge Extraction accomplished.
simple_pipeline_container  | Knowledge Transformation accomplished.
simple_pipeline_container  | Knowledge Loading accomplished.
simple_pipeline_container  | Knowledge pipeline accomplished efficiently.
simple_pipeline_container exited with code 0

Wenn alles erfolgreich ausgeführt wird, werden Sie eine neue sehen CleanedMedicalData.csv Datei in Ihrem Datenordner.

Glückwunsch! Sie haben gerade eine einfache Datenpipeline mit Python und Docker erstellt. Versuchen Sie, verschiedene Datenquellen und ETL -Prozesse zu verwenden, um festzustellen, ob Sie eine komplexere Pipeline verarbeiten können.

Abschluss

Das Verständnis von Datenpipelines ist für jeden Datenfachmann von entscheidender Bedeutung, da sie für den Erwerb der richtigen Daten für ihre Arbeit unerlässlich sind. In diesem Artikel haben wir untersucht, wie man eine einfache Datenpipeline mit Python und Docker erstellt und gelernt hat, wie man sie ausführt.

Ich hoffe das hat geholfen!

Cornellius Yudha Wijaya ist ein Knowledge Science Assistant Supervisor und Datenautor. Während er in Vollzeit bei Allianz Indonesien arbeitet, liebt er es, Python- und Datentipps über soziale Medien und das Schreiben von Medien zu teilen. Cornellius schreibt über eine Vielzahl von KI- und maschinellen Lernthemen.

Bild vom Autor | Canva

In diesem Tutorial lernen wir Prefect kennen, ein modernes Device zur Workflow-Orchestrierung. Wir beginnen mit dem Aufbau einer Datenpipeline mit Pandas und vergleichen sie dann mit einem Prefect-Workflow, um ein besseres Verständnis zu erlangen. Am Ende stellen wir unseren Workflow bereit und zeigen Ausführungsprotokolle auf dem Dashboard an.

Was ist Präfekt?

Präfekt ist ein Workflow-Administration-System, das für die Orchestrierung und Verwaltung komplexer Daten-Workflows, einschließlich Machine-Studying-Pipelines (ML), entwickelt wurde. Es bietet einen Rahmen für die Erstellung, Planung und Überwachung von Workflows und ist damit ein unverzichtbares Device für die Verwaltung von ML-Operationen (MLOps).

Prefect bietet Aufgaben- und Flussverwaltung, sodass Benutzer Abhängigkeiten definieren und Workflows effizient ausführen können. Mit Funktionen wie Statusverwaltung und Beobachtbarkeit bietet Prefect Einblicke in den Aufgabenstatus und -verlauf und unterstützt so das Debuggen und Optimieren. Es verfügt über ein hochgradig interaktives Dashboard, mit dem Sie verschiedene andere Funktionen planen, überwachen und integrieren können, die Ihren Workflow für die MLOps-Pipeline verbessern. Sie können sogar Benachrichtigungen einrichten und andere ML-Frameworks mit wenigen Klicks integrieren.

Prefect ist als Open-Supply-Framework und verwalteter Cloud-Dienst verfügbar und vereinfacht Ihren Arbeitsablauf noch weiter.

Erstellen einer Datenpipeline mit Pandas

Wir werden die Datenpipeline replizieren, die ich in den vorherigen Tutorials verwendet habe (Erstellen von Information Science-Pipelines mit Pandas – KDnuggets), um Ihnen eine Vorstellung davon zu geben, wie jede Aufgabe in der Pipeline funktioniert und wie sie kombiniert werden. Ich erwähne es hier, damit Sie klar vergleichen können, wie sich perfekte Datenpipelines von normalen Pipelines unterscheiden.

import pandas as pd

def load_data(path):
    return pd.read_csv(path)

def data_cleaning(information):
    information = information.drop_duplicates()
    information = information.dropna()
    information = information.reset_index(drop=True)
    return information

def convert_dtypes(information, types_dict=None):
    information = information.astype(dtype=types_dict)
    ## convert the date column to datetime
    information("Date") = pd.to_datetime(information("Date"))
    return information

def data_analysis(information):
    information("month") = information("Date").dt.month
    new_df = information.groupby("month")("Items Bought").imply()
    return new_df

def data_visualization(new_df, vis_type="bar"):
    new_df.plot(form=vis_type, figsize=(10, 5), title="Common Items Bought by Month")
    return new_df

path = "On-line Gross sales Information.csv"
df = (
    pd.DataFrame()
    .pipe(lambda x: load_data(path))
    .pipe(data_cleaning)
    .pipe(convert_dtypes, {"Product Class": "str", "Product Title": "str"})
    .pipe(data_analysis)
    .pipe(data_visualization, "line")
)

Wenn wir den obigen Code ausführen, wird jede Aufgabe nacheinander ausgeführt und generiert die Datenvisualisierung. Abgesehen davon geschieht nichts. Wir können es planen, die Ausführungsprotokolle anzeigen oder sogar Instruments von Drittanbietern zur Benachrichtigung oder Überwachung integrieren.

Erstellen einer Datenpipeline mit Prefect

Jetzt werden wir die gleiche Pipeline mit dem gleichen Datensatz erstellen On-line-Verkaufsdatensatz – Daten zu beliebten Marktplätzen aber mit Prefect. Wir werden zuerst die PRefect-Bibliothek mit dem PIP-Befehl installieren.

Wenn Sie den folgenden Code überprüfen, werden Sie feststellen, dass sich nicht wirklich etwas geändert hat. Die Funktionen sind dieselben, aber mit der Hinzufügung der Python-Dekoratoren. Jeder Schritt in der Pipeline hat den Dekorator `@activity` und die Pipeline, die diese Schritte kombiniert, hat den Dekorator `@circulate`. Darüber hinaus speichern wir auch die generierte Abbildung.

import pandas as pd
import matplotlib.pyplot as plt
from prefect import activity, circulate

@activity
def load_data(path):
    return pd.read_csv(path)

@activity
def data_cleaning(information):
    information = information.drop_duplicates()
    information = information.dropna()
    information = information.reset_index(drop=True)
    return information

@activity
def convert_dtypes(information, types_dict=None):
    information = information.astype(dtype=types_dict)
    information("Date") = pd.to_datetime(information("Date"))
    return information

@activity
def data_analysis(information):
    information("month") = information("Date").dt.month
    new_df = information.groupby("month")("Items Bought").imply()
    return new_df

@activity
def data_visualization(new_df, vis_type="bar"):

    new_df.plot(form=vis_type, figsize=(10, 5), title="Common Items Bought by Month")
    plt.savefig("average_units_sold_by_month.png")
    return new_df

@circulate(title="Information Pipeline")
def data_pipeline(path: str):
    df = load_data(path)
    df_cleaned = data_cleaning(df)
    df_converted = convert_dtypes(
        df_cleaned, {"Product Class": "str", "Product Title": "str"}
    )
    analysis_result = data_analysis(df_converted)
    new_df = data_visualization(analysis_result, "line")
    return new_df

# Run the circulate!
if __name__ == "__main__":
    new_df = data_pipeline("On-line Gross sales Information.csv")
    print(new_df)

Wir führen unsere Datenpipeline aus, indem wir den Speicherort der CSV-Datei angeben. Sie führt alle Schritte der Reihe nach aus und generiert Protokolle mit den Ausführungszuständen.

14:18:48.649 | INFO    | prefect.engine - Created circulate run 'enlightened-dingo' for circulate 'Information Pipeline'
14:18:48.816 | INFO    | Movement run 'enlightened-dingo' - Created activity run 'load_data-0' for activity 'load_data'
14:18:48.822 | INFO    | Movement run 'enlightened-dingo' - Executing 'load_data-0' instantly...
14:18:48.990 | INFO    | Process run 'load_data-0' - Completed in state Accomplished()
14:18:49.052 | INFO    | Movement run 'enlightened-dingo' - Created activity run 'data_cleaning-0' for activity 'data_cleaning'
14:18:49.053 | INFO    | Movement run 'enlightened-dingo' - Executing 'data_cleaning-0' instantly...
14:18:49.226 | INFO    | Process run 'data_cleaning-0' - Completed in state Accomplished()
14:18:49.283 | INFO    | Movement run 'enlightened-dingo' - Created activity run 'convert_dtypes-0' for activity 'convert_dtypes'
14:18:49.288 | INFO    | Movement run 'enlightened-dingo' - Executing 'convert_dtypes-0' instantly...
14:18:49.441 | INFO    | Process run 'convert_dtypes-0' - Completed in state Accomplished()
14:18:49.506 | INFO    | Movement run 'enlightened-dingo' - Created activity run 'data_analysis-0' for activity 'data_analysis'
14:18:49.510 | INFO    | Movement run 'enlightened-dingo' - Executing 'data_analysis-0' instantly...
14:18:49.684 | INFO    | Process run 'data_analysis-0' - Completed in state Accomplished()
14:18:49.753 | INFO    | Movement run 'enlightened-dingo' - Created activity run 'data_visualization-0' for activity 'data_visualization'
14:18:49.760 | INFO    | Movement run 'enlightened-dingo' - Executing 'data_visualization-0' instantly...
14:18:50.087 | INFO    | Process run 'data_visualization-0' - Completed in state Accomplished()
14:18:50.144 | INFO    | Movement run 'enlightened-dingo' - Completed in state Accomplished()

Am Ende erhalten Sie den transformierten Datenrahmen und die Visualisierungen.

Bereitstellen der Prefect Pipeline

Um die Prefect-Pipeline bereitzustellen, müssen wir zunächst unsere Codebasis in die Python-Datei „data_pipe.py“ verschieben. Danach ändern wir, wie wir unsere Pipeline ausführen. Wir verwenden die Funktion „.server“, um die Pipeline bereitzustellen, und übergeben die CSV-Datei als Argument an die Funktion.

data_pipe.py:

import pandas as pd
import matplotlib.pyplot as plt
from prefect import activity, circulate

@activity
def load_data(path: str) -> pd.DataFrame:
    return pd.read_csv(path)

@activity
def data_cleaning(information: pd.DataFrame) -> pd.DataFrame:
    information = information.drop_duplicates()
    information = information.dropna()
    information = information.reset_index(drop=True)
    return information

@activity
def convert_dtypes(information: pd.DataFrame, types_dict: dict = None) -> pd.DataFrame:
    information = information.astype(dtype=types_dict)
    information("Date") = pd.to_datetime(information("Date"))
    return information

@activity
def data_analysis(information: pd.DataFrame) -> pd.DataFrame:
    information("month") = information("Date").dt.month
    new_df = information.groupby("month")("Items Bought").imply()
    return new_df

@activity
def data_visualization(new_df: pd.DataFrame, vis_type: str = "bar") -> pd.DataFrame:
    new_df.plot(form=vis_type, figsize=(10, 5), title="Common Items Bought by Month")
    plt.savefig("average_units_sold_by_month.png")
    return new_df

@activity
def save_to_csv(df: pd.DataFrame, filename: str):
    df.to_csv(filename, index=False)
    return filename

@circulate(title="Information Pipeline")
def run_pipeline(path: str):
    df = load_data(path)
    df_cleaned = data_cleaning(df)
    df_converted = convert_dtypes(
        df_cleaned, {"Product Class": "str", "Product Title": "str"}
    )
    analysis_result = data_analysis(df_converted)
    data_visualization(analysis_result, "line")
    save_to_csv(analysis_result, "average_units_sold_by_month.csv")

# Run the circulate
if __name__ == "__main__":
    run_pipeline.serve(
        title="pass-params-deployment",
        parameters=dict(path="On-line Gross sales Information.csv"),
    )

Wenn wir die Python-Datei ausführen, erhalten wir die Meldung, dass wir zum Ausführen der bereitgestellten Pipeline den folgenden Befehl verwenden müssen:

Starten Sie ein neues Terminalfenster und geben Sie den Befehl ein, um die Ausführung dieses Flows auszulösen.

$ prefect deployment run 'Information Pipeline/pass-params-deployment'

Wie wir sehen, wurden Movement-Läufe eingeleitet, d. h. die Pipeline läuft im Hintergrund. Wir können jederzeit zum ersten Terminalfenster zurückkehren, um die Protokolle anzuzeigen.

Um die Protokolle im Dashboard anzuzeigen, müssen wir das Prefect-Dashboard starten, indem wir den folgenden Befehl eingeben:

Klicken Sie auf den Dashboard-Hyperlink, um das Dashboard in Ihrem Webbrowser zu starten.

Das Dashboard besteht aus verschiedenen Registerkarten und Informationen zu Ihrer Pipeline, Ihrem Workflow und Ihren Läufen. Um den aktuellen Lauf anzuzeigen, navigieren Sie zur Registerkarte „Movement Runs“ und wählen Sie den aktuellsten Movement-Lauf aus.

Der gesamte Quellcode, alle Daten und Informationen sind verfügbar unter Kingabzpro/Datenpipeline mit Präfekt GitHub-Repository. Bitte vergessen Sie nicht, es mit einem Stern zu markieren.

Abschluss

Um Ihren Datenworkflow zu skalieren und unnötige Probleme zu vermeiden, müssen Sie eine Pipeline mit den richtigen Instruments erstellen. Mit Prefect können Sie Ihre Läufe planen, die Pipeline debuggen und sie in mehrere Drittanbietertools integrieren, die Sie bereits verwenden. Es ist einfach zu verwenden und bietet zahlreiche Funktionen, die Sie lieben werden. Wenn Sie Prefect noch nicht kennen, empfehle ich Ihnen dringend, sich Prefect Cloud anzusehen. Sie bieten kostenlose Stunden an, damit Benutzer die Cloud-Plattform kennenlernen und sich mit dem Workflow-Administration-System vertraut machen können.

Abid Ali Awan (@1abidaliawan) ist ein zertifizierter Datenwissenschaftler, der gerne Modelle für maschinelles Lernen erstellt. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben technischer Blogs zu Technologien für maschinelles Lernen und Datenwissenschaft. Abid hat einen Grasp-Abschluss in Technologiemanagement und einen Bachelor-Abschluss in Telekommunikationstechnik. Seine Imaginative and prescient ist es, mithilfe eines Graph-Neural-Networks ein KI-Produkt für Studenten zu entwickeln, die mit psychischen Erkrankungen zu kämpfen haben.