Как преобразовать тензор TensorFlow в NumPy в режиме графа?

Краткий обзор TensorFlow и NumPy

TensorFlow и NumPy — это две мощные библиотеки в экосистеме Python, широко используемые для численных вычислений. NumPy зарекомендовал себя как стандарт для работы с многомерными массивами и выполнения базовых математических операций. TensorFlow, изначально созданный для глубокого обучения, предлагает возможности автоматического дифференцирования, оптимизации вычислений на различных устройствах (CPU, GPU, TPU) и построения вычислительных графов.

Хотя TensorFlow имеет свой собственный тип данных — Tensor — который во многом схож с массивами NumPy, существуют сценарии, когда необходимо преобразовать Tensor в массив NumPy или наоборот.

Важность преобразования между TensorFlow Tensor и NumPy

Несмотря на схожесть, Tensor и ndarray имеют принципиальные отличия, особенно в контексте вычислений. NumPy массивы обычно статичны и обрабатываются на CPU (если явно не используются сторонние библиотеки). TensorFlow Tensorы динамичны по своей природе (в режиме Eager Execution) или являются узлами в вычислительном графе (в режиме графа), и могут быть размещены на различных устройствах.

Необходимость преобразования возникает, когда:

• Вам нужно использовать функциональность NumPy, которая не реализована в TensorFlow (например, специфичные операции со строками или специализированные статистические функции).
• Вы хотите передать данные из TensorFlow модели для постобработки или анализа с использованием других библиотек, которые работают с NumPy (например, Scipy, Pandas, Matplotlib).
• Интеграция существующего кода на NumPy в конвейер TensorFlow.

Определение ‘режима графа’ в TensorFlow

Режим графа (Graph Mode) в TensorFlow предполагает построение статического вычислительного графа перед выполнением. В этом режиме операции определяют узлы графа, а тензоры — ребра. Преимущества графового режима включают возможность оптимизации графа перед выполнением, сериализации и развертывания модели без интерпретатора Python, а также лучшую производительность на устройствах типа TPU. До появления Eager Execution (режим немедленного выполнения) режим графа был основным способом работы с TensorFlow.

Преобразование между Tensor и ndarray в режиме графа требует особого подхода, поскольку NumPy операции выполняются вне контекста TensorFlow графа.

Основы преобразования TensorFlow Tensor в NumPy

Преобразование в режиме не-графа (Eager Execution)

В режиме Eager Execution, который является поведением TensorFlow по умолчанию с версии 2.0, преобразование между Tensor и ndarray происходит очень просто, поскольку операции выполняются немедленно.

Любой Tensor может быть преобразован в массив NumPy с помощью метода .numpy():

import tensorflow as tf
import numpy as np

# В режиме Eager Execution
tf.config.run_ старики_mode(True)

# Создаем TensorFlow Tensor
ten = tf.constant([[1.0, 2.0], [3.0, 4.0]])

# Преобразуем Tensor в NumPy array
np_array: np.ndarray = ten.numpy()

print(f"TensorFlow Tensor:\n{ten}")
print(f"Тип Tensor: {type(ten)}")
print(f"NumPy array:\n{np_array}")
print(f"Тип NumPy array: {type(np_array)}")

Аналогично, массив NumPy легко преобразуется в Tensor с помощью tf.constant() или tf.convert_to_tensor():

# Создаем NumPy array
np_data = np.array([[5.0, 6.0], [7.0, 8.0]], dtype=np.float32)

# Преобразуем NumPy array в TensorFlow Tensor
ten_from_np: tf.Tensor = tf.constant(np_data)

print(f"NumPy array:\n{np_data}")
print(f"Тип NumPy array: {type(np_data)}")
print(f"TensorFlow Tensor:\n{ten_from_np}")
print(f"Тип Tensor: {type(ten_from_np)}")

В Eager Execution эти преобразования выполняются мгновенно, так как нет концепции построения статического графа.

Ограничения и особенности преобразования в режиме графа

В отличие от Eager Execution, в режиме графа (который активно используется при использовании tf.function для построения оптимизированных графов) прямое использование .numpy() или tf.constant() с NumPy массивом внутри функции, декорированной @tf.function, имеет ограничения. tf.function трассирует функцию, создавая статический граф. Операции NumPy не являются частью TensorFlow графа и не могут быть непосредственно включены в него.

Если вы попытаетесь использовать .numpy() внутри tf.function, TensorFlow сгенерирует ошибку или предупреждение, указывая на то, что операция .numpy() возвращает значение, вычисленное во время трассировки, а не операцию, включенную в граф. Это означает, что результат будет статичным значением, полученным при первом вызове функции (трассировке), а не динамическим значением, вычисляемым при каждом последующем выполнении графа.

Пример, показывающий проблему внутри tf.function:

import tensorflow as tf
import numpy as np

# Включаем Graph Execution (для демонстрации)
tf.config.run_ старики_mode(False)

@tf.function
def simple_operation(x: tf.Tensor) -> tf.Tensor:
    # Эта часть выполняется во время трассировки
    # Результат .numpy() будет запечен в граф как константа
    # Это не будет динамически конвертироваться при каждом вызове
    try:
        x_np = x.numpy() # Проблема: .numpy() внутри tf.function
        # Здесь может возникнуть ошибка или предупреждение в зависимости от контекста и версии TF
        # Если ошибки нет, x_np будет значением x во время трассировки
        # Это не демонстрирует динамическое преобразование!
        # Пример бесполезен для динамики, но показывает синтаксис, который следует избегать для динамики

        # Вместо этого, нужно использовать специальные функции для интеграции NumPy
        # Этот код не будет работать как ожидается для динамического преобразования:
        # return tf.constant(x_np) + 1.0 # Вернет константу + 1

        # Корректный подход будет показан далее
        return x + 1.0 # Возвращаем что-то, что работает в графе
    except tf.errors.InaccessibleAttributeError as e:
        print(f"Ошибка: {e}")
        print("Нельзя вызвать .numpy() напрямую на tf.Tensor внутри tf.function")
        return x # Возвращаем исходный Tensor

# Этот вызов вызовет трассировку и, возможно, ошибку/предупреждение
tensor_input = tf.constant([10.0, 20.0], dtype=tf.float32)
output_tensor = simple_operation(tensor_input)

print(f"Выходной тензор: {output_tensor}")

# Возвращаемся в Eager mode для удобства дальнейших примеров
tf.config.run_ старики_mode(True)

Для выполнения NumPy операций внутри графа TensorFlow и динамического преобразования тензоров, требуются специальные функции-обертки, которые TensorFlow предоставляет именно для таких сценариев.

Методы преобразования TensorFlow Tensor в NumPy в режиме графа

Для выполнения произвольного кода на Python, включая операции NumPy, внутри графа TensorFlow, используются функции tf.numpy_function и tf.py_function. Эти функции позволяют передать тензоры TensorFlow в функцию Python, выполнить эту функцию (которая может использовать NumPy) и получить результат обратно в виде тензоров TensorFlow.

Использование tf.numpy_function

tf.numpy_function предназначен специально для случаев, когда выполняемая Python функция принимает NumPy массивы и возвращает NumPy массивы. TensorFlow автоматически преобразует входные тензоры в NumPy массивы перед вызовом Python функции и преобразует возвращенные NumPy массивы обратно в тензоры TensorFlow.

Сигнатура:
tf.numpy_function(func, inp, Tout, name=None)

• func: Python функция, которая принимает NumPy массивы в качестве аргументов и возвращает NumPy массивы.
• inp: Список или кортеж TensorFlow тензоров, которые будут переданы в func после преобразования в NumPy.
• Tout: Список или кортеж типов данных TensorFlow (tf.DType) для выходных тензоров. Это критически важно для tf.function, так как граф должен знать типы выходных данных.
• name: Необязательное имя для операции.

Пример использования tf.numpy_function для выполнения NumPy операции над тензором внутри tf.function:

import tensorflow as tf
import numpy as np

@tf.function
def apply_numpy_sqrt(tensor_input: tf.Tensor) -> tf.Tensor:
    """
    Применяет np.sqrt к входному тензору с использованием tf.numpy_function.

    Args:
        tensor_input: Входной TensorFlow Tensor.

    Returns:
        TensorFlow Tensor с примененной операцией np.sqrt.
    """
    # Определяем Python функцию, которая работает с NumPy
    def numpy_sqrt_func(numpy_array: np.ndarray) -> np.ndarray:
        """
        Python функция для вычисления квадратного корня NumPy.

        Args:
            numpy_array: Входной NumPy array.

        Returns:
            NumPy array с квадратными корнями.
        """
        return np.sqrt(numpy_array)

    # Используем tf.numpy_function для вызова numpy_sqrt_func в графе
    # inp=[tensor_input] - передаем входной тензор как список
    # Tout=[tensor_input.dtype] - указываем тип выходного тензора (совпадает с входным в данном случае)
    result_tensor: tf.Tensor = tf.numpy_function(
        func=numpy_sqrt_func,
        inp=[tensor_input],
        Tout=[tensor_input.dtype] # Обязательно указываем тип выходных данных!
    )

    # tf.numpy_function возвращает список тензоров, даже если выход один
    return result_tensor[0]

# Тестируем функцию в режиме графа
tf.config.run_ старики_mode(False) # Убедимся, что мы в режиме графа для демонстрации tf.function

input_data = tf.constant([[4.0, 9.0], [16.0, 25.0]], dtype=tf.float32)
output_data = apply_numpy_sqrt(input_data)

print(f"Входные данные (TensorFlow Tensor):\n{input_data}")
print(f"Результат после np.sqrt через tf.numpy_function (TensorFlow Tensor):\n{output_data}")

# Возвращаемся в Eager mode
tf.config.run_ старики_mode(True)

Использование tf.py_function

tf.py_function является более общей версией tf.numpy_function. Она предназначена для выполнения произвольного Python кода, который может принимать и возвращать списки тензоров TensorFlow. В отличие от tf.numpy_function, tf.py_function не выполняет автоматическое преобразование в NumPy и обратно. Вы должны управлять этим преобразованием вручную внутри вашей Python функции, если это необходимо.

Сигнатура:
tf.py_function(func, inp, Tout, name=None)

• func: Python функция, которая принимает список TensorFlow тензоров в качестве аргументов и возвращает список TensorFlow тензоров.
• inp: Список или кортеж TensorFlow тензоров, которые будут переданы в func.
• Tout: Список или кортеж типов данных TensorFlow (tf.DType) для выходных тензоров. Обязательно для tf.function.
• name: Необязательное имя для операции.

Пример использования tf.py_function. Здесь мы вручную преобразуем тензоры в NumPy внутри Python функции, выполняем операцию, а затем преобразуем результат обратно в тензор TensorFlow:

import tensorflow as tf
import numpy as np

@tf.function
def apply_numpy_mean_py_func(tensor_input: tf.Tensor) -> tf.Tensor:
    """
    Вычисляет среднее значение np.mean для входного тензора
    с использованием tf.py_function и ручным преобразованием.

    Args:
        tensor_input: Входной TensorFlow Tensor.

    Returns:
        TensorFlow Tensor с результатом np.mean.
    """
    # Определяем Python функцию, которая принимает и возвращает TensorFlow тензоры
    def numpy_mean_func_py(tensors: list[tf.Tensor]) -> list[tf.Tensor]:
        """
        Python функция для вычисления np.mean с ручным преобразованием.

        Args:
            tensors: Список входных TensorFlow тензоров ([input_tensor]).

        Returns:
            Список выходных TensorFlow тензоров ([mean_tensor]).
        """
        # Преобразуем входной тензор в NumPy array
        numpy_array: np.ndarray = tensors[0].numpy()

        # Выполняем операцию NumPy
        mean_value: np.float64 = np.mean(numpy_array)

        # Преобразуем результат обратно в TensorFlow Tensor
        result_tensor: tf.Tensor = tf.constant(mean_value, dtype=tf.float32) # Указываем нужный dtype

        # Возвращаем результат как список тензоров
        return [result_tensor]

    # Используем tf.py_function для вызова numpy_mean_func_py в графе
    # inp=[tensor_input] - передаем входной тензор как список
    # Tout=[tf.float32] - указываем тип выходного тензора (среднее значение)
    result_tensor_list: list[tf.Tensor] = tf.py_function(
        func=numpy_mean_func_py,
        inp=[tensor_input],
        Tout=[tf.float32] # Обязательно указываем тип выходных данных!
    )

    # tf.py_function возвращает список тензоров
    return result_tensor_list[0]

# Тестируем функцию в режиме графа
tf.config.run_ старики_mode(False)

input_data_mean = tf.constant([[1.0, 2.0], [3.0, 4.0]], dtype=tf.float32)
output_mean = apply_numpy_mean_py_func(input_data_mean)

print(f"Входные данные (TensorFlow Tensor):\n{input_data_mean}")
print(f"Результат после np.mean через tf.py_function (TensorFlow Tensor): {output_mean}")

# Возвращаемся в Eager mode
tf.config.run_ старики_mode(True)

Объяснение работы tf.numpy_function и tf.py_function

Важно понимать, что tf.numpy_function и tf.py_function по своей сути не интегрируют Python/NumPy код внутрь TensorFlow графа как нативные операции. Вместо этого, они добавляют в граф узел, который при выполнении графа останавливает выполнение графа на текущем устройстве (GPU/TPU), передает необходимые входные тензоры в окружение Python (обычно на CPU), выполняет указанную Python функцию, получает от нее результаты и затем передает их обратно в граф TensorFlow в виде новых тензоров для дальнейшего выполнения.

• Отсутствие градиентов: По умолчанию, TensorFlow не может автоматически вычислить градиенты для операций, выполняемых внутри tf.numpy_function или tf.py_function, потому что их внутреннее устройство неизвестно графу. Если вам нужны градиенты через такую функцию, вам придется регистрировать пользовательский градиент с помощью tf.custom_gradient.
• Сериализация: Графы с tf.numpy_function или tf.py_function могут быть сериализованы и загружены, но это требует, чтобы Python функция была доступна в среде, где граф загружается и выполняется. Это может усложнить развертывание на платформах, где нет полного окружения Python или установлены ограничения (например, мобильные или IoT устройства).
• Накладные расходы: Передача данных между устройствами (GPU/TPU и CPU) и переключение контекста выполнения влечет за собой определенные накладные расходы. Частое использование этих функций внутри критических по производительности частей графа может замедлить выполнение.

Практические примеры и сценарии

Преобразование TensorFlow Tensor в NumPy для постобработки данных

Распространенный сценарий — использование NumPy для анализа или визуализации результатов, полученных из модели TensorFlow, работающей в режиме графа (например, при инференсе с tf.saved_model или внутри tf.function).

Предположим, у вас есть выходной тензор из модели, и вам нужно выполнить над ним операцию, которая есть только в NumPy, например, применить маску или выполнить специфическую фильтрацию, а затем, возможно, вернуть результат обратно в граф.

import tensorflow as tf
import numpy as np

@tf.function
def process_with_numpy_mask(model_output: tf.Tensor, threshold: tf.Tensor) -> tf.Tensor:
    """
    Применяет NumPy маску к выходным данным модели с использованием tf.numpy_function.

    Args:
        model_output: Выходной тензор модели.
        threshold: Тензор порога для маски (один элемент).

    Returns:
        Тензор после применения маски.
    """
    def apply_mask_np(data_np: np.ndarray, threshold_np: np.ndarray) -> np.ndarray:
        """
        Python функция для применения NumPy маски.
        """
        # Применение маски: обнуляем элементы меньше порога
        masked_data = np.where(data_np > threshold_np, data_np, 0.0)
        return masked_data

    # Используем tf.numpy_function для выполнения apply_mask_np
    processed_output: tf.Tensor = tf.numpy_function(
        func=apply_mask_np,
        inp=[model_output, threshold], # Передаем оба тензора
        Tout=[model_output.dtype]     # Ожидаем тензор того же типа
    )[0]

    return processed_output

# Пример использования
tf.config.run_ старики_mode(False)

output_from_model = tf.constant([[0.1, 0.8, 0.3], [0.9, 0.2, 0.7]], dtype=tf.float32)
mask_threshold = tf.constant(0.5, dtype=tf.float32)

masked_result = process_with_numpy_mask(output_from_model, mask_threshold)

print(f"Выход модели:\n{output_from_model}")
print(f"Порог:\n{mask_threshold}")
print(f"Результат после маскирования через NumPy:\n{masked_result}")

tf.config.run_ старики_mode(True)

Использование NumPy для вычислений, не поддерживаемых TensorFlow в режиме графа

Иногда вам может потребоваться выполнить сложные численные расчеты или использовать функции из библиотек, построенных поверх NumPy (например, SciPy), которые не имеют прямых аналогов в TensorFlow графе.

Пример: вычисление перцентилей или использование функций из scipy.signal или scipy.ndimage.

import tensorflow as tf
import numpy as np
from scipy.stats import percentileofscore

@tf.function
def calculate_percentile_score(data_tensor: tf.Tensor, value_tensor: tf.Tensor) -> tf.Tensor:
    """
    Вычисляет перцентиль для заданного значения в данных с использованием SciPy через tf.py_function.

    Args:
        data_tensor: Тензор с данными (должен быть 1D или легко преобразуемым в 1D).
        value_tensor: Тензор с одним значением, для которого нужно вычислить перцентиль.

    Returns:
        Тензор с перцентилем (float).
    """
    def get_percentile_np(tensors: list[tf.Tensor]) -> list[tf.Tensor]:
        """
        Python функция для вычисления перцентиля с использованием SciPy.
        """
        data_np: np.ndarray = tensors[0].numpy().flatten() # Преобразуем в 1D NumPy array
        value_np: float = tensors[1].numpy().item()      # Получаем скалярное значение

        # Вычисляем перцентиль с помощью SciPy
        # per: float = percentileofscore(data_np, value_np)

        # Простая заглушка, имитирующая такую операцию, чтобы избежать зависимости от SciPy
        # В реальном коде здесь был бы вызов SciPy
        # per = float(np.sum(data_np <= value_np) / len(data_np)) * 100.0
        per = np.mean(data_np <= value_np) * 100.0

        # Возвращаем результат как список TensorFlow тензоров
        return [tf.constant(per, dtype=tf.float32)]

    # Используем tf.py_function
    percentile_tensor: tf.Tensor = tf.py_function(
        func=get_percentile_np,
        inp=[data_tensor, value_tensor],
        Tout=[tf.float32] # Ожидаем один тензор типа float32
    )[0]

    return percentile_tensor

# Пример использования
tf.config.run_ старики_mode(False)

input_data_percentile = tf.constant([10, 20, 30, 40, 50, 60, 70, 80, 90, 100], dtype=tf.float32)
percentile_value = tf.constant(75, dtype=tf.float32)

calculated_percentile = calculate_percentile_score(input_data_percentile, percentile_value)

print(f"Входные данные:\n{input_data_percentile}")
print(f"Значение для перцентиля: {percentile_value.numpy()}") # Используем .numpy() только вне tf.function
print(f"Вычисленный перцентиль (через tf.py_function): {calculated_percentile}")

tf.config.run_ старики_mode(True)

Интеграция NumPy операций в TensorFlow графы

Другой сценарий — использование NumPy для генерации данных или выполнения вспомогательных вычислений, которые должны быть частью конвейера обработки данных TensorFlow, определенного в tf.function. Например, создание сложных масок или предобработка входных данных, которая удобнее реализуется на NumPy.

import tensorflow as tf
import numpy as np

@tf.function
def generate_complex_mask(shape: tf.Tensor) -> tf.Tensor:
    """
    Генерирует сложную NumPy маску заданной формы с использованием tf.numpy_function.

    Args:
        shape: Тензор формы маски (например, [128, 128]).

    Returns:
        Тензор с сгенерированной маской (dtype=tf.bool).
    """
    def create_mask_np(shape_np: np.ndarray) -> np.ndarray:
        """
        Python функция для создания сложной NumPy маски.
        (Пример: круговая маска в центре изображения)
        """
        h, w = shape_np[0], shape_np[1]
        y, x = np.ogrid[:h, :w]
        center_x, center_y = w // 2, h // 2
        radius = min(center_x, center_y) * 0.8
        # Создаем круговую маску
        mask_np = (x - center_x)**2 + (y - center_y)**2 <= radius**2
        return mask_np.astype(np.bool_)

    # Используем tf.numpy_function для вызова create_mask_np
    mask_tensor: tf.Tensor = tf.numpy_function(
        func=create_mask_np,
        inp=[shape],       # Передаем тензор формы
        Tout=[tf.bool]     # Ожидаем тензор типа bool
    )[0]

    return mask_tensor

# Пример использования в графе (например, для обработки изображения)
@tf.function
def apply_generated_mask(image: tf.Tensor, mask_shape: tf.Tensor) -> tf.Tensor:
    """
    Применяет сгенерированную маску к изображению.
    """
    # Генерируем маску внутри графа
    mask = generate_complex_mask(mask_shape)

    # Убедимся, что форма маски соответствует форме изображения (без батча)
    # Это упрощенный пример, в реальном коде нужна проверка форм
    mask = tf.cast(mask, image.dtype) # Приводим маску к типу изображения

    # Применяем маску (поэлементное умножение)
    masked_image = image * mask

    return masked_image

# Тестирование
tf.config.run_ старики_mode(False)

# Создаем фейковое изображение (с батч-размером 1)
fake_image = tf.random.uniform(shape=[1, 128, 128, 3], dtype=tf.float32)
image_shape = tf.constant([128, 128], dtype=tf.int32)

processed_image = apply_generated_mask(fake_image, image_shape)

print(f"Форма исходного изображения: {fake_image.shape}")
print(f"Форма обработанного изображения: {processed_image.shape}")

# Чтобы увидеть результат маскирования, нужно получить тензор из графа
# Это можно сделать, выполнив функцию с конкретными входными данными
# (подразумевается, что функция уже трассирована)
# Или просто вывести результат в Eager mode
# masked_image_np = processed_image.numpy() # Работает в Eager mode

tf.config.run_ старики_mode(True)

Рекомендации и лучшие практики

Влияние преобразований на производительность в режиме графа

Как упоминалось ранее, использование tf.numpy_function и tf.py_function влечет за собой накладные расходы:

• Передача данных между CPU и ускорителем (GPU/TPU): Данные должны быть скопированы с устройства TensorFlow на CPU для выполнения Python кода и обратно.
• Переключение контекста выполнения: TensorFlow граф приостанавливает выполнение, передает управление Python интерпретатору, ждет завершения Python функции, а затем возобновляет выполнение графа.

Частое или последовательное использование таких функций внутри цикла обучения или инференса может значительно снизить общую производительность по сравнению с полностью нативными операциями TensorFlow. Особенно это заметно при работе с большими объемами данных или на высокопроизводительных ускорителях.

Оптимизация преобразований для повышения эффективности

Чтобы минимизировать накладные расходы, следуйте этим рекомендациям:

• Минимизируйте количество вызовов: Старайтесь группировать несколько NumPy операций в одну Python функцию, вызываемую через tf.numpy_function или tf.py_function, вместо многократных вызовов для каждой отдельной операции.
• Минимизируйте объем передаваемых данных: Передавайте только те данные, которые абсолютно необходимы Python функции. Обрабатывайте большие объемы данных на стороне TensorFlow, если это возможно.
• Используйте tf.numpy_function для операций с NumPy: Если ваша функция исключительно принимает и возвращает NumPy массивы, используйте tf.numpy_function. TensorFlow может применить некоторые оптимизации, специфичные для NumPy. Используйте tf.py_function только когда вам нужна более общая функциональность Python или работаете непосредственно с тензорами TensorFlow внутри Python функции.
• Тщательно указывайте Tout: Правильное указание типов данных в Tout помогает TensorFlow эффективно управлять памятью и типами данных.
• Избегайте в критическом пути: По возможности, используйте эти функции для предобработки данных (вне цикла обучения) или для постобработки результатов, а не внутри горячего цикла модели (например, в слоях нейронной сети).

Альтернативные подходы и решения

Прежде чем прибегать к преобразованию через tf.numpy_function или tf.py_function, рассмотрите альтернативы:

• Проверьте наличие нативной операции в TensorFlow: Возможно, нужная вам операция уже реализована в TensorFlow или может быть эффективно эмулирована комбинацией существующих операций.
• Используйте TensorFlow Probability, TensorFlow I/O и другие расширения: Эти библиотеки предоставляют специализированные операции, которые могут быть реализованы нативно в TensorFlow и покрыть некоторые сценарии, ранее требующие NumPy/SciPy.
• Переформулируйте задачу: Иногда задача может быть решена другим способом, который лучше подходит для парадигмы графа TensorFlow.
• Кастомные TensorFlow операции: Для высокопроизводительных и часто используемых операций, не имеющих аналогов в TensorFlow, можно написать собственную кастомную операцию на C++ с привязками к Python. Это наиболее сложный, но и наиболее производительный подход для добавления новой функциональности в граф.

Выбор между использованием tf.numpy_function/tf.py_function и поиском нативных решений в TensorFlow — это компромисс между удобством разработки и производительностью. Для прототипирования или редких операций tf.numpy_function/tf.py_function — отличное решение. Для производительных пайплайнов в продакшене стоит искать более нативные способы реализации.