TensorFlow I/O

TensorFlow est de retour sur Google I/O le 14 mai ! S'inscrire maintenant

Cette page a été traduite par l'API Cloud Translation.

Développement

Le document contient les informations nécessaires à la configuration de l'environnement de développement et à la création du package tensorflow-io à partir des sources sur diverses plates-formes. Une fois la configuration terminée, veuillez vous référer au STYLE_GUIDE pour obtenir des directives sur l'ajout de nouvelles opérations.

Configuration de l'EDI

Pour obtenir des instructions sur la configuration de Visual Studio Code pour le développement d'E/S TensorFlow, veuillez vous référer à ce document .

Peluche

Le code de TensorFlow I/O est conforme à Bazel Buildifier, Clang Format, Black et Pyupgrade. Veuillez utiliser la commande suivante pour vérifier le code source et identifier les problèmes de peluches :

# Install Bazel version specified in .bazelversion
$ curl -OL https://github.com/bazelbuild/bazel/releases/download/$(cat .bazelversion)/bazel-$(cat .bazelversion)-installer-darwin-x86_64.sh
$ sudo bash -x -e bazel-$(cat .bazelversion)-installer-darwin-x86_64.sh
$ bazel run //tools/lint:check

Pour Bazel Buildifier et Clang Format, la commande suivante identifiera et corrigera automatiquement toutes les erreurs de charpie :

$ bazel run //tools/lint:lint

Alternativement, si vous souhaitez uniquement effectuer une vérification des charpies à l'aide de linters individuels, vous pouvez transmettre sélectivement black , pyupgrade , bazel ou clang aux commandes ci-dessus.

Par exemple, une vérification des peluches spécifiques black peut être effectuée en utilisant :

$ bazel run //tools/lint:check -- black

La correction des peluches à l'aide de Bazel Buildifier et de Clang Format peut être effectuée en utilisant :

$ bazel run //tools/lint:lint -- bazel clang

La vérification des peluches à l'aide de black et pyupgrade pour un fichier python individuel peut être effectuée en utilisant :

$ bazel run //tools/lint:check -- black pyupgrade -- tensorflow_io/python/ops/version_ops.py

Lint corrige un fichier Python individuel avec black et pyupgrade en utilisant :

$ bazel run //tools/lint:lint -- black pyupgrade --  tensorflow_io/python/ops/version_ops.py

Python

macOS

Sur macOS Catalina 10.15.7, il est possible de créer tensorflow-io avec le système fourni python 3.8.2. tensorflow et bazel sont nécessaires pour ce faire.

#!/usr/bin/env bash

# Disable arm64 build by specifying only x86_64 arch.
# Only needed for macOS's system default python 3.8.2 on macOS 10.15.7
export ARCHFLAGS="-arch x86_64"

# Use following command to check if Xcode is correctly installed:
xcodebuild -version

# Show macOS's default python3
python3 --version

# Install Bazel version specified in .bazelversion
curl -OL https://github.com/bazelbuild/bazel/releases/download/$(cat .bazelversion)/bazel-$(cat .bazelversion)-installer-darwin-x86_64.sh
sudo bash -x -e bazel-$(cat .bazelversion)-installer-darwin-x86_64.sh

# Install tensorflow and configure bazel
sudo ./configure.sh

# Add any optimization on bazel command, e.g., --compilation_mode=opt,
#   --copt=-msse4.2, --remote_cache=, etc.
# export BAZEL_OPTIMIZATION=

# Build shared libraries
bazel build -s --verbose_failures $BAZEL_OPTIMIZATION //tensorflow_io/... //tensorflow_io_gcs_filesystem/...

# Once build is complete, shared libraries will be available in
# `bazel-bin/tensorflow_io/core`, `bazel-bin/tensorflow_io/python/ops` and
# it is possible to run tests with `pytest`, e.g.:
sudo python3 -m pip install pytest
TFIO_DATAPATH=bazel-bin python3 -m pytest -s -v tests/test_serialization.py

Dépanner

Si Xcode est installé, mais que $ xcodebuild -version n'affiche pas le résultat attendu, vous devrez peut-être activer la ligne de commande Xcode avec la commande :

$ xcode-select -s /Applications/Xcode.app/Contents/Developer .

Un redémarrage du terminal peut être nécessaire pour que les modifications prennent effet.

Exemple de sortie :

$ xcodebuild -version
Xcode 12.2
Build version 12B45b

Linux

Le développement de tensorflow-io sous Linux est similaire à celui de macOS. Les packages requis sont gcc, g++, git, bazel et python 3. Des versions plus récentes de gcc ou python, autres que les versions installées par défaut sur le système, peuvent cependant être requises.

Ubuntu 20.04

Ubuntu 20.04 nécessite gcc/g++, git et python 3. Ce qui suit installera les dépendances et créera les bibliothèques partagées sur Ubuntu 20.04 :

#!/usr/bin/env bash

