TensorFlow I/O

TensorFlow torna al Google I/O il 14 maggio! Iscriviti ora

Questa pagina è stata tradotta dall'API Cloud Translation.

Sviluppo

Il documento contiene le informazioni necessarie per impostare l'ambiente di sviluppo e costruire il pacchetto tensorflow-io dai sorgenti su varie piattaforme. Una volta completata la configurazione, fare riferimento alla STYLE_GUIDE per le linee guida sull'aggiunta di nuove operazioni.

Configurazione dell'IDE

Per istruzioni su come configurare Visual Studio Code per lo sviluppo di TensorFlow I/O, fare riferimento a questo documento .

Lanugine

Il codice di TensorFlow I/O è conforme a Bazel Buildifier, Clang Format, Black e Pyupgrade. Utilizzare il seguente comando per controllare il codice sorgente e identificare i problemi di lanugine:

# 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

Per Bazel Buildifier e Clang Format, il seguente comando identificherà e risolverà automaticamente eventuali errori di lanugine:

$ bazel run //tools/lint:lint

In alternativa, se desideri eseguire solo il controllo dei lint utilizzando singoli linter, puoi passare selettivamente black , pyupgrade , bazel o clang ai comandi precedenti.

Ad esempio, è possibile eseguire un controllo della lanugine specifico black utilizzando:

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

La correzione della lanugine utilizzando Bazel Buildifier e Clang Format può essere eseguita utilizzando:

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

Il controllo dei lanugine utilizzando black e pyupgrade per un singolo file Python può essere eseguito utilizzando:

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

Lint corregge un singolo file Python con black e pyupgrade utilizzando:

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

Pitone

Mac OS

Su macOS Catalina 10.15.7, è possibile creare tensorflow-io con Python 3.8.2 fornito dal sistema. Per farlo sono necessari sia tensorflow che bazel .

#!/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

Risoluzione dei problemi

Se Xcode è installato, ma $ xcodebuild -version non visualizza l'output previsto, potrebbe essere necessario abilitare la riga di comando di Xcode con il comando:

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

Potrebbe essere necessario il riavvio del terminale affinché le modifiche abbiano effetto.

Output di esempio:

$ xcodebuild -version
Xcode 12.2
Build version 12B45b

Linux

Lo sviluppo di tensorflow-io su Linux è simile a macOS. I pacchetti richiesti sono gcc, g++, git, bazel e python 3. Potrebbero tuttavia essere necessarie versioni più recenti di gcc o python, diverse dalle versioni installate di default nel sistema.

Ubuntu 20.04

Ubuntu 20.04 richiede gcc/g++, git e python 3. Quanto segue installerà le dipendenze e creerà le librerie condivise su 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

CentOS8

I passaggi per creare librerie condivise per CentOS 8 sono simili a quelli di Ubuntu 20.04 sopra, tranne questo

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

dovrebbe essere usato invece per installare gcc/g++, git, unzip/ which (per bazel) e python3.

CentOS7

Su CentOS 7, le versioni predefinite di Python e gcc sono troppo vecchie per creare le librerie condivise di tensorflow-io (.so). Dovrebbe essere invece utilizzato il gcc fornito da Developer Toolset e rh-python36. Inoltre, libstdc++ deve essere collegato staticamente per evitare discrepanze tra libstdc++ installato su CentOS e la versione più recente di gcc da devtoolset.

Inoltre, un flag speciale --//tensorflow_io/core:static_build deve essere passato a Bazel per evitare la duplicazione dei simboli nelle librerie collegate staticamente per i plugin del file system.

Quanto segue installerà bazel, devtoolset-9, rh-python36 e creerà le librerie condivise:

#!/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

Per lo sviluppo Python, un Dockerfile di riferimento qui può essere utilizzato per creare il pacchetto I/O TensorFlow ( tensorflow-io ) dal sorgente. Inoltre, è possibile utilizzare anche le immagini di sviluppo predefinite:

# 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 file di pacchetto dist/tensorflow_io-*.whl verrà generato al termine della compilazione.

Ruote in pitone

È possibile costruire ruote Python dopo aver completato la costruzione di Bazel con il seguente comando:

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

Il file .whl sarà disponibile nella directory dist. Tieni presente che la directory binaria di bazel bazel-bin deve essere passata con --data args affinché setup.py possa individuare gli oggetti di condivisione necessari, poiché bazel-bin è esterno alla directory del pacchetto tensorflow_io .

In alternativa, l'installazione del codice sorgente può essere eseguita con:

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

con TFIO_DATAPATH=bazel-bin passato per lo stesso motivo.

Nota che l'installazione con -e è diversa da quella sopra. IL

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

non installerà automaticamente l'oggetto condiviso anche con TFIO_DATAPATH=bazel-bin . Invece, TFIO_DATAPATH=bazel-bin deve essere passato ogni volta che il programma viene eseguito dopo l'installazione:

$ TFIO_DATAPATH=bazel-bin python

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

Test

Alcuni test richiedono l'avvio di un contenitore di test o l'avvio di un'istanza locale dello strumento associato prima dell'esecuzione. Ad esempio, per eseguire test relativi a Kafka che avvieranno un'istanza locale di kafka, zookeeper e schema-registry, utilizzare:

# 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

Il test Datasets associati a strumenti come Elasticsearch o MongoDB richiede che la finestra mobile sia disponibile nel sistema. In tali scenari, utilizzare:

# 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

Inoltre, testare alcune funzionalità di tensorflow-io non richiede l'attivazione di strumenti aggiuntivi poiché i dati sono stati forniti nella directory tests stessa. Ad esempio, per eseguire test relativi ai set di dati parquet , utilizzare:

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

R

Forniamo qui un Dockerfile di riferimento in modo che tu possa utilizzare direttamente il pacchetto R per i test. Puoi costruirlo tramite:

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

All'interno del contenitore, puoi avviare la sessione R, creare un'istanza di un SequenceFileDataset da un esempio Hadoop SequenceFile string.seq e quindi utilizzare qualsiasi funzione di trasformazione fornita dal pacchetto tfdatasets sul set di dati come la seguente:

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)
})