497 lines
115 KiB
Plaintext
497 lines
115 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# Lab5"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"WARNING:tensorflow:From f:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"import tensorflow as tf\n",
|
|
"\n",
|
|
"import glob\n",
|
|
"import imageio\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"import numpy as np\n",
|
|
"import os\n",
|
|
"import PIL\n",
|
|
"from tensorflow.keras import layers\n",
|
|
"import time\n",
|
|
"\n",
|
|
"from IPython import display"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()\n",
|
|
"\n",
|
|
"train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')\n",
|
|
"train_images = (train_images - 127.5) / 127.5 # Normalize the images to [-1, 1]\n",
|
|
"\n",
|
|
"BUFFER_SIZE = 60000\n",
|
|
"BATCH_SIZE = 256\n",
|
|
"\n",
|
|
"# Batch and shuffle the data\n",
|
|
"train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"EPOCHS = 50\n",
|
|
"noise_dim = 100\n",
|
|
"num_examples_to_generate = 16\n",
|
|
"\n",
|
|
"# You will reuse this seed overtime (so it's easier)\n",
|
|
"# to visualize progress in the animated GIF)\n",
|
|
"seed = tf.random.normal([num_examples_to_generate, noise_dim])"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 10,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"WARNING:tensorflow:Detecting that an object or model or tf.train.Checkpoint is being deleted with unrestored values. See the following logs for the specific values in question. To silence these warnings, use `status.expect_partial()`. See https://www.tensorflow.org/api_docs/python/tf/train/Checkpoint#restorefor details about the status object returned by the restore function.\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.1\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.2\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.3\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.4\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.5\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.6\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.7\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.8\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.9\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.10\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.11\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.12\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.1\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.2\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.3\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.4\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.5\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.6\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.7\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.8\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.9\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.10\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.11\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.12\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.13\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.14\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.15\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.16\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.17\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.18\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.19\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.20\n",
|
|
"WARNING:tensorflow:Detecting that an object or model or tf.train.Checkpoint is being deleted with unrestored values. See the following logs for the specific values in question. To silence these warnings, use `status.expect_partial()`. See https://www.tensorflow.org/api_docs/python/tf/train/Checkpoint#restorefor details about the status object returned by the restore function.\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.1\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.2\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.3\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.4\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.5\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.6\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.7\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.8\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.9\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.10\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.11\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).discriminator_optimizer._variables.12\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.1\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.2\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.3\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.4\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.5\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.6\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.7\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.8\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.9\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.10\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.11\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.12\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.13\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.14\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.15\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.16\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.17\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.18\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.19\n",
|
|
"WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).generator_optimizer._variables.20\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"def make_generator_model():\n",
|
|
" model = tf.keras.Sequential()\n",
|
|
" model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))\n",
|
|
" model.add(layers.BatchNormalization())\n",
|
|
" model.add(layers.LeakyReLU())\n",
|
|
"\n",
|
|
" model.add(layers.Reshape((7, 7, 256)))\n",
|
|
" assert model.output_shape == (None, 7, 7, 256) # Note: None is the batch size\n",
|
|
"\n",
|
|
" model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))\n",
|
|
" assert model.output_shape == (None, 7, 7, 128)\n",
|
|
" model.add(layers.BatchNormalization())\n",
|
|
" model.add(layers.LeakyReLU())\n",
|
|
"\n",
|
|
" model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))\n",
|
|
" assert model.output_shape == (None, 14, 14, 64)\n",
|
|
" model.add(layers.BatchNormalization())\n",
|
|
" model.add(layers.LeakyReLU())\n",
|
|
"\n",
|
|
" model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))\n",
|
|
" assert model.output_shape == (None, 28, 28, 1)\n",
|
|
"\n",
|
|
" return model\n",
|
|
"\n",
|
|
"def make_discriminator_model():\n",
|
|
" model = tf.keras.Sequential()\n",
|
|
" model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',\n",
|
|
" input_shape=[28, 28, 1]))\n",
|
|
" model.add(layers.LeakyReLU())\n",
|
|
" model.add(layers.Dropout(0.3))\n",
|
|
"\n",
|
|
" model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))\n",
|
|
" model.add(layers.LeakyReLU())\n",
|
|
" model.add(layers.Dropout(0.3))\n",
|
|
"\n",
|
|
" model.add(layers.Flatten())\n",
|
|
" model.add(layers.Dense(1))\n",
|
|
"\n",
|
|
" return model\n",
|
|
"\n",
|
|
"cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n",
|
|
"\n",
|
|
"def discriminator_loss(real_output, fake_output):\n",
|
|
" real_loss = cross_entropy(tf.ones_like(real_output), real_output)\n",
|
|
" fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)\n",
|
|
" total_loss = real_loss + fake_loss\n",
|
|
" return total_loss\n",
|
|
"\n",
|
|
"def generator_loss(fake_output):\n",
|
|
" return cross_entropy(tf.ones_like(fake_output), fake_output)\n",
|
|
"\n",
|
|
"generator = make_generator_model()\n",
|
|
"\n",
|
|
"discriminator = make_discriminator_model()\n",
|
|
"\n",
|
|
"generator_optimizer = tf.keras.optimizers.Adam(1e-4)\n",
|
|
"discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)\n",
|
|
"\n",
|
|
"checkpoint_prefix = \"ckpt\"\n",
|
|
"checkpoint = tf.train.Checkpoint(\n",
|
|
" generator_optimizer=generator_optimizer,\n",
|
|
" discriminator_optimizer=discriminator_optimizer,\n",
|
|
" generator=generator,\n",
|
|
" discriminator=discriminator\n",
|
|
")\n",
|
|
"\n",
|
|
"\n",
|
|
"@tf.function\n",
|
|
"def train_step(images):\n",
|
|
" noise = tf.random.normal([BATCH_SIZE, noise_dim])\n",
|
|
"\n",
|
|
" with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:\n",
|
|
" generated_images = generator(noise, training=True)\n",
|
|
"\n",
|
|
" real_output = discriminator(images, training=True)\n",
|
|
" fake_output = discriminator(generated_images, training=True)\n",
|
|
"\n",
|
|
" gen_loss = generator_loss(fake_output)\n",
|
|
" disc_loss = discriminator_loss(real_output, fake_output)\n",
|
|
"\n",
|
|
" gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)\n",
|
|
" gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)\n",
|
|
"\n",
|
|
" generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))\n",
|
|
" discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))\n",
|
|
"\n",
|
|
"def generate_and_save_images(model, epoch, test_input):\n",
|
|
" # Notice `training` is set to False.\n",
|
|
" # This is so all layers run in inference mode (batchnorm).\n",
|
|
" predictions = model(test_input, training=False)\n",
|
|
"\n",
|
|
" fig = plt.figure(figsize=(4, 4))\n",
|
|
"\n",
|
|
" for i in range(predictions.shape[0]):\n",
|
|
" plt.subplot(4, 4, i+1)\n",
|
|
" plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')\n",
|
|
" plt.axis('off')\n",
|
|
"\n",
|
|
" plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))\n",
|
|
" plt.show()\n",
|
|
"\n",
|
|
"def train(dataset, epochs):\n",
|
|
" for epoch in range(epochs):\n",
|
|
" start = time.time()\n",
|
|
"\n",
|
|
" for image_batch in dataset:\n",
|
|
" train_step(image_batch)\n",
|
|
"\n",
|
|
" # Produce images for the GIF as you go\n",
|
|
" display.clear_output(wait=True)\n",
|
|
" generate_and_save_images(generator,\n",
|
|
" epoch + 1,\n",
|
|
" seed)\n",
|
|
"\n",
|
|
" # Save the model every 5 epochs\n",
|
|
" if (epoch + 1) % 5 == 0:\n",
|
|
" checkpoint.save(file_prefix = checkpoint_prefix)\n",
|
|
"\n",
|
|
" print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))\n",
|
|
"\n",
|
|
" # Generate after the final epoch\n",
|
|
" display.clear_output(wait=True)\n",
|
|
" generate_and_save_images(generator,\n",
|
|
" epochs,\n",
|
|
" seed)\n",
|
|
"\n",
|
|
"def display_image(epoch_no):\n",
|
|
" return PIL.Image.open('reference/image_at_epoch_{:04d}.png'.format(epoch_no))\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 24,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 400x400 with 16 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Time for epoch 20 is 98.05159759521484 sec\n"
|
|
]
|
|
},
|
|
{
|
|
"ename": "KeyboardInterrupt",
|
|
"evalue": "",
|
|
"output_type": "error",
|
|
"traceback": [
|
|
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
|
|
"\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)",
|
|
"Cell \u001b[1;32mIn[24], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mEPOCHS\u001b[49m\u001b[43m)\u001b[49m\n",
|
|
"Cell \u001b[1;32mIn[23], line 107\u001b[0m, in \u001b[0;36mtrain\u001b[1;34m(dataset, epochs)\u001b[0m\n\u001b[0;32m 104\u001b[0m start \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n\u001b[0;32m 106\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m image_batch \u001b[38;5;129;01min\u001b[39;00m dataset:\n\u001b[1;32m--> 107\u001b[0m \u001b[43mtrain_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage_batch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 109\u001b[0m \u001b[38;5;66;03m# Produce images for the GIF as you go\u001b[39;00m\n\u001b[0;32m 110\u001b[0m display\u001b[38;5;241m.\u001b[39mclear_output(wait\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n",
|
|
"File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\util\\traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m 149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n",
|
|
"File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\polymorphic_function.py:832\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m 829\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 831\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[1;32m--> 832\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 834\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[0;32m 835\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n",
|
|
"File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\polymorphic_function.py:868\u001b[0m, in \u001b[0;36mFunction._call\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m 865\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[0;32m 866\u001b[0m \u001b[38;5;66;03m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[0;32m 867\u001b[0m \u001b[38;5;66;03m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[1;32m--> 868\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtracing_compilation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 869\u001b[0m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_no_variable_creation_config\u001b[49m\n\u001b[0;32m 870\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 871\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_variable_creation_config \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 872\u001b[0m \u001b[38;5;66;03m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[0;32m 873\u001b[0m \u001b[38;5;66;03m# in parallel.\u001b[39;00m\n\u001b[0;32m 874\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n",
|
|
"File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\tracing_compilation.py:139\u001b[0m, in \u001b[0;36mcall_function\u001b[1;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[0;32m 137\u001b[0m bound_args \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 138\u001b[0m flat_inputs \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39munpack_inputs(bound_args)\n\u001b[1;32m--> 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[0;32m 140\u001b[0m \u001b[43m \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[0;32m 141\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
|
|
"File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\concrete_function.py:1323\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[1;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[0;32m 1319\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[0;32m 1320\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[0;32m 1321\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[0;32m 1322\u001b[0m \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[1;32m-> 1323\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1324\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[0;32m 1325\u001b[0m args,\n\u001b[0;32m 1326\u001b[0m possible_gradient_type,\n\u001b[0;32m 1327\u001b[0m executing_eagerly)\n\u001b[0;32m 1328\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n",
|
|
"File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\atomic_function.py:216\u001b[0m, in \u001b[0;36mAtomicFunction.call_preflattened\u001b[1;34m(self, args)\u001b[0m\n\u001b[0;32m 214\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core\u001b[38;5;241m.\u001b[39mTensor]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[0;32m 215\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[1;32m--> 216\u001b[0m flat_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 217\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mpack_output(flat_outputs)\n",
|
|
"File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\polymorphic_function\\atomic_function.py:251\u001b[0m, in \u001b[0;36mAtomicFunction.call_flat\u001b[1;34m(self, *args)\u001b[0m\n\u001b[0;32m 249\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m record\u001b[38;5;241m.\u001b[39mstop_recording():\n\u001b[0;32m 250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mexecuting_eagerly():\n\u001b[1;32m--> 251\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_bound_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 252\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 253\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 254\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction_type\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 256\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 257\u001b[0m outputs \u001b[38;5;241m=\u001b[39m make_call_op_in_graph(\n\u001b[0;32m 258\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m 259\u001b[0m \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[0;32m 260\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mfunction_call_options\u001b[38;5;241m.\u001b[39mas_attrs(),\n\u001b[0;32m 261\u001b[0m )\n",
|
|
"File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\context.py:1486\u001b[0m, in \u001b[0;36mContext.call_function\u001b[1;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[0;32m 1484\u001b[0m cancellation_context \u001b[38;5;241m=\u001b[39m cancellation\u001b[38;5;241m.\u001b[39mcontext()\n\u001b[0;32m 1485\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m-> 1486\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 1487\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mutf-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1488\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1489\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1490\u001b[0m \u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1491\u001b[0m \u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 1492\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1493\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 1494\u001b[0m outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[0;32m 1495\u001b[0m name\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[0;32m 1496\u001b[0m num_outputs\u001b[38;5;241m=\u001b[39mnum_outputs,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1500\u001b[0m cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_context,\n\u001b[0;32m 1501\u001b[0m )\n",
|
|
"File \u001b[1;32mf:\\KTU\\Neuroninių tinklų metodai\\venv\\Lib\\site-packages\\tensorflow\\python\\eager\\execute.py:53\u001b[0m, in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m 51\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 52\u001b[0m ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[1;32m---> 53\u001b[0m tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 55\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m 56\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
|
|
"\u001b[1;31mKeyboardInterrupt\u001b[0m: "
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"train(train_dataset, EPOCHS)\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 12,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<tensorflow.python.checkpoint.checkpoint.CheckpointLoadStatus at 0x1620ecabbd0>"
|
|
]
|
|
},
|
|
"execution_count": 12,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"checkpoint.restore(tf.train.latest_checkpoint(\"reference\"))\n",
|
|
"# display_image(EPOCHS)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "plaintext"
|
|
}
|
|
},
|
|
"source": [
|
|
"### 2. Pakeiskite tinklo parametrus, architektūrą, įvertinkite pakeitimų įtaką modelio tikslumui ir apmokymo greičiui."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 14,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"image/png": "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",
|
|
"text/plain": [
|
|
"<Figure size 400x400 with 16 Axes>"
|
|
]
|
|
},
|
|
"metadata": {},
|
|
"output_type": "display_data"
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Time for epoch 27 is 83.70056343078613 sec\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"def make_generator_model_v2():\n",
|
|
" model = tf.keras.Sequential()\n",
|
|
" model.add(layers.Dense(7*7*256, input_shape=(100,)))\n",
|
|
" model.add(layers.BatchNormalization())\n",
|
|
" model.add(layers.ReLU())\n",
|
|
"\n",
|
|
" model.add(layers.Reshape((7, 7, 256)))\n",
|
|
" assert model.output_shape == (None, 7, 7, 256) # Note: None is the batch size\n",
|
|
"\n",
|
|
" model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same'))\n",
|
|
" assert model.output_shape == (None, 7, 7, 128)\n",
|
|
" model.add(layers.BatchNormalization())\n",
|
|
" model.add(layers.ReLU())\n",
|
|
"\n",
|
|
" model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same'))\n",
|
|
" assert model.output_shape == (None, 14, 14, 64)\n",
|
|
" model.add(layers.BatchNormalization())\n",
|
|
" model.add(layers.ReLU())\n",
|
|
"\n",
|
|
" model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', activation='tanh'))\n",
|
|
" assert model.output_shape == (None, 28, 28, 1)\n",
|
|
"\n",
|
|
" return model\n",
|
|
"\n",
|
|
"def make_discriminator_model_v2():\n",
|
|
" model = tf.keras.Sequential()\n",
|
|
" model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',\n",
|
|
" input_shape=[28, 28, 1]))\n",
|
|
" model.add(layers.ReLU())\n",
|
|
" model.add(layers.Dropout(0.3))\n",
|
|
"\n",
|
|
" model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))\n",
|
|
" model.add(layers.ReLU())\n",
|
|
" model.add(layers.Dropout(0.3))\n",
|
|
"\n",
|
|
" model.add(layers.Flatten())\n",
|
|
" model.add(layers.Dense(1))\n",
|
|
"\n",
|
|
" return model\n",
|
|
"\n",
|
|
"cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n",
|
|
"\n",
|
|
"generator = make_generator_model()\n",
|
|
"discriminator = make_discriminator_model()\n",
|
|
"generator_optimizer = tf.keras.optimizers.Adam(1e-2)\n",
|
|
"discriminator_optimizer = tf.keras.optimizers.Adam(1e-2)\n",
|
|
"\n",
|
|
"train(train_dataset, EPOCHS)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### 3. Pritaikykite modelį Fashion MNIST duomenų rinkiniui."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "plaintext"
|
|
}
|
|
},
|
|
"source": [
|
|
"### 4. Pritaikykite modelį RGB vaizdų generavimui."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": []
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "venv",
|
|
"language": "python",
|
|
"name": "python3"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": {
|
|
"name": "ipython",
|
|
"version": 3
|
|
},
|
|
"file_extension": ".py",
|
|
"mimetype": "text/x-python",
|
|
"name": "python",
|
|
"nbconvert_exporter": "python",
|
|
"pygments_lexer": "ipython3",
|
|
"version": "3.11.0"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 2
|
|
}
|