# Install gcc/g++, git, unzip/curl (for bazel), and python3
sudo apt-get -y -qq update
sudo apt-get -y -qq install gcc g++ git unzip curl python3-pip

# Install Bazel version specified in .bazelversion
curl -sSOL <a href="https://github.com/bazelbuild/bazel/releases/download/">https://github.com/bazelbuild/bazel/releases/download/</a>\\((cat .bazelversion)/bazel-\\)(cat .bazelversion)-installer-linux-x86_64.sh
sudo bash -x -e bazel-$(cat .bazelversion)-installer-linux-x86_64.sh

# Upgrade pip
sudo python3 -m pip install -U pip

# Install tensorflow and configure bazel
sudo ./configure.sh

# Alias python3 to python, needed by bazel
sudo ln -s /usr/bin/python3 /usr/bin/python

# Add any optimization on bazel command, e.g., --compilation_mode=opt,
#   --copt=-msse4.2, --remote_cache=, etc.
# export BAZEL_OPTIMIZATION=

# Build shared libraries
bazel build -s --verbose_failures $BAZEL_OPTIMIZATION //tensorflow_io/... //tensorflow_io_gcs_filesystem/...

# Once build is complete, shared libraries will be available in
# `bazel-bin/tensorflow_io/core`, `bazel-bin/tensorflow_io/python/ops` and
# it is possible to run tests with `pytest`, e.g.:
sudo python3 -m pip install pytest
TFIO_DATAPATH=bazel-bin python3 -m pytest -s -v tests/test_serialization.py

CentOS 8

Les étapes pour créer des bibliothèques partagées pour CentOS 8 sont similaires à celles d'Ubuntu 20.04 ci-dessus, sauf que

sudo yum install -y python3 python3-devel gcc gcc-c++ git unzip which make

doit être utilisé à la place pour installer gcc/g++, git, unzip/which (pour bazel) et python3.

CentOS7

Sur CentOS 7, les versions par défaut de python et gcc sont trop anciennes pour créer les bibliothèques partagées de tensorflow-io (.so). Le gcc fourni par Developer Toolset et rh-python36 doit être utilisé à la place. De plus, libstdc++ doit être lié statiquement pour éviter toute divergence entre libstdc++ installé sur CentOS et la version plus récente de gcc par devtoolset.

De plus, un indicateur spécial --//tensorflow_io/core:static_build doit être transmis à Bazel afin d'éviter la duplication de symboles dans les bibliothèques liées statiquement pour les plugins du système de fichiers.

Ce qui suit installera bazel, devtoolset-9, rh-python36 et créera les bibliothèques partagées :

#!/usr/bin/env bash

# Install centos-release-scl, then install gcc/g++ (devtoolset), git, and python 3
sudo yum install -y centos-release-scl
sudo yum install -y devtoolset-9 git rh-python36 make

# Install Bazel version specified in .bazelversion
curl -sSOL <a href="https://github.com/bazelbuild/bazel/releases/download/">https://github.com/bazelbuild/bazel/releases/download/</a>\\((cat .bazelversion)/bazel-\\)(cat .bazelversion)-installer-linux-x86_64.sh
sudo bash -x -e bazel-$(cat .bazelversion)-installer-linux-x86_64.sh

# Upgrade pip
scl enable rh-python36 devtoolset-9 \
    'python3 -m pip install -U pip'

# Install tensorflow and configure bazel with rh-python36
scl enable rh-python36 devtoolset-9 \
    './configure.sh'

# Add any optimization on bazel command, e.g., --compilation_mode=opt,
#   --copt=-msse4.2, --remote_cache=, etc.
# export BAZEL_OPTIMIZATION=

# Build shared libraries, notice the passing of --//tensorflow_io/core:static_build
BAZEL_LINKOPTS="-static-libstdc++ -static-libgcc" BAZEL_LINKLIBS="-lm -l%:libstdc++.a" \
  scl enable rh-python36 devtoolset-9 \
    'bazel build -s --verbose_failures $BAZEL_OPTIMIZATION --//tensorflow_io/core:static_build //tensorflow_io/...'

# Once build is complete, shared libraries will be available in
# `bazel-bin/tensorflow_io/core`, `bazel-bin/tensorflow_io/python/ops` and
# it is possible to run tests with `pytest`, e.g.:
scl enable rh-python36 devtoolset-9 \
    'python3 -m pip install pytest'

TFIO_DATAPATH=bazel-bin \
  scl enable rh-python36 devtoolset-9 \
    'python3 -m pytest -s -v tests/test_serialization.py'

Docker

Pour le développement Python, un Dockerfile de référence ici peut être utilisé pour créer le package d'E/S TensorFlow ( tensorflow-io ) à partir des sources. De plus, les images de développement prédéfinies peuvent également être utilisées :

# Pull (if necessary) and start the devel container
\\( docker run -it --rm --name tfio-dev --net=host -v \\){PWD}:/v -w /v tfsigio/tfio:latest-devel bash

