এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

গবেষণা সরঞ্জাম

TensorFlow.org এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

টেনসরফ্লো কোয়ান্টাম টেনসরফ্লো ইকোসিস্টেমে কোয়ান্টাম আদিম নিয়ে আসে। এখন কোয়ান্টাম গবেষকরা TensorFlow থেকে টুলস ব্যবহার করতে পারেন। এই টিউটোরিয়ালে আপনি আপনার কোয়ান্টাম কম্পিউটিং গবেষণায় টেনসরবোর্ডকে অন্তর্ভুক্ত করার বিষয়ে ঘনিষ্ঠভাবে নজর দেবেন। TensorFlow থেকে DCGAN টিউটোরিয়াল ব্যবহার করে আপনি দ্রুত কাজ করার পরীক্ষা-নিরীক্ষা এবং ভিজ্যুয়ালাইজেশন তৈরি করবেন যা Niu et al দ্বারা করা হয়েছে। . ব্যাপকভাবে বলতে গেলে আপনি করবেন:

কোয়ান্টাম সার্কিট থেকে এসেছে এমন নমুনা তৈরি করতে একটি 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 কোয়ান্টাম ব্যবহার করতে পারেন যা আপনার বাকি পরীক্ষার জন্য প্রাথমিক ডেটাসোর্স হবে। নিউ এট আলের মত। আপনি গভীরভাবে কম গভীরতা সহ র্যান্ডম সার্কিট থেকে নমুনা অনুকরণ করা কতটা সহজ তা অন্বেষণ করবেন। প্রথমে, কিছু সাহায্যকারী সংজ্ঞায়িত করুন:

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 কোয়ান্টামের সাথে একই জিনিস করতে পারেন:

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

এখন আপনার কাছে আপনার মডেলের জন্য প্রয়োজনীয় সমস্ত বিল্ডিং ব্লক রয়েছে, আপনি একটি প্রশিক্ষণ ফাংশন সেটআপ করতে পারেন যা টেনসরবোর্ড ভিজ্যুয়ালাইজেশনকে অন্তর্ভুক্ত করে। প্রথমে একটি টেনসরবোর্ড ফাইলরাইটার সেটআপ করুন:

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 ফাংশনের ভিতরে টেনসরবোর্ডে scalar , histogram (পাশাপাশি অন্যান্য) লগিং অন্তর্ভুক্ত করতে পারেন:

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 কল করার সময় টেনসোবোর্ড ড্যাশবোর্ড ট্রেনিং লুপে দেওয়া সমস্ত সারসংক্ষেপ পরিসংখ্যানের সাথে স্বয়ংক্রিয়ভাবে আপডেট হবে।

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)

প্রশিক্ষণ চলাকালীন (এবং এটি সম্পূর্ণ হলে) আপনি স্কেলার পরিমাণ পরীক্ষা করতে পারেন:

হিস্টোগ্রাম ট্যাবে স্যুইচ করে আপনি দেখতে পারেন যে জেনারেটর নেটওয়ার্ক কোয়ান্টাম ডিস্ট্রিবিউশন থেকে নমুনাগুলি পুনরায় তৈরি করতে কতটা ভাল করে:

আপনার পরীক্ষার সাথে সম্পর্কিত সারাংশের পরিসংখ্যানের রিয়েল টাইম নিরীক্ষণের অনুমতি দেওয়ার পাশাপাশি, টেনসরবোর্ড আপনাকে কার্যক্ষমতার বাধাগুলি সনাক্ত করতে আপনার পরীক্ষাগুলি প্রোফাইলে সহায়তা করতে পারে। পারফরম্যান্স পর্যবেক্ষণের সাথে আপনার মডেল পুনরায় চালানোর জন্য আপনি করতে পারেন:

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

Epoch 50, took 0.8879530429840088(s)

টেনসরবোর্ড tf.profiler.experimental.start এবং tf.profiler.experimental.stop এর মধ্যে সমস্ত কোড প্রোফাইল করবে। এই প্রোফাইল ডেটা তারপর টেনসরবোর্ডের profile পৃষ্ঠায় দেখা যাবে:

গভীরতা বাড়ানোর চেষ্টা করুন বা কোয়ান্টাম সার্কিটের বিভিন্ন শ্রেণীর সাথে পরীক্ষা করুন। হাইপারপ্যারামিটার টিউনিংয়ের মতো টেনসরবোর্ডের অন্যান্য দুর্দান্ত বৈশিষ্ট্যগুলি দেখুন যা আপনি আপনার টেনসরফ্লো কোয়ান্টাম পরীক্ষায় অন্তর্ভুক্ত করতে পারেন।