調査ツール

TensorFlow.org で見る Google Colabで実行 GitHub でソースを表示ノートをダウンロード

TensorFlow Quantum は、量子プリミティブを TensorFlow エコシステムにもたらします。現在、量子研究者は TensorFlow のツールを活用できます。このチュートリアルでは、量子コンピューティングの研究にTensorBoardを組み込む方法を詳しく見ていきます。 TensorFlow の DCGAN チュートリアルを使用すると、 Niu らによって行われたものと同様の実用的な実験と視覚化をすばやく構築できます .大まかに言うと、次のことを行います。

  1. 量子回路から来たように見えるサンプルを生成するように GAN をトレーニングします。
  2. トレーニングの進行状況と分布の進化を経時的に視覚化します。
  3. 計算グラフを調べて実験をベンチマークします。
pip install tensorflow==2.4.1 tensorflow-quantum tensorboard_plugin_profile==2.4.0
%load_ext tensorboard
import datetime
import time
import cirq
import tensorflow as tf
import tensorflow_quantum as tfq
from tensorflow.keras import layers

# visualization tools
%matplotlib inline
import matplotlib.pyplot as plt
from cirq.contrib.svg import SVGCircuit

1. データ生成

いくつかのデータを収集することから始めます。 TensorFlow Quantum を使用して、残りの実験の主要なデータソースとなるいくつかのビット文字列サンプルをすばやく生成できます。 Niu らのように。深さを大幅に減らしたランダム回路からのサンプリングをエミュレートすることがいかに簡単かを探ります。まず、いくつかのヘルパーを定義します。

def generate_circuit(qubits):
    """Generate a random circuit on qubits."""
    random_circuit = cirq.generate_boixo_2018_supremacy_circuits_v2(
        qubits, cz_depth=2, seed=1234)
    return random_circuit

def generate_data(circuit, n_samples):
    """Draw n_samples samples from circuit into a tf.Tensor."""
    return tf.squeeze(tfq.layers.Sample()(circuit, repetitions=n_samples).to_tensor())

これで、回路といくつかのサンプル データを検査できます。

qubits = cirq.GridQubit.rect(1, 5)
random_circuit_m = generate_circuit(qubits) + cirq.measure_each(*qubits)
SVGCircuit(random_circuit_m)
findfont: Font family ['Arial'] not found. Falling back to DejaVu Sans.

svg

samples = cirq.sample(random_circuit_m, repetitions=10)
print('10 Random bitstrings from this circuit:')
print(samples)
10 Random bitstrings from this circuit:
(0, 0)=1000110110
(0, 1)=1110011001
(0, 2)=1000111011
(0, 3)=0001000000
(0, 4)=0100000000

TensorFlow Quantum でも同じことができます:

generate_data(random_circuit_m, 10)
<tf.Tensor: shape=(10, 5), dtype=int8, numpy=
array([[0, 0, 1, 0, 0],
       [0, 0, 1, 0, 0],
       [0, 1, 0, 0, 0],
       [0, 1, 0, 0, 0],
       [0, 1, 0, 0, 1],
       [1, 0, 0, 0, 0],
       [1, 0, 1, 0, 0],
       [1, 0, 1, 0, 1],
       [1, 1, 0, 0, 0],
       [1, 1, 0, 0, 0]], dtype=int8)>

これで、次の方法でトレーニング データをすばやく生成できます。

N_SAMPLES = 60000
N_QUBITS = 10
QUBITS = cirq.GridQubit.rect(1, N_QUBITS)
REFERENCE_CIRCUIT = generate_circuit(QUBITS)
all_data = generate_data(REFERENCE_CIRCUIT, N_SAMPLES)
all_data
<tf.Tensor: shape=(60000, 10), dtype=int8, numpy=
array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [1, 1, 1, ..., 1, 1, 1],
       [1, 1, 1, ..., 1, 1, 1],
       [1, 1, 1, ..., 1, 1, 1]], dtype=int8)>

トレーニングが進行しているときに視覚化するいくつかのヘルパー関数を定義すると便利です。使用する 2 つの興味深い量は次のとおりです。

  1. サンプルの整数値。分布のヒストグラムを作成できます。
  2. サンプル セットの線形 XEB忠実度の推定値。サンプルがいかに「本当に量子ランダム」であるかを示す指標です。
@tf.function
def bits_to_ints(bits):
    """Convert tensor of bitstrings to tensor of ints."""
    sigs = tf.constant([1 << i for i in range(N_QUBITS)], dtype=tf.int32)
    rounded_bits = tf.clip_by_value(tf.math.round(
        tf.cast(bits, dtype=tf.dtypes.float32)), clip_value_min=0, clip_value_max=1)
    return tf.einsum('jk,k->j', tf.cast(rounded_bits, dtype=tf.dtypes.int32), sigs)

@tf.function
def xeb_fid(bits):
    """Compute linear XEB fidelity of bitstrings."""
    final_probs = tf.squeeze(
        tf.abs(tfq.layers.State()(REFERENCE_CIRCUIT).to_tensor()) ** 2)
    nums = bits_to_ints(bits)
    return (2 ** N_QUBITS) * tf.reduce_mean(tf.gather(final_probs, nums)) - 1.0

ここでは、XEB を使用して配布と健全性チェックを視覚化できます。

plt.hist(bits_to_ints(all_data).numpy(), 50)
plt.show()

png

xeb_fid(all_data)
<tf.Tensor: shape=(), dtype=float32, numpy=0.014540911>

2. モデルを構築する

ここでは、量子の場合のDCGAN チュートリアルの関連コンポーネントを使用できます。 MNIST 数字を生成する代わりに、新しい GAN を使用して、長さN_QUBITSビット文字N_QUBITSサンプルを生成します。

LATENT_DIM = 100
def make_generator_model():
    """Construct generator model."""
    model = tf.keras.Sequential()
    model.add(layers.Dense(256, use_bias=False, input_shape=(LATENT_DIM,)))
    model.add(layers.Dense(128, activation='relu'))
    model.add(layers.Dropout(0.3))
    model.add(layers.Dense(64, activation='relu'))
    model.add(layers.Dense(N_QUBITS, activation='relu'))

    return model

def make_discriminator_model():
    """Constrcut discriminator model."""
    model = tf.keras.Sequential()
    model.add(layers.Dense(256, use_bias=False, input_shape=(N_QUBITS,)))
    model.add(layers.Dense(128, activation='relu'))
    model.add(layers.Dropout(0.3))
    model.add(layers.Dense(32, activation='relu'))
    model.add(layers.Dense(1))

    return model

次に、ジェネレーター モデルとtrain_stepモデルをインスタンス化し、損失を定義して、メインのトレーニング ループに使用するtrain_step関数を作成します。

discriminator = make_discriminator_model()
generator = make_generator_model()
cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)
def discriminator_loss(real_output, fake_output):
    """Compute discriminator loss."""
    real_loss = cross_entropy(tf.ones_like(real_output), real_output)
    fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
    total_loss = real_loss + fake_loss
    return total_loss

def generator_loss(fake_output):
    """Compute generator loss."""
    return cross_entropy(tf.ones_like(fake_output), fake_output)

generator_optimizer = tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)
BATCH_SIZE=256

@tf.function
def train_step(images):
    """Run train step on provided image batch."""
    noise = tf.random.normal([BATCH_SIZE, LATENT_DIM])
    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
        generated_images = generator(noise, training=True)

        real_output = discriminator(images, training=True)
        fake_output = discriminator(generated_images, training=True)

        gen_loss = generator_loss(fake_output)
        disc_loss = discriminator_loss(real_output, fake_output)

    gradients_of_generator = gen_tape.gradient(
        gen_loss, generator.trainable_variables)
    gradients_of_discriminator = disc_tape.gradient(
        disc_loss, discriminator.trainable_variables)

    generator_optimizer.apply_gradients(
        zip(gradients_of_generator, generator.trainable_variables))
    discriminator_optimizer.apply_gradients(
        zip(gradients_of_discriminator, discriminator.trainable_variables))

    return gen_loss, disc_loss

モデルに必要なすべての構成要素が揃ったので、TensorBoard 視覚化を組み込んだトレーニング関数をセットアップできます。最初に TensorBoard ファイルライターをセットアップします。

logdir = "tb_logs/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(logdir + "/metrics")
file_writer.set_as_default()

tf.summaryモジュールを使用すると、メインのtrain関数内に、 scalarhistogram (およびその他) のロギングを TensorBoard に組み込むことができます。

def train(dataset, epochs, start_epoch=1):
    """Launch full training run for the given number of epochs."""
    # Log original training distribution.
    tf.summary.histogram('Training Distribution', data=bits_to_ints(dataset), step=0)

    batched_data = tf.data.Dataset.from_tensor_slices(dataset).shuffle(N_SAMPLES).batch(512)
    t = time.time()
    for epoch in range(start_epoch, start_epoch + epochs):
        for i, image_batch in enumerate(batched_data):
            # Log batch-wise loss.
            gl, dl = train_step(image_batch)
            tf.summary.scalar(
                'Generator loss', data=gl, step=epoch * len(batched_data) + i)
            tf.summary.scalar(
                'Discriminator loss', data=dl, step=epoch * len(batched_data) + i)

        # Log full dataset XEB Fidelity and generated distribution.
        generated_samples = generator(tf.random.normal([N_SAMPLES, 100]))
        tf.summary.scalar(
        'Generator XEB Fidelity Estimate', data=xeb_fid(generated_samples), step=epoch)
        tf.summary.histogram(
        'Generator distribution', data=bits_to_ints(generated_samples), step=epoch)
        # Log new samples drawn from this particular random circuit.
        random_new_distribution = generate_data(REFERENCE_CIRCUIT, N_SAMPLES)
        tf.summary.histogram(
        'New round of True samples', data=bits_to_ints(random_new_distribution), step=epoch)

        if epoch % 10 == 0:
            print('Epoch {}, took {}(s)'.format(epoch, time.time() - t))
            t = time.time()

3. トレーニングとパフォーマンスの視覚化

TensorBoard ダッシュボードは、次のコマンドで起動できるようになりました。

%tensorboard --logdir tb_logs/

train呼び出すと、TensoBoard ダッシュボードは、トレーニング ループで指定されたすべての要約統計で自動更新されます。

train(all_data, epochs=50)
Epoch 10, took 7.8367908000946045(s)
Epoch 20, took 6.453724145889282(s)
Epoch 30, took 6.470423936843872(s)
Epoch 40, took 6.507797002792358(s)
Epoch 50, took 6.529016017913818(s)

トレーニングの実行中 (およびトレーニングが完了すると)、スカラー量を調べることができます。

ヒストグラム タブに切り替えると、生成ネットワークが量子分布からサンプルを再作成する際にどの程度うまく機能するかを確認することもできます。

TensorBoard は、実験に関連する要約統計のリアルタイム監視を可能にすることに加えて、実験のプロファイルを作成してパフォーマンスのボトルネックを特定するのにも役立ちます。パフォーマンス モニタリングを使用してモデルを再実行するには、次のことができます。

tf.profiler.experimental.start(logdir)
train(all_data, epochs=10, start_epoch=50)
tf.profiler.experimental.stop()
Epoch 50, took 0.7546782493591309(s)

TensorBoard はtf.profiler.experimental.starttf.profiler.experimental.stop間のすべてのコードをtf.profiler.experimental.starttf.profiler.experimental.stop 。このプロファイル データは、TensorBoard のprofileページで表示できます。

深さを増やすか、さまざまなクラスの量子回路を試してみてください。 TensorFlow Quantum の実験に組み込むことができるハイパーパラメータ調整など、 TensorBoard の他のすべての優れた機能をチェックしてください。