Ich erwähnte, dass die Terminplanung die nächste Hürde ist, auf die ich zusteuere.

Additionally schätze ich, hier bin ich und gehe darauf zu

Aber bevor ich darauf eingehe, was passiert ist, möchte ich für jeden, der zum ersten Mal darüber stolpert, einen Kontext geben.

Ich bin ein Systemanalytiker, der sich für den Übergang in die Datentechnik entschieden hat. Anstatt nur Kurse zu belegen und Zertifikate zu sammeln, habe ich beschlossen, zu lernen, indem ich etwas aufbaue und öffentlich darüber schreibe. Jeder Artikel in dieser Reihe dokumentiert etwas, das ich tatsächlich gebaut habe, die Entscheidungen, die ich getroffen habe, die Dinge, die kaputt gegangen sind, und was ich daraus gelernt habe.

Der erste Artikel struggle meine 12-monatige Roadmap für das Selbststudiumwo ich den Plan darlegte, wie ich diesen Übergang angehen würde. Der Zweite struggle ich Ich baue meine erste ETL-Pipeline von Grund auf auf Verwendung der GitHub-API als absoluter Anfänger. Im dritten habe ich dieselbe Pipeline genommen und machte es produktionstauglicher durch Hinzufügen von SQLite-Speicher, Idempotenz-Handhabung und Google Drive-Persistenz, alles innerhalb von Google Colab.

Dieser Artikel ist der vierte. Und es setzt genau dort an, wo das letzte aufgehört hat.

Ich ging davon aus, dass ich die meiste Zeit damit verbringen würde, ein Planungstool auszuwählen und zu konfigurieren. Was ich nicht erwartet hatte, struggle, dass ich mich mit etwas Grundlegenderem befassen musste, bevor ich überhaupt über die Terminplanung nachdenken konnte. Meine Pipeline konnte nicht außerhalb von Google Colab ausgeführt werden. Und bis sich das änderte, konnte mir kein Planer der Welt helfen.

Dies ist die Geschichte dessen, was tatsächlich passiert ist.

Die erste Wand: Meine Pipeline lebte in Colab

Bevor ich überhaupt mit der Planung begann, wollte ich verstehen, was eigentlich nötig wäre, um meine Pipeline automatisch auszuführen. Deshalb habe ich mir meinen Code zum ersten Mal mit dieser Frage im Hinterkopf genauer angesehen.

So sah der Ladebereich aus:

conn = sqlite3.join('/content material/drive/MyDrive/github_repos.db')

Dieser Weg, /content material/drive/MyDrive/existiert nur innerhalb von Google Colab. Es handelt sich um den bereitgestellten Google Drive-Pfad, den Ihnen Colab zur Verfügung stellt, wenn Sie Ihr Drive mit einem Pocket book verbinden. Außerhalb von Colab existiert dieser Pfad nicht. Wenn ein Planer versuchen würde, dieses Skript auszuführen, würde es genau dort abstürzen.

Das Interessante ist, dass mein Code nein hatte google.colab Importe. Keine Colab-spezifischen Bibliotheken. Nur ein fest codierter Pfad, den ich eingegeben hatte, ohne wirklich darüber nachzudenken. Dieser Pfad struggle die Abhängigkeit, nicht der Code.

Das struggle das erste, was ich nicht erwartet hatte. Ich dachte, die Herausforderung würde darin bestehen, ein Planungstool zu erlernen. Stattdessen struggle die erste Lektion, dass meine Umgebung Teil meiner Pipeline struggle und ich es nicht bemerkt hatte.

Die Lösung struggle einfach. Anstatt den Colab-Pfad fest zu codieren, habe ich den Datenbankpfad über eine Umgebungsvariable konfigurierbar gemacht:

import os

DB_PATH = os.environ.get('DB_PATH', 'github_repos.db')
conn = sqlite3.join(DB_PATH)

Jetzt verwendet das Skript den in der Umgebung festgelegten Pfad. Wenn nichts festgelegt ist, wird auf die Erstellung einer lokalen Datei zurückgegriffen github_repos.db Datei im selben Ordner. Eine Änderung und die Pipeline struggle nicht mehr an Colab gebunden.

Zum ersten Mal außerhalb von Colab ausführen

Bevor ich einen Planer einrichtete, wollte ich sicherstellen, dass das Skript tatsächlich eigenständig funktioniert. Additionally habe ich es gespeichert als pipeline.pyerstellt a necessities.txt mit den beiden benötigten Bibliotheken:

requests
pandas

Und habe es von meinem Terminal aus ausgeführt:

Es wurde gedruckt: Pipeline full. Duplicates dealt with.

Und eine Datei namens github_repos.db erschien in meinem Ordner. Dieselbe Pipeline, die ich in Colab ausgeführt hatte, lief jetzt überall als einfaches Python-Skript.

Das schien eine größere Sache zu sein, als ich erwartet hatte. Nicht weil die Änderung komplex struggle, das struggle sie nicht. Sondern weil mir klar wurde, dass ich meine Pipeline als Notizbuch betrachtet hatte, obwohl ich tatsächlich ein Skript hatte, das sich zufällig darin befand.

Auswahl eines Planungstools

Zu diesem Zeitpunkt hatte ich ein eigenständiges Skript. Jetzt brauchte ich etwas, um es nach einem Zeitplan auszuführen.

Ich habe mir ein paar Optionen angesehen. Mit APScheduler können Sie Zeitpläne in Ihrem Python-Code definieren. Dies funktioniert, während eine Sitzung ausgeführt wird, stoppt jedoch, sobald Sie Ihr Terminal schließen. Das ist nicht wirklich eine Planung, das ist nur eine Schleife. Airflow ist der Industriestandard für die Orchestrierung von Pipelines, erfordert jedoch den Betrieb eines Servers, einer Metadatendatenbank und einer Webschnittstelle. Das ist eine Menge Infrastruktur für den Ort, an dem ich mich gerade befinde.

GitHub Actions befanden sich in der Mitte. Es ist kostenlos, läuft auf den Servern von GitHub, der Zeitplan ist im Code definiert und ich muss keine Infrastruktur pflegen. Der Nachteil besteht darin, dass es für CI/CD-Workflows und nicht für die Pipeline-Orchestrierung konzipiert ist und daher Einschränkungen hinsichtlich komplexer Abhängigkeiten und Überwachung aufweist. Aber für eine Pipeline in meinem Stadium ist es eine praktische Wahl.