# Inside the docker container, ./configure.sh will install TensorFlow or use existing install
(tfio-dev) root@docker-desktop:/v$ ./configure.sh

# Clean up exisiting bazel build's (if any)
(tfio-dev) root@docker-desktop:/v$ rm -rf bazel-*

# Build TensorFlow I/O C++. For compilation optimization flags, the default (-march=native)
# optimizes the generated code for your machine's CPU type.
# Reference: <a href="https://www.tensorflow.orginstall/source#configuration_options">https://www.tensorflow.orginstall/source#configuration_options</a>).

# NOTE: Based on the available resources, please change the number of job workers to:
# -j 4/8/16 to prevent bazel server terminations and resource oriented build errors.

(tfio-dev) root@docker-desktop:/v$ bazel build -j 8 --copt=-msse4.2 --copt=-mavx --compilation_mode=opt --verbose_failures --test_output=errors --crosstool_top=//third_party/toolchains/gcc7_manylinux2010:toolchain //tensorflow_io/... //tensorflow_io_gcs_filesystem/...


# Run tests with PyTest, note: some tests require launching additional containers to run (see below)
(tfio-dev) root@docker-desktop:/v$ pytest -s -v tests/
# Build the TensorFlow I/O package
(tfio-dev) root@docker-desktop:/v$ python setup.py bdist_wheel

Un fichier de package dist/tensorflow_io-*.whl sera généré une fois la construction réussie.

Roues Python

Il est possible de créer des roues Python une fois la construction de Bazel terminée avec la commande suivante :

$ python setup.py bdist_wheel --data bazel-bin

Le fichier .whl sera disponible dans le répertoire dist. Notez que le répertoire binaire bazel-bin doit être transmis avec --data args pour que setup.py localise les objets de partage nécessaires, car bazel-bin se trouve en dehors du répertoire du package tensorflow_io .

Alternativement, l'installation des sources peut être effectuée avec :

$ TFIO_DATAPATH=bazel-bin python -m pip install .

avec TFIO_DATAPATH=bazel-bin transmis pour la même raison.

Notez que l'installation avec -e est différente de ce qui précède. Le

$ TFIO_DATAPATH=bazel-bin python -m pip install -e .

n'installera pas automatiquement l'objet partagé même avec TFIO_DATAPATH=bazel-bin . Au lieu de cela, TFIO_DATAPATH=bazel-bin doit être transmis à chaque fois que le programme est exécuté après l'installation :

$ TFIO_DATAPATH=bazel-bin python

>>> import tensorflow_io as tfio
>>> ...

Essai

Certains tests nécessitent le lancement d'un conteneur de tests ou le démarrage d'une instance locale de l'outil associé avant de s'exécuter. Par exemple, pour exécuter des tests liés à Kafka qui démarreront une instance locale de Kafka, Zookeeper et Schema-Registry, utilisez :

# Start the local instances of kafka, zookeeper and schema-registry
$ bash -x -e tests/test_kafka/kafka_test.sh

# Run the tests
$ TFIO_DATAPATH=bazel-bin pytest -s -vv tests/test_kafka.py

Datasets de test associés à des outils tels que Elasticsearch ou MongoDB nécessitent que Docker soit disponible sur le système. Dans de tels scénarios, utilisez :

# Start elasticsearch within docker container
$ bash tests/test_elasticsearch/elasticsearch_test.sh start

# Run the tests
$ TFIO_DATAPATH=bazel-bin pytest -s -vv tests/test_elasticsearch.py

# Stop and remove the container
$ bash tests/test_elasticsearch/elasticsearch_test.sh stop

De plus, tester certaines fonctionnalités de tensorflow-io ne nécessite pas de lancer d'outils supplémentaires car les données ont été fournies dans le répertoire tests lui-même. Par exemple, pour exécuter des tests liés aux ensembles de données parquet , utilisez :

# Just run the test
$ TFIO_DATAPATH=bazel-bin pytest -s -vv tests/test_parquet.py

R.

Nous fournissons ici un Dockerfile de référence afin que vous puissiez utiliser le package R directement pour les tests. Vous pouvez le construire via :

$ docker build -t tfio-r-dev -f R-package/scripts/Dockerfile .

À l'intérieur du conteneur, vous pouvez démarrer votre session R, instancier un SequenceFileDataset à partir d'un exemple Hadoop SequenceFile string.seq , puis utiliser toutes les fonctions de transformation fournies par le package tfdatasets sur l'ensemble de données comme suit :

library(tfio)
dataset <- sequence_file_dataset("R-package/tests/testthat/testdata/string.seq") %>%
    dataset_repeat(2)

sess <- tf$Session()
iterator <- make_iterator_one_shot(dataset)
next_batch <- iterator_get_next(iterator)

until_out_of_range({
  batch <- sess$run(next_batch)
  print(batch)
})