Vektorisierte Python-UDFs¶

Übersicht¶

Mit vektorisierten Python-UDFs können Sie Python-Funktionen definieren, mit denen Batches von Eingabezeilen als Pandas DataFrames empfangen und Batches von Ergebnissen als Pandas-Arrays oder Pandas Series zurückgeben werden. Vektorisierte Python-UDFs werden genauso aufgerufen wie andere Python-UDFs.

Die Verwendung von vektorisierten Python-UDFs bietet im Vergleich zur zeilenweisen Standardverarbeitung folgende Vorteile:

• Potenziell bessere Performance, wenn der Python-Code effizient auf Batches von Zeilen ausgeführt wird

• Weniger Transformationslogik durch den Aufruf von Bibliotheken, die Pandas DataFrames oder Pandas-Arrays verarbeiten.

Vektorisierte Python-UDFs bieten folgende Vorteile:

• Das Schreiben von Abfragen muss für Python-UDFs nicht geändert werden. Die gesamte Batchverarbeitung wird vom UDF-Framework und nicht von Ihrem eigenen Code übernommen.

• Wie bei nicht vektorisierten UDFs gibt es keine Garantie dafür, welche Instanzen Ihres Handler-Codes welche Batches von Eingaben verarbeiten werden.

Erste Schritte mit vektorisierten Python-UDFs¶

Um eine Python-UDF zu erstellen, verwenden Sie eines der unterstützten Verfahren zum Kommentieren Ihrer Handler-Funktion.

create function add_one_to_inputs(x number(10, 0), y number(10, 0))
returns number(10, 0)
language python
runtime_version = 3.8
packages = ('pandas')
handler = 'add_one_to_inputs'
as $$
import pandas
from _snowflake import vectorized

@vectorized(input=pandas.DataFrame)
def add_one_to_inputs(df):
  return df[0] + df[1] + 1
$$;

create function add_one_to_inputs(x number(10, 0), y number(10, 0))
returns number(10, 0)
language python
runtime_version = 3.8
packages = ('pandas')
handler = 'add_one_to_inputs'
as $$
import pandas

def add_one_to_inputs(df):
  return df[0] + df[1] + 1

add_one_to_inputs._sf_vectorized_input = pandas.DataFrame
$$;

Festlegen einer Zielbatchgröße¶

Aufrufe der Python-Handler-Funktion müssen innerhalb eines Zeitlimits von 180 Sekunden ausgeführt werden, wobei aber jeder DataFrame, der als Eingabe an die Handler-Funktion übergeben wird, derzeit bis zu einige tausend Zeilen enthalten. Um das Zeitlimit einzuhalten, sollten Sie für Ihre Handler-Funktion eine Zielbatchgröße festlegen, die eine maximale Anzahl von Zeilen pro Eingabe-DataFrame vorgibt. Beachten Sie, dass die Einstellung eines größeren Wertes nicht garantiert, dass Snowflake Batches mit der angegebenen Anzahl von Zeilen codieren wird. Sie können die Zielbatchgröße entweder mit dem Decorator-Element vectorized oder mit einem Attribut der Funktion festlegen.

create function add_one_to_inputs(x number(10, 0), y number(10, 0))
returns number(10, 0)
language python
runtime_version = 3.8
packages = ('pandas')
handler = 'add_one_to_inputs'
as $$
import pandas
from _snowflake import vectorized

@vectorized(input=pandas.DataFrame, max_batch_size=100)
def add_one_to_inputs(df):
  return df[0] + df[1] + 1
$$;

create function add_one_to_inputs(x number(10, 0), y number(10, 0))
returns number(10, 0)
language python
runtime_version = 3.8
packages = ('pandas')
handler = 'add_one_to_inputs'
as $$
import pandas

def add_one_to_inputs(df):
  return df[0] + df[1] + 1

add_one_to_inputs._sf_vectorized_input = pandas.DataFrame
add_one_to_inputs._sf_max_batch_size = 100
$$;

DataFrame-Codierung¶

Batches von Argumenten für die UDF werden als Arrays in der Pandas DataFrames-Eingabe codiert, wobei die Anzahl der Zeilen in jedem DataFrame variieren kann. Weitere Informationen dazu finden Sie unter Festlegen einer Zielbatchgröße. Auf die Argumente kann in dem DataFrame über deren Index zugegriffen werden, d. h. das erste Argument hat den Index 0, das zweite den Index 1 und so weiter. Das Pandas-Array oder die Pandas Series, die der UDF-Handler zurückgibt, muss die gleiche Länge haben wie die der Eingabe-DataFrame.

Angenommen, Sie definieren eine vektorisierte Python-UDF wie folgt:

create or replace function add_inputs(x int, y float)
returns float
language python
runtime_version = 3.8
packages = ('pandas')
handler = 'add_inputs'
as $$
import pandas
from _snowflake import vectorized

@vectorized(input=pandas.DataFrame)
def add_inputs(df):
  return df[0] + df[1]
$$;

Dieses UDF verwendet df[0] für den Zugriff auf das erste Argument des Pandas-Arrays und df[1] für das zweite. df[0] + df[1] ergibt ein Pandas-Array mit den paarweisen Summen der entsprechenden Elemente aus beiden Arrays. Nachdem Sie die UDF erstellt haben, können Sie diese mit einigen Eingabezeilen aufrufen:

select add_inputs(x, y)
from (
  select 1 as x, 3.14::float as y union all
  select 2, 1.59 union all
  select 3, -0.5
);
+------------------+
| ADD_INPUTS(X, Y) |
|------------------|
|             4.14 |
|             3.59 |
|             2.5  |
+------------------+

m folgenden Beispiel erhält die Python-Funktion add_inputs einen DataFrame analog zu einem Datenframe, der mit dem folgenden Python-Code erstellt wurde:

>>> import pandas
>>> df = pandas.DataFrame({0: pandas.array([1, 2, 3]), 1: pandas.array([3.14, 1.59, -0.5])})
>>> df
   0     1
0  1  3.14
1  2  1.59
2  3 -0.50

Die Zeile return df[0] + df[1] in der Handler-Funktion ergibt ein Array ähnlich dem folgenden Python-Code:

>>> df[0] + df[1]
0    4.14
1    3.59
2    2.50
dtype: float64