Ich möchte auch ehrlich sein: Instruments wie Airflow gibt es aus einem bestimmten Grund. Wenn eine Pipeline wächst, wenn Abhängigkeiten zwischen Aufgaben bestehen und Sie Einblick in die ausgeführten und fehlgeschlagenen Aufgaben benötigen, ist eine ordnungsgemäße Orchestrierung erforderlich. GitHub Actions ist das nicht. Aber es ist ein guter erster Schritt, und zu verstehen, warum es begrenzt ist, ist Teil des Verständnisses dafür, was diese ernsthafteren Instruments tatsächlich lösen.

Einrichten von GitHub-Aktionen

GitHub Actions arbeitet mit Workflow-Dateien, bei denen es sich um YAML-Dateien handelt, die Sie in einem bestimmten Ordner in Ihrem Repository ablegen. Die Ordnerstruktur sieht so aus:

github-etl/
├── .github/
│   └── workflows/
│       └── schedule.yml
├── pipeline.py
└── necessities.txt

Hier ist die vollständige Workflow-Datei, die ich erstellt habe:

title: Run ETL Pipeline

on:
  schedule:
    - cron: '0 9 * * *'
  workflow_dispatch:

jobs:
  run-pipeline:
    runs-on: ubuntu-latest

    steps:
      - title: Checkout code
        makes use of: actions/checkout@v4

      - title: Arrange Python
        makes use of: actions/setup-python@v5
        with:
          python-version: '3.11'

      - title: Set up dependencies
        run: pip set up -r necessities.txt

      - title: Run pipeline
        run: python pipeline.py

Lassen Sie mich durchgehen, was jeder Teil tut.

• cron: '0 9 * * *' ist der tatsächliche Zeitplan. Cron ist ein zeitbasiertes Jobplanungsformat, das es in Unix-Systemen seit Jahrzehnten gibt. Die fünf Werte repräsentieren Minute, Stunde, Tag des Monats, Monat und Wochentag. Additionally 0 9 * * * bedeutet: zur Minute 0 der 9. Stunde, jeden Tag, jeden Monat, jeden Tag der Woche. Mit anderen Worten, jeden Tag 9 Uhr UTC.
• workflow_dispatch fügt einen manuellen Auslöser hinzu. Das bedeutet, dass Sie den Workflow auch durch Klicken auf eine Schaltfläche in GitHub ausführen können, ohne auf die geplante Zeit warten zu müssen. Dies ist zum Testen nützlich.
• runs-on: ubuntu-latest weist GitHub an, bei jedem Lauf eine neue Linux-Maschine hochzufahren. Jedes Mal, wenn der Workflow ausgelöst wird, erstellt GitHub eine saubere Umgebung, installiert Ihre Abhängigkeiten, führt Ihr Skript aus und fährt dann alles herunter. Es gibt keinen persistenten Pc, der irgendwo Ihren Code ausführt. Es ist vergänglich.

Die Schritte sind unkompliziert. Checkout ruft Ihren Code aus dem Repository in den Runner ab. Setup Python installiert die von Ihnen angegebene Model. Abhängigkeiten installieren wird ausgeführt pip set up -r necessities.txt. Und dann führt „Run Pipeline“ Ihr Skript aus.

Was geschah, als ich es ausführte?

Nachdem ich die Workflow-Datei auf GitHub übertragen hatte, ging ich in meinem Repository zur Registerkarte „Aktionen“ und löste sie manuell über die Schaltfläche „workflow_dispatch“ aus.

Es lief. Siebenundzwanzig Sekunden vom Begin bis zum Ende. Die Pipeline hat Daten von der GitHub-API abgerufen, transformiert und in SQLite geladen, alles auf einem GitHub-Server, ohne dass ich nach dem Klicken auf die Schaltfläche etwas tun musste.

Ich habe beim ersten Durchlauf eine Warnung erhalten:

Node.js 20 actions are deprecated...

Das lag daran, dass ich ältere Versionen der Checkout- und Setup-Python-Aktionen verwendet hatte. Der Repair wurde aktualisiert actions/checkout@v3 Zu actions/checkout@v4 Und actions/setup-python@v4 Zu actions/setup-python@v5. Danach lief der Workflow sauber.

Was ich tatsächlich gelernt habe

Als ich darauf einging, dachte ich, dass es bei der Terminplanung darum geht, das richtige Werkzeug auszuwählen. Ich stellte fest, dass mich die Terminplanung dazu zwang, über etwas nachzudenken, worüber ich vorher nicht sorgfältig nachgedacht hatte: Portabilität.

Eine Pipeline, die nur in einer bestimmten Umgebung ausgeführt wird, ist keine echte Pipeline. Es ist ein Skript, das an eine Plattform gebunden ist. Um es planbar zu machen, musste man es zunächst portabel machen, und um es portabel zu machen, musste man verstehen, wovon es tatsächlich abhängt.

Der fest codierte Pfad struggle eine Kleinigkeit. Aber als ich es erkannte, änderte sich meine Einstellung zum künftigen Schreiben von Pipeline-Code. Jedes Mal, wenn ich einen Pfad, einen Berechtigungsnachweis oder einen umgebungsspezifischen Wert schreibe, frage ich mich nun, ob das Ding außerhalb des Kontexts, in dem ich baue, existieren wird.

Außerdem habe ich gelernt, dass Planung und Orchestrierung unterschiedliche Probleme sind. GitHub Actions handhabt die Planung intestine. Dinge wie die Wiederholung fehlgeschlagener Ausführungen mit Backoff, die Warnung, wenn etwas schief geht, die Visualisierung von Pipeline-Abhängigkeiten oder die Verwaltung mehrerer voneinander abhängiger Pipelines werden nicht behandelt. Dabei handelt es sich um Orchestrierungsprobleme, für deren Lösung Instruments wie Airflow konzipiert sind.

Ich bin noch nicht da. Aber ich verstehe jetzt, warum diese Instruments auf eine Weise existieren, die ich vorher nicht kannte.

Was kommt als nächstes?

Die Pipeline läuft jetzt jeden Tag um 9 Uhr UTC. Es werden Daten erhoben. Und mir fällt langsam etwas auf: Wenn eine Pipeline täglich läuft, kümmern Sie sich auf andere Weise um die Daten, die sie produziert.

Sind alle Unterlagen sauber? Gibt es Repos, die mit fehlenden Feldern durchschlüpfen? Ist die virale Flagge tatsächlich sinnvoll oder habe ich sie so definiert, dass quick alles „Nein“ lautet?

Das sind Fragen zur Datenqualität. Und sie sind die nächste Wand, auf die ich zugehe.

Dies ist Teil meiner fortlaufenden Serie, die meinen Übergang vom Systemanalytiker zum Dateningenieur dokumentiert. Wenn Sie mitgemacht haben, vielen Dank. Wenn dies Ihr erster Artikel in der Reihe ist, sind die früheren Artikel unten verlinkt.

Vom Datenanalysten zum Dateningenieur: Meine 12-monatige Roadmap zum Selbststudium

Ich habe meine erste ETL-Pipeline als absoluter Anfänger gebaut. Hier erfahren Sie, wie.

Ich dachte, Knowledge Engineering sei nur das Schreiben von Skripten. Ich habe mich geirrt.

Verbinde dich mit mir LinkedIn, YouTubeUnd Twitter.

Bild vom Autor

# Einführung

Es gibt heute zahlreiche Instruments zur Verarbeitung von Datensätzen. Sie alle behaupten – und das tun sie natürlich auch –, dass sie die beste und richtige Wahl für Sie sind. Aber sind sie es? Es gibt zwei Hauptanforderungen, die diese Instruments erfüllen sollten: Sie sollten alltägliche Datenanalysevorgänge einfach und schnell durchführen, selbst unter dem Druck großer Datenmengen.

Um das beste Werkzeug zu ermitteln DuckDB, SQLiteUnd Pandaswir haben sie unter diesen Bedingungen getestet.

Zunächst gaben wir ihnen nur alltägliche Analyseaufgaben: Summieren von Werten, Gruppieren nach Kategorien, Filtern mit Bedingungen und Aggregationen mehrerer Felder. Dies spiegelte wider, wie Analysten tatsächlich mit realen Datensätzen arbeiten, im Vergleich zu Szenarien, die darauf ausgelegt sind, die besten Eigenschaften eines Instruments darzustellen.

Zweitens haben wir diese Operationen an einem Kaggle-Datensatz mit über 1 Million Zeilen durchgeführt. Es ist ein realistischer Wendepunkt – klein genug, um auf einem einzelnen Laptop ausgeführt zu werden, aber groß genug, dass Speicherdruck und Abfragegeschwindigkeit deutliche Unterschiede zwischen den Instruments erkennen lassen.

Mal sehen, wie diese Exams verlaufen sind.

# Der von uns verwendete Datensatz

// Datensatzübersicht

Wir haben den Bankdatensatz von verwendet Kaggle. Dieser Datensatz enthält über 1 Million Zeilen, bestehend aus fünf Spalten:

Dieser Datensatz wird mit Python generiert. Auch wenn es möglicherweise nicht ganz den realen Daten ähnelt, reichen Größe und Struktur aus, um die Leistungsunterschiede zwischen den Instruments zu testen und zu vergleichen.

// Mit Pandas einen Blick in die Daten werfen

Wir haben verwendet Pandas um den Datensatz in ein Jupyter-Notizbuch zu laden und seine allgemeine Struktur, Abmessungen und Nullwerte zu untersuchen. Hier ist der Code.

import pandas as pd
df = pd.read_excel('bankdataset.xlsx')

print("Dataset form:", df.form)

df.head()

Hier ist die Ausgabe.

Wenn Sie einen schnellen Überblick über gängige Vorgänge beim Durchsuchen von Datensätzen benötigen, schauen Sie sich dieses praktische Handbuch an Pandas-Spickzettel.

Sehen wir uns vor dem Benchmarking an, wie die Umgebung eingerichtet wird.

# Einrichten einer fairen Testumgebung

Alle drei Instruments – DuckDB, SQLite und Pandas – wurden in derselben Jupyter Pocket book-Umgebung eingerichtet und ausgeführt, um sicherzustellen, dass der Check truthful battle. Dadurch wurde sichergestellt, dass die Bedingungen zur Laufzeit und die Speichernutzung durchgehend konstant blieben.

Zuerst haben wir die notwendigen Pakete installiert und geladen.

Hier sind die Instruments, die wir brauchten:

• Pandas: für Normal DataFrame Operationen
• duckdb: für die SQL-Ausführung auf a DataFrame
• sqlite3: zum Verwalten einer eingebetteten SQL-Datenbank
• Zeit: zum Erfassen der Ausführungszeit
• Memory_profiler: um die Speicherzuordnung zu messen

# Set up if any of them should not in your surroundings
!pip set up duckdb --quiet

import pandas as pd
import duckdb
import sqlite3
import time
from memory_profiler import memory_usage

Bereiten wir nun die Daten in einem Format vor, das von allen drei Instruments gemeinsam genutzt werden kann.

// Daten in Pandas laden

Wir verwenden Pandas, um den Datensatz einmal zu laden, und geben ihn dann für DuckDB und SQLite frei oder registrieren ihn.

df = pd.read_excel('bankdataset.xlsx')

df.head()

Hier ist die zu validierende Ausgabe.

// Registrieren von Daten bei DuckDB

Mit DuckDB können Sie direkt auf Pandas zugreifen DataFrameS. Sie müssen nichts umrechnen – einfach registrieren und abfragen. Hier ist der Code.

# Register DataFrame as a DuckDB desk
duckdb.register("bank_data", df)

# Question through DuckDB
duckdb.question("SELECT * FROM bank_data LIMIT 5").to_df()

Hier ist die Ausgabe.

// Vorbereiten von Daten für SQLite

Da SQLite Excel-Dateien nicht direkt liest, haben wir zunächst die Pandas hinzugefügt DataFrame an eine In-Reminiscence-Datenbank. Anschließend verwendeten wir eine einfache Abfrage, um das Datenformat zu untersuchen.

conn_sqlite = sqlite3.join(":reminiscence:")

df.to_sql("bank_data", conn_sqlite, index=False, if_exists="change")

pd.read_sql_query("SELECT * FROM bank_data LIMIT 5", conn_sqlite)

Hier ist die Ausgabe.

# Wie wir die Instruments bewertet haben

Wir haben dieselben vier Abfragen für DuckDB, SQLite und Pandas verwendet, um ihre Leistung zu vergleichen. Jede Abfrage wurde für eine allgemeine Analyseaufgabe entwickelt, die widerspiegelt, wie die Datenanalyse in der realen Welt angewendet wird.

// Sicherstellung einer konsistenten Einrichtung

Der In-Reminiscence-Datensatz wurde von allen drei Instruments verwendet.

• Pandas befragte die DataFrame direkt
• DuckDB führte SQL-Abfragen direkt gegen die aus DataFrame
• SQLite hat eine Kopie davon gespeichert DataFrame in einer In-Reminiscence-Datenbank und führte darauf SQL-Abfragen aus

Diese Methode stellte sicher, dass alle drei Instruments dieselben Daten verwendeten und mit denselben Systemeinstellungen arbeiteten.

// Messung der Ausführungszeit

Um die Abfragedauer zu verfolgen, verwendet Python time Das Modul verpackte jede Abfrage in einen einfachen Begin-/Finish-Timer. Es wurde nur die Ausführungszeit der Abfrage aufgezeichnet; Datenlade- und Vorbereitungsschritte wurden ausgeschlossen.

// Verfolgen der Speichernutzung

Zusammen mit der Verarbeitungszeit zeigt die Speichernutzung an, wie intestine jede Engine bei großen Datenmengen funktioniert.

Bei Bedarf kann die Speichernutzung unmittelbar vor und nach jeder Abfrage abgetastet werden, um den inkrementellen RAM-Verbrauch abzuschätzen.

// Die Benchmark-Abfragen

Wir haben jede Engine anhand derselben vier alltäglichen Analyseaufgaben getestet:

1. Gesamttransaktionswert: Summieren einer numerischen Spalte
2. Nach Domäne gruppieren: Aggregieren der Transaktionszahlen professional Kategorie
3. Nach Standort filtern: Zeilen werden vor der Aggregation nach einer Bedingung gefiltert
4. Gruppieren nach Domäne und Standort: Mehrfeldaggregation mit Durchschnittswerten

# Benchmark-Ergebnisse

// Abfrage 1: Gesamttransaktionswert

Hier messen wir, wie Pandas, DuckDB und SQLite bei der Summierung abschneiden Worth Spalte im gesamten Datensatz.

// Pandas-Leistung

Wir berechnen den Gesamttransaktionswert anhand von .sum() auf der Worth Spalte. Hier ist der Code.

pandas_results = ()

def pandas_q1():
    return df('Worth').sum()

mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q1()
finish = time.time()
mem_after = memory_usage(-1)(0)

pandas_results.append({
    "engine": "Pandas",
    "question": "Complete transaction worth",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})
pandas_results

Hier ist die Ausgabe.

// DuckDB-Leistung

Wir berechnen den Gesamttransaktionswert mithilfe einer Vollspaltenaggregation. Hier ist der Code.

duckdb_results = ()

def duckdb_q1():
    return duckdb.question("SELECT SUM(worth) FROM bank_data").to_df()

mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q1()
finish = time.time()
mem_after = memory_usage(-1)(0)

duckdb_results.append({
    "engine": "DuckDB",
    "question": "Complete transaction worth",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})
duckdb_results

Hier ist die Ausgabe.

// SQLite-Leistung

Wir berechnen den gesamten Transaktionswert durch Summieren worth Spalte. Hier ist der Code.

sqlite_results = ()

def sqlite_q1():
    return pd.read_sql_query("SELECT SUM(worth) FROM bank_data", conn_sqlite)

mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q1()
finish = time.time()
mem_after = memory_usage(-1)(0)

sqlite_results.append({
    "engine": "SQLite",
    "question": "Complete transaction worth",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})
sqlite_results

Hier ist die Ausgabe.

// Gesamtleistungsanalyse

Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.

import matplotlib.pyplot as plt


all_q1 = pd.DataFrame(pandas_results + duckdb_results + sqlite_results)

fig, axes = plt.subplots(1, 2, figsize=(10,4))

all_q1.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False, title="Execution Time (s)")
all_q1.plot(x="engine", y="reminiscence", form="barh", colour="salmon", ax=axes(1), legend=False, title="Reminiscence Utilization (MB)")

plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

Pandas ist bei weitem das schnellste und speichereffizienteste hier und wird bei minimaler RAM-Nutzung quick sofort ausgeführt. DuckDB ist etwas langsamer und benötigt mehr Speicher, bleibt aber effizient, während SQLite sowohl am langsamsten als auch am höchsten im Hinblick auf den Speicherverbrauch ist.

// Abfrage 2: Nach Domäne gruppieren

Hier messen wir die Leistung von Pandas, DuckDB und SQLite beim Gruppieren von Transaktionen Area und summieren ihre Zählungen.

// Pandas-Leistung

Wir berechnen die Gesamttransaktionszahl professional Area anhand von .groupby() auf der Area Spalte.

def pandas_q2():
    return df.groupby('Area')('Transaction_count').sum()

mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q2()
finish = time.time()
mem_after = memory_usage(-1)(0)

pandas_results.append({
    "engine": "Pandas",
    "question": "Group by area",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in pandas_results if p("question") == "Group by area")

Hier ist die Ausgabe.

// DuckDB-Leistung

Wir berechnen die Gesamtzahl der Transaktionen professional Area mithilfe einer SQL-Anweisung GROUP BY auf der area Spalte.

def duckdb_q2():
    return duckdb.question("""
        SELECT area, SUM(transaction_count) 
        FROM bank_data 
        GROUP BY area
    """).to_df()

mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q2()
finish = time.time()
mem_after = memory_usage(-1)(0)

duckdb_results.append({
    "engine": "DuckDB",
    "question": "Group by area",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in duckdb_results if p("question") == "Group by area")

Hier ist die Ausgabe.

// SQLite-Leistung

Wir berechnen die Gesamtzahl der Transaktionen professional Area mithilfe von SQL GROUP BY auf der In-Reminiscence-Tabelle.

def sqlite_q2():
    return pd.read_sql_query("""
        SELECT area, SUM(transaction_count) AS total_txn
        FROM bank_data
        GROUP BY area
    """, conn_sqlite)

mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q2()
finish = time.time()
mem_after = memory_usage(-1)(0)

sqlite_results.append({
    "engine": "SQLite",
    "question": "Group by area",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in sqlite_results if p("question") == "Group by area")

Hier ist die Ausgabe.

// Gesamtleistungsanalyse

Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

groupby_results = (r for r in (pandas_results + duckdb_results + sqlite_results) 
                   if "Group by" in r("question"))

df_groupby = pd.DataFrame(groupby_results)

fig, axes = plt.subplots(1, 2, figsize=(10,4))

df_groupby.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False, title="Execution Time (s)")
df_groupby.plot(x="engine", y="reminiscence", form="barh", colour="salmon", ax=axes(1), legend=False, title="Reminiscence Utilization (MB)")

plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

DuckDB ist am schnellsten, Pandas benötigt etwas mehr Zeit für weniger Speicher, während SQLite sowohl am langsamsten als auch am speicherintensivsten ist.

// Abfrage 3: Nach Standort filtern (Goa)

Hier messen wir die Leistung von Pandas, DuckDB und SQLite beim Filtern des Datensatzes Location = 'Goa' und Summieren der Transaktionswerte.

// Pandas-Leistung

Wir filtern Zeilen nach Location == 'Goa' und summieren ihre Werte. Hier ist der Code.

def pandas_q3():
    return df(df('Location') == 'Goa')('Worth').sum()

mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q3()
finish = time.time()
mem_after = memory_usage(-1)(0)

pandas_results.append({
    "engine": "Pandas",
    "question": "Filter by location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in pandas_results if p("question") == "Filter by location")

Hier ist die Ausgabe.

// DuckDB-Leistung

Wir filtern Transaktionen nach Location = 'Goa' und berechnen Sie ihren Gesamtwert. Hier ist der Code.

def duckdb_q3():
    return duckdb.question("""
        SELECT SUM(worth) 
        FROM bank_data 
        WHERE location = 'Goa'
    """).to_df()

mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q3()
finish = time.time()
mem_after = memory_usage(-1)(0)

duckdb_results.append({
    "engine": "DuckDB",
    "question": "Filter by location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in duckdb_results if p("question") == "Filter by location")

Hier ist die Ausgabe.

// SQLite-Leistung

Wir filtern Transaktionen nach Location = 'Goa' und summieren ihre Werte. Hier ist der Code.

def sqlite_q3():
    return pd.read_sql_query("""
        SELECT SUM(worth) AS total_value
        FROM bank_data
        WHERE location = 'Goa'
    """, conn_sqlite)

mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q3()
finish = time.time()
mem_after = memory_usage(-1)(0)

sqlite_results.append({
    "engine": "SQLite",
    "question": "Filter by location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in sqlite_results if p("question") == "Filter by location")

Hier ist die Ausgabe.

// Gesamtleistungsanalyse

Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

filter_results = (r for r in (pandas_results + duckdb_results + sqlite_results)
                  if r("question") == "Filter by location")

df_filter = pd.DataFrame(filter_results)

fig, axes = plt.subplots(1, 2, figsize=(10, 4))

df_filter.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False, title="Execution Time (s)")
df_filter.plot(x="engine", y="reminiscence", form="barh", colour="salmon", ax=axes(1), legend=False, title="Reminiscence Utilization (MB)")

plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

DuckDB ist die schnellste und effizienteste; Pandas ist bei höherer Speichernutzung langsamer; und SQLite ist am langsamsten, benötigt aber weniger Speicher.

// Abfrage 4: Gruppieren nach Domäne und Standort

// Pandas-Leistung

Wir berechnen den durchschnittlichen Transaktionswert gruppiert nach beiden Area Und Location. Hier ist der Code.

def pandas_q4():
    return df.groupby(('Area', 'Location'))('Worth').imply()

mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q4()
finish = time.time()
mem_after = memory_usage(-1)(0)

pandas_results.append({
    "engine": "Pandas",
    "question": "Group by area & location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in pandas_results if p("question") == "Group by area & location")

Hier ist die Ausgabe.

// DuckDB-Leistung

Wir berechnen den durchschnittlichen Transaktionswert gruppiert nach beiden area Und location. Hier ist der Code.

def duckdb_q4():
    return duckdb.question("""
        SELECT area, location, AVG(worth) AS avg_value
        FROM bank_data
        GROUP BY area, location
    """).to_df()

mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q4()
finish = time.time()
mem_after = memory_usage(-1)(0)

duckdb_results.append({
    "engine": "DuckDB",
    "question": "Group by area & location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in duckdb_results if p("question") == "Group by area & location")

Hier ist die Ausgabe.

// SQLite-Leistung

Wir berechnen den durchschnittlichen Transaktionswert gruppiert nach beiden area Und location. Hier ist der Code.

def sqlite_q4():
    return pd.read_sql_query("""
        SELECT area, location, AVG(worth) AS avg_value
        FROM bank_data
        GROUP BY area, location
    """, conn_sqlite)

mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q4()
finish = time.time()
mem_after = memory_usage(-1)(0)

sqlite_results.append({
    "engine": "SQLite",
    "question": "Group by area & location",
    "time": spherical(finish - begin, 4),
    "reminiscence": spherical(mem_after - mem_before, 4)
})

(p for p in sqlite_results if p("question") == "Group by area & location")

Hier ist die Ausgabe.

// Gesamtleistungsanalyse

Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

gdl_results = (r for r in (pandas_results + duckdb_results + sqlite_results)
               if r("question") == "Group by area & location")

df_gdl = pd.DataFrame(gdl_results)

fig, axes = plt.subplots(1, 2, figsize=(10, 4))

df_gdl.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False,
            title="Execution Time (s)")
df_gdl.plot(x="engine", y="reminiscence", form="barh", ax=axes(1), legend=False,
            title="Reminiscence Utilization (MB)", colour="salmon")

plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

DuckDB verarbeitet Mehrfeld-Gruppierungen am schnellsten bei mäßiger Speichernutzung, Pandas ist bei sehr hoher Speichernutzung langsamer und SQLite ist bei erheblichem Speicherverbrauch am langsamsten.

# Endgültiger Vergleich aller Abfragen

Wir haben diese drei Engines hinsichtlich Speicher und Geschwindigkeit miteinander verglichen. Schauen wir uns noch einmal die Ausführungszeit an. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

all_results = pd.DataFrame(pandas_results + duckdb_results + sqlite_results)

measure_order = (
    "Complete transaction worth",
    "Group by area",
    "Filter by location",
    "Group by area & location",
)
engine_colors = {"Pandas": "#1f77b4", "DuckDB": "#ff7f0e", "SQLite": "#2ca02c"}

fig, axes = plt.subplots(2, 2, figsize=(12, 8))
axes = axes.ravel()

for i, q in enumerate(measure_order):
    d = all_results(all_results("question") == q)
    axes(i).barh(d("engine"), d("time"), 
                 colour=(engine_colors(e) for e in d("engine")))
    for y, v in enumerate(d("time")):
        axes(i).textual content(v, y, f" {v:.3f}", va="heart")
    axes(i).set_title(q, fontsize=10)
    axes(i).set_xlabel("Seconds")

fig.suptitle("Per-Measure Comparability — Execution Time", fontsize=14)
plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

Dieses Diagramm zeigt, dass DuckDB bei quick allen Abfragen durchweg die niedrigsten Ausführungszeiten aufweist, mit Ausnahme des Gesamttransaktionswerts, bei dem Pandas die Nase vorn hat. SQLite ist auf der ganzen Linie mit Abstand das langsamste. Lassen Sie uns als nächstes den Speicher überprüfen. Hier ist der Code.

import pandas as pd
import matplotlib.pyplot as plt

all_results = pd.DataFrame(pandas_results + duckdb_results + sqlite_results)

measure_order = (
    "Complete transaction worth",
    "Group by area",
    "Filter by location",
    "Group by area & location",
)
engine_colors = {"Pandas": "#1f77b4", "DuckDB": "#ff7f0e", "SQLite": "#2ca02c"}

fig, axes = plt.subplots(2, 2, figsize=(12, 8))
axes = axes.ravel()

for i, q in enumerate(measure_order):
    d = all_results(all_results("question") == q)
    axes(i).barh(d("engine"), d("reminiscence"), 
                 colour=(engine_colors(e) for e in d("engine")))
    for y, v in enumerate(d("reminiscence")):
        axes(i).textual content(v, y, f" {v:.1f}", va="heart")
    axes(i).set_title(q, fontsize=10)
    axes(i).set_xlabel("MB")

fig.suptitle("Per-Measure Comparability — Reminiscence Utilization", fontsize=14)
plt.tight_layout()
plt.present()

Hier ist die Ausgabe.

Dieses Diagramm zeigt, dass SQLite bei der Speichernutzung zwischen der besten und der schlechtesten Leistung schwankt, Pandas mit zwei besten und zwei schlechtesten Fällen extrem ist, während DuckDB bei allen Abfragen konstant im Mittelfeld bleibt. Infolgedessen erweist sich DuckDB insgesamt als die ausgewogenste Wahl und liefert eine konstant schnelle Leistung bei moderater Speichernutzung. Pandas zeigt Excessive – manchmal die schnellsten, manchmal die schwersten –, während SQLite mit der Geschwindigkeit zu kämpfen hat und beim Speicher oft auf der ineffizienten Seite landet.

Nate Rosidi ist Datenwissenschaftler und in der Produktstrategie tätig. Er ist außerdem außerordentlicher Professor für Analytik und Gründer von StrataScratch, einer Plattform, die Datenwissenschaftlern hilft, sich mit echten Interviewfragen von High-Unternehmen auf ihre Interviews vorzubereiten. Nate schreibt über die neuesten Traits auf dem Karrieremarkt, gibt Ratschläge zu Vorstellungsgesprächen, stellt Knowledge-Science-Projekte vor und behandelt alles rund um SQL.

OpenAI wurde offiziell veröffentlicht Soraam dritten Tag ihrer „12 Days of OpenAI“-Reihe. Nach Monaten der Spannung seit seiner ersten Ankündigung im April 2024 hat sich Sora als großer Sprung im Bereich KI-generierter Videoinhalte erwiesen. OpenAI hat das Sora Turbo-Modell veröffentlicht, die beschleunigte Excessive-Finish-Model des ursprünglichen Sora-Modells. Schauen wir uns die neu hinzugefügten Funktionen an und probieren Sie es aus!

Unser Weihnachtsgeschenk an Sie: Sora ist da. https://t.co/UhdmYuGHtT pic.twitter.com/ljoruQsfO0

— OpenAI (@OpenAI) 9. Dezember 2024

Was ist Sora?

Sora ist ein Textual content-zu-Video-Generator das nutzt fortgeschrittene Diffusionsmodelle Und Transformatorarchitekturen um Movies basierend auf schriftlichen Beschreibungen zu erstellen. Diese Movies werden erstellt, indem man mit Rauschen beginnt und es in mehreren Schritten schrittweise verfeinert. Dieser Diffusionsprozess ermöglicht es dem Modell, realistische, kohärente Videosequenzen aus einer Vielzahl von Texteingaben zu erstellen.

Aufbauend auf den früheren Erfolgen von OpenAI mit GPT, DALL·EUnd CLIPstellt Sora einen großen Fortschritt dar, indem es Benutzern ermöglicht, Movies von Grund auf zu erstellen oder bestehende auf der Grundlage von Texteingabeaufforderungen zu erweitern. Ob es darum geht, ein völlig neues Video zu erstellen oder ein Bild zu animieren, Soras Fähigkeit, visuell überzeugende Erzählungen direkt aus natürlicher Sprache zu erstellen, ist beispiellos.

Funktionen von OpenAI Sora

• Movies aus Textual content generieren: Erstellen Sie Movies aus einfachen Textaufforderungen.
• Vorhandene Movies erweitern: Bestehende Movies fortsetzen oder ändern.
• Bilder animieren: Erwecken Sie Standbilder mit Animationen zum Leben.
• Bewältigen Sie komplexe Szenen: Behalten Sie die Kontinuität über mehrere Frames hinweg bei.
• Skalieren und anpassen: Erstellen Sie Movies in verschiedenen Formaten und Längen.
• Transformationsvideos: Ändern Sie vorhandene Movies basierend auf Textaufforderungen.

Wichtige Verbesserungen

• Realistische Physik: Natürlichere Objektbewegung.
• Längere Movies: Erstellen Sie Movies mit einer Länge von bis zu 20 Sekunden.
• Verbesserte Beleuchtung: Optisch ansprechendere Movies mit dynamischen Lichteffekten.

OpenAI Sora auf die Probe stellen

Immediate: Erstellen Sie ein Video über einen weißen Hund, der mit einem Kätzchen spielt

Immediate: Erstellen Sie ein Video von einem tanzenden Hund am Strand.

Storyboard-Eingabeaufforderung

Immediate:

• Eine anschauliche Animation zeigt die Aufnahme eines psychotropen Moleküls, dargestellt als kleines, leuchtendes Partikel, das in den Mund gelangt. Der Hintergrund ist eine stilisierte Darstellung des menschlichen Verdauungssystems, wobei die wirbelnden Farben den Beginn einer komplexen Reise andeuten.
• Das Molekül wandert durch den Blutkreislauf, umgeben von roten und weißen Blutkörperchen. Es wird als helles, leuchtendes Teilchen dargestellt, das sich schnell durch ein Netzwerk von Blutgefäßen bewegt.
• Das Molekül erreicht die Blut-Hirn-Schranke, dargestellt als schimmernde Wand, durchdringt diese und dringt in das Gehirn ein. Die Szene wird komplexer, da Neuronen und Synapsen aufleuchten, wenn das Molekül mit ihnen interagiert.

Immediate:

1. In einem heat erleuchteten Kinderzimmer sitzen ein kleiner Junge und ein kleines Mädchen in einer gemütlichen provisorischen Jurte aus karierten Decken und Kissen. Sie tragen verspielte Hüte und Filzstiefel und sind vom sanften Schein der Lampen umgeben. Die Kinder kichern, während sie mit einem Spielzeug-Rentier spielen, und ihre Augen funkeln vor Fantasie.
2. Die Kinder schließen fest die Augen, ein Gefühl der Vorfreude liegt in der Luft.
3. Wenn sie ihre Augen öffnen, verwandeln sie sich in Erwachsene und stehen vor einer modernen Hotellandschaft in Jakutien, umgeben von echten Jurten und einer riesigen, verschneiten Winterlandschaft.

Beobachtung: Beim Erstellen der Movies mit dem ChatGPT Plus Das Konto hat mich viel Zeit gekostet, ich sehe, dass es viel Raum für Verbesserungen gibt.

Wie greife ich auf Sora zu?

Sora ist über die neue Web site erreichbar – sora.com. Sie können Ihre ChatGPT-Pläne verwenden, um Zugriff auf das Modell zu erhalten:

• ChatGPT Plus-Konto: Dieser Plan gibt Ihnen 50 Generationen professional Monat. Diese könnten mit der Anzahl der Textual content-zu-Video-Erstellungen oder anderen spezifischen Aufgaben professional Monat zusammenhängen.
• OpenAI Professional-Konto: Das bietet unbegrenzte Generationen im langsamen Warteschlangenmodus, plus 500 schnellere Generationen professional Monat. Der Schwerpunkt dieser Stufe scheint darauf zu liegen, mehr Flexibilität zu bieten, mit der Possibility, Aufgaben für eine bestimmte Anzahl von Generationen schneller zu verarbeiten, während andere Aufgaben möglicherweise in die Warteschlange gestellt und langsamer verarbeitet werden.
• Verfügbarkeit: Der Dienst steht dem nicht zur Verfügung Großbritannien und EU Dies kann aus rechtlichen, behördlichen oder datenschutzrechtlichen Gründen (z. B. DSGVO) erfolgen. Diese Einschränkung könnte in Zukunft aufgehoben werden, wenn das Unternehmen auf weitere Regionen expandiert.

OpenAI Sora-Funktionen

Separates Produkt

• Sora ist ein eigenständiges Produkt, das nicht in ChatGPT oder andere OpenAI-Plattformen integriert ist.
• Erreichbar über Sora.comwo kürzlich erstellte und kuratierte Movies angezeigt werden.

Videoerstellung und -bearbeitung

• Generieren Sie Movies aus Eingabeaufforderungen: Benutzer können Movies basierend auf Textaufforderungen erstellen.
• Bilder hochladen: Benutzer können auch Bilder hochladen, mit denen Sora Movies erstellen kann.
• Remix-Funktion: Ermöglicht Benutzern, Änderungen an vorhandenen Movies vorzunehmen, indem die gewünschten Änderungen beschrieben werden.
  • Stärkeeinstellung: Steuert, wie drastisch das Video verändert wird, wobei höhere Einstellungen zu stärkeren künstlerischen Veränderungen führen.
• Videobearbeitung: Sora kann auch Movies bearbeiten, die ursprünglich mit dem Device generiert wurden.

Bild-Add und -Verbesserung

• Bilder hochladen: Sie können damit beginnen, ein Bild hochzuladen, um ein Video zu erstellen. Dieses Bild kann als Foundation dienen und Sie können es mit weiteren Elementen, Textual content oder Animationen erweitern.
• Textbeschreibung: Sie können das Bild auch mit Textual content beschreiben. Je detaillierter Ihre Beschreibung, desto konkreter folgt die Videoerstellung Ihren Anweisungen. Bei weniger detaillierten Beschreibungen füllt das Device die Lücken mit allgemeiner Kreativität und Particulars.

Themen (Voreinstellungen)

• SORA bietet verschiedene Voreinstellungen, mit denen das Gesamtthema des Movies definiert werden kann. Einige Beispiele sind:
  • Ballonwelt: Diese Voreinstellung könnte eine skurrile oder traumhafte Atmosphäre schaffen.
  • Cease-Movement: Eine Voreinstellung, die den Cease-Movement-Animationsstil emuliert und Ihrem Video Bild für Bild ein handgefertigtes Aussehen verleiht.

Auswahl des Seitenverhältnisses

• Sie können das Seitenverhältnis für Ihr Video auswählen. Zu den gängigen Optionen gehören:
  • 16:9 (Breitbild): Excellent für die meisten Movies, insbesondere für YouTube, Breitbildfilme usw.
  • 1:1 (Quadrat): Geeignet für Social-Media-Beiträge wie Instagram.
  • 9:16 (Vertikal): Perfekt für Plattformen wie TikTok oder Instagram Tales.

Videodauer

• Sie können die Dauer Ihres Movies auf bis zu einstellen 20 Sekundenwas Ihnen Flexibilität bei der Menge der enthaltenen Inhalte gibt.

Textual content- und Bildintegration

• Die Plattform ermöglicht die Kombination von Textual content und Bildern für den kreativen Ausdruck:
  • Erstellen Sie durch Hochladen von Bildern: Sie laden ein Bild hoch, das als Grundlage für Ihr Video dient, und erweitern oder animieren es dann mit zusätzlichen Inhalten.
  • Textbasierte Erstellung: Sie können Szenen oder Bilder mit Textual content beschreiben. Je spezifischer der Textual content, desto mehr folgt das Video Ihrer Richtung. Beispielsweise wird das Video durch eine detaillierte Beschreibung angeleitet, die genauen Elemente wiederzugeben, die Sie erwähnen.

Storyboard (Erweiterte Erstellung)

• Für komplexere Videoprojekte, Storyboard Im Modus können Sie die Videoerstellung entlang einer Zeitleiste steuern. Dies bietet:
  • Kontrolle über die Reihenfolge: Sie können die Reihenfolge der Elemente (Textual content, Bilder und Movies) festlegen.
  • Erweiterte Bearbeitung: Es ermöglicht eine präzisere Anpassung und Abfolge von Szenen.
  • Multimedia-Integration: Sie können Bilder, Textual content und Videoclips kombinieren, um eine Erzählung oder eine komplexe visuelle Geschichte zu erstellen.

Videoqualität und Auflösung

• Auflösungsoptionen: Erzeugt Movies bis zu 1080p Auflösung.
  • 1080p-Filmmaterial dauert 8x länger zu generieren im Vergleich zu 480p, was die schnellste Possibility ist.
  • 720p dauert 4x länger als 480p.
  • 480p ist am schnellsten.
• Durchschnittliche Generationszeit: A ein paar Minuten für ein 1080p-Video (je nach Benutzernachfrage und Datenverkehr).

Kurzgesagt,

SORA ist eine versatile, benutzerfreundliche Plattform zur Videoerstellung mit leistungsstarken Anpassungsoptionen. Du kannst:

• Laden Sie Bilder hoch oder beschreiben Sie Szenen mit Textual content.
• Wählen Sie aus verschiedenen Themenvoreinstellungen wie Balloon World oder Cease Movement.
• Steuern Sie das Seitenverhältnis und die Videodauer.
• Verwenden Sie den Storyboard-Modus für erweiterte Videobearbeitung und -sequenzierung.

Diese Kombination von Funktionen macht es Benutzern leicht, ansprechende, professionell aussehende Movies zu erstellen, selbst mit minimalen technischen Kenntnissen.

Diese Funktionen machen Sora zu einem leistungsstarken, aber immer noch unvollkommenen Device zum Generieren kreativer Videoinhalte, insbesondere für nicht fotorealistische, stilisierte Projekte.

Soras technische Grundlagen

Sora basiert im Wesentlichen auf dem Diffusionsmodelleine Technik, die mit zufälligem Rauschen beginnt und es iterativ zu einem zusammenhängenden Video verfeinert. Dieser Prozess spiegelt die Custom wider Bild-zu-Bild Diffusionsmodelle funktionieren, jedoch mit der zusätzlichen Komplexität von Videosequenzen.

Der Schlüssel zu Soras Innovation liegt in der Verwendung von Patch-basierte Darstellung sowohl für Bilder als auch für Movies. Ähnlich wie Token in GPT werden Movies und Bilder in Sora in kleinere „Datenfelder“ zerlegt. Dadurch kann das Modell große und komplexe visuelle Daten effizienter verarbeiten und Movies mit unterschiedlicher Dauer und Auflösung generieren.

Darüber hinaus baut Sora auf dem auf Recaptioning-Technik verwendet in DALL·E 3was es ihm ermöglicht, sehr aussagekräftige Untertitel für seine Trainingsdaten zu generieren. Diese Fähigkeit ermöglicht es dem Modell, Textaufforderungen genau zu folgen, was zu Movies führt, die den Benutzeranweisungen treu bleiben und besser auf die Eingabebeschreibung abgestimmt sind.

Lesen Sie auch: Was ist der Sora Diffusion Transformer (DiT) von OpenAI?

Ethische Überlegungen von OpenAI Sora

Folgendes erwartet Sora von Ihnen:

1. Zustimmung: Laden Sie Medien mit Personen nur mit deren ausdrücklicher Erlaubnis hoch und stellen Sie sicher, dass Personen unter 18 Jahren über die entsprechende Einwilligung verfügen.
2. Gewalt und explizite Themen: Laden Sie keine Inhalte hoch, die Gewalt, explizite Themen oder Inhalte für Erwachsene darstellen.
3. Rechte an Medien: Stellen Sie sicher, dass Sie über die erforderlichen Eigentumsrechte oder Rechte zum Hochladen der von Ihnen freigegebenen Medien verfügen.
4. Konsequenzen: Der Missbrauch der Plattform durch Verstöße gegen diese Regeln kann zur Sperrung oder Sperrung des Kontos ohne Rückerstattung führen.

Wichtige Erkenntnisse

Sora von OpenAI ist ein Textual content-zu-Video-Generator mit Funktionen wie Themen, Storyboard-Modus und Auflösungen von bis zu 1080p. Es weist jedoch erhebliche Einschränkungen auf. Movies sind auf 20 Sekunden begrenzt, was für längere Erzählungen möglicherweise nicht geeignet ist. Das Rendern mit hoher Auflösung (z. B. 1080p) ist zeitintensiv und verlangsamt die Generierung im Vergleich zu niedrigeren Auflösungen erheblich. Derzeit ist Sora im Vereinigten Königreich/in der EU aufgrund regulatorischer Probleme nicht verfügbar, was den Zugang einschränkt. Darüber hinaus schränken ethische Richtlinien die Nutzung ein und bei Verstößen besteht die Gefahr einer Kontosperrung. Sora ist leistungsstark, entwickelt sich jedoch weiter und bietet Raum für technische Verbesserungen und Verbesserungen bei der Zugänglichkeit. Außerdem ist die Generierungsgeschwindigkeit ziemlich langsam, was auf die hochauflösenden Movies zurückzuführen ist. Ich hoffe jedoch, dass es sich mit der Zeit verbessern wird, da OpenAI das Modell und die zugrunde liegende Infrastruktur weiter optimiert. Zukünftige Updates können zu schnelleren Generierungsgeschwindigkeiten führen, ohne die Qualität hochauflösender Movies zu beeinträchtigen, wodurch der Prozess effizienter und benutzerfreundlicher wird.

Abschluss

Soras letzte Veröffentlichung ist ein bemerkenswerter Meilenstein in der Entwicklung der künstlichen Intelligenz und vereint die neuesten Fortschritte in Verarbeitung natürlicher Sprache (NLP), Pc Imaginative and prescientUnd tiefes Lernen um hochwertige Kurzvideos direkt aus Textaufforderungen zu generieren. Die potenziellen Auswirkungen dieser Technologie sind weitreichend und reichen von der Kreativbranche bis hin zu Bildung, Advertising und darüber hinaus.

Die Imaginative and prescient von OpenAI für das Modell ist weitreichend, mit dem ultimativen Ziel, Systeme zu schaffen, die die reale Welt simulieren können, was uns der Verwirklichung einen Schritt näher bringt Künstliche Allgemeine Intelligenz (AGI). Mit der Weiterentwicklung von Sora werden seine Fähigkeiten wahrscheinlich erweitert und erweiterte Funktionen wie Echtzeit-Videogenerierung, interaktives Storytelling und sogar die Integration mit virtueller und erweiterter Realität umfassen.

Hast du es versucht? Teilen Sie mir Ihre Meinung im Kommentarbereich unten mit!

Hallo, ich bin Pankaj Singh Negi – Senior Content material Editor | Leidenschaft für das Geschichtenerzählen und die Erstellung überzeugender Erzählungen, die Ideen in wirkungsvolle Inhalte verwandeln. Ich liebe es, über Technologie zu lesen, die unseren Lebensstil revolutioniert.