이 페이지는 Cloud Translation API를 통해 번역되었습니다.

연구 도구

TensorFlow.org에서 보기

Google Colab에서 실행

GitHub에서 소스 보기

노트북 다운로드

TensorFlow Quantum은 양자 프리미티브를 TensorFlow 생태계로 가져옵니다. 이제 양자 연구자는 TensorFlow의 도구를 활용할 수 있습니다. 이 자습서에서는 TensorBoard 를 양자 컴퓨팅 연구에 통합하는 방법을 자세히 살펴봅니다. TensorFlow의 DCGAN 튜토리얼 을 사용하면 Niu 등이 수행한 것과 유사한 작업 실험 및 시각화를 빠르게 구축할 수 있습니다. . 일반적으로 다음을 수행합니다.

GAN을 훈련하여 양자 회로에서 온 것처럼 보이는 샘플을 생성합니다.
교육 진행 상황과 시간 경과에 따른 분포 변화를 시각화합니다.
컴퓨팅 그래프를 탐색하여 실험을 벤치마킹합니다.

pip install tensorflow==2.7.0 tensorflow-quantum tensorboard_plugin_profile==2.4.0

# Update package resources to account for version changes.
import importlib, pkg_resources
importlib.reload(pkg_resources)

<module 'pkg_resources' from '/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pkg_resources/__init__.py'>

#docs_infra: no_execute
%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

2022-02-04 12:46:52.770534: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected

1. 데이터 생성

몇 가지 데이터를 수집하여 시작하십시오. TensorFlow Quantum을 사용하여 나머지 실험의 기본 데이터 소스가 될 일부 비트열 샘플을 빠르게 생성할 수 있습니다. Niu et al. 대폭 감소된 깊이로 임의의 회로에서 샘플링을 에뮬레이트하는 것이 얼마나 쉬운지 탐색할 것입니다. 먼저 몇 가지 도우미를 정의합니다.

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)=1000001000
(0, 1)=0000001010
(0, 2)=1010000100
(0, 3)=0010000110
(0, 4)=0110110010

다음을 사용하여 TensorFlow Quantum에서 동일한 작업을 수행할 수 있습니다.

generate_data(random_circuit_m, 10)

<tf.Tensor: shape=(10, 5), dtype=int8, numpy=
array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 1, 0, 0],
       [0, 1, 0, 0, 0],
       [0, 1, 0, 0, 0],
       [0, 1, 1, 0, 0],
       [1, 0, 0, 0, 0],
       [1, 0, 0, 1, 0],
       [1, 1, 1, 0, 0],
       [1, 1, 1, 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)>

훈련이 진행됨에 따라 시각화할 몇 가지 도우미 함수를 정의하는 것이 유용할 것입니다. 사용할 두 가지 흥미로운 양은 다음과 같습니다.

분포의 히스토그램을 생성할 수 있도록 샘플의 정수 값.
샘플 집합의 선형 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.0015467405>

2. 모델 구축

여기에서 양자 사례에 대한 DCGAN 자습서 의 관련 구성 요소를 사용할 수 있습니다. MNIST 숫자를 생성하는 대신 새 GAN을 사용하여 길이가 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 함수를 생성합니다.

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 모듈을 사용하여 이제 scalar , histogram (및 기타) 로깅을 기본 train 함수 내부에 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 대시보드를 시작할 수 있습니다.

#docs_infra: no_execute
%tensorboard --logdir tb_logs/

train 을 호출하면 TensoBoard 대시보드가 훈련 루프에 제공된 모든 요약 통계로 자동 업데이트됩니다.

train(all_data, epochs=50)

Epoch 10, took 9.325464487075806(s)
Epoch 20, took 7.684147119522095(s)
Epoch 30, took 7.508770704269409(s)
Epoch 40, took 7.5157341957092285(s)
Epoch 50, took 7.533370494842529(s)

훈련이 실행되는 동안(그리고 훈련이 완료되면) 스칼라 수량을 검사할 수 있습니다.

히스토그램 탭으로 전환하면 생성기 네트워크가 양자 분포에서 샘플을 재생성할 때 얼마나 잘 수행하는지 확인할 수도 있습니다.

TensorBoard는 실험과 관련된 요약 통계의 실시간 모니터링을 허용하는 것 외에도 실험을 프로파일링하여 성능 병목 현상을 식별하는 데 도움을 줄 수 있습니다. 성능 모니터링으로 모델을 다시 실행하려면 다음을 수행할 수 있습니다.

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

Epoch 50, took 0.8879530429840088(s)

TensorBoard는 tf.profiler.experimental.start 와 tf.profiler.experimental.stop 사이의 모든 코드를 프로파일링합니다. 이 프로필 데이터는 TensorBoard의 profile 페이지에서 볼 수 있습니다.

깊이를 높이거나 다른 클래스의 양자 회로를 실험해 보십시오. TensorFlow Quantum 실험에 통합할 수 있는 초 매개변수 조정 과 같은 TensorBoard 의 다른 모든 훌륭한 기능을 확인하십시오.