Unable to identify Tuple index error - Printable Version +- Python Forum (https://python-forum.io) +-- Forum: Python Coding (https://python-forum.io/forum-7.html) +--- Forum: Data Science (https://python-forum.io/forum-44.html) +--- Thread: Unable to identify Tuple index error (/thread-19396.html) |
Unable to identify Tuple index error - appmkl - Jun-26-2019 Hello ! I've been wanting to create a DCGAN following this tutorial. I've got the whole thing up and running on GCP, with my own image dataset (trying to get the GAN to generate satellite imagery). This is the tutorial I followed, step by step. https://towardsdatascience.com/image-generator-drawing-cartoons-with-generative-adversarial-networks-45e814ca9b6b However, once I run the file, I get this error message. --------------------------------------------------------------------------- IndexError Traceback (most recent call last) <ipython-input-14-db5a32a0c488> in <module> 9 10 with tf.Graph().as_default(): ---> 11 train(get_batches(input_images), input_images.shape) <ipython-input-11-73fe85d9d0bc> in train(get_batches, data_shape, checkpoint_to_load) 1 def train(get_batches, data_shape, checkpoint_to_load=None): 2 input_images, input_z, lr_G, lr_D = model_inputs(data_shape[1:], NOISE_SIZE) ----> 3 d_loss, g_loss = model_loss(input_images, input_z, data_shape[3]) 4 d_opt, g_opt = model_optimizers(d_loss, g_loss) 5 IndexError: tuple index out of rangeI don't understand why I'm getting this error message, as I've followed the tutorial and copied the same code... Any help greatly appreciated, been trying to figure this out for a week now, but relatively new to python. Thank you !! RE: Unable to identify Tuple index error - Larz60+ - Jun-27-2019 Please show your code (not tutorials) RE: Unable to identify Tuple index error - appmkl - Jun-27-2019 (Jun-27-2019, 03:39 PM)Larz60+ Wrote: Please show your code (not tutorials) Here you go ! Quite long.. import os import time import tensorflow as tf import numpy as np from glob import glob import datetime import random from PIL import Image import matplotlib.pyplot as plt %matplotlib inlinein2 def generator(z, output_channel_dim, training): with tf.variable_scope("generator", reuse= not training): # 8x8x1024 fully_connected = tf.layers.dense(z, 8*8*1024) fully_connected = tf.reshape(fully_connected, (-1, 8, 8, 1024)) fully_connected = tf.nn.leaky_relu(fully_connected) # 8x8x1024 -> 16x16x512 trans_conv1 = tf.layers.conv2d_transpose(inputs=fully_connected, filters=512, kernel_size=[5,5], strides=[2,2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name="trans_conv1") batch_trans_conv1 = tf.layers.batch_normalization(inputs = trans_conv1, training=training, epsilon=EPSILON, name="batch_trans_conv1") trans_conv1_out = tf.nn.leaky_relu(batch_trans_conv1, name="trans_conv1_out") # 16x16x512 -> 32x32x256 trans_conv2 = tf.layers.conv2d_transpose(inputs=trans_conv1_out, filters=256, kernel_size=[5,5], strides=[2,2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name="trans_conv2") batch_trans_conv2 = tf.layers.batch_normalization(inputs = trans_conv2, training=training, epsilon=EPSILON, name="batch_trans_conv2") trans_conv2_out = tf.nn.leaky_relu(batch_trans_conv2, name="trans_conv2_out") # 32x32x256 -> 64x64x128 trans_conv3 = tf.layers.conv2d_transpose(inputs=trans_conv2_out, filters=128, kernel_size=[5,5], strides=[2,2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name="trans_conv3") batch_trans_conv3 = tf.layers.batch_normalization(inputs = trans_conv3, training=training, epsilon=EPSILON, name="batch_trans_conv3") trans_conv3_out = tf.nn.leaky_relu(batch_trans_conv3, name="trans_conv3_out") # 64x64x128 -> 128x128x64 trans_conv4 = tf.layers.conv2d_transpose(inputs=trans_conv3_out, filters=64, kernel_size=[5,5], strides=[2,2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name="trans_conv4") batch_trans_conv4 = tf.layers.batch_normalization(inputs = trans_conv4, training=training, epsilon=EPSILON, name="batch_trans_conv4") trans_conv4_out = tf.nn.leaky_relu(batch_trans_conv4, name="trans_conv4_out") # 128x128x64 -> 128x128x3 logits = tf.layers.conv2d_transpose(inputs=trans_conv4_out, filters=3, kernel_size=[5,5], strides=[1,1], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name="logits") out = tf.tanh(logits, name="out") return outIn [3]: def discriminator(x, reuse): with tf.variable_scope("discriminator", reuse=reuse): # 128*128*3 -> 64x64x64 conv1 = tf.layers.conv2d(inputs=x, filters=64, kernel_size=[5,5], strides=[2,2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name='conv1') batch_norm1 = tf.layers.batch_normalization(conv1, training=True, epsilon=EPSILON, name='batch_norm1') conv1_out = tf.nn.leaky_relu(batch_norm1, name="conv1_out") # 64x64x64-> 32x32x128 conv2 = tf.layers.conv2d(inputs=conv1_out, filters=128, kernel_size=[5, 5], strides=[2, 2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name='conv2') batch_norm2 = tf.layers.batch_normalization(conv2, training=True, epsilon=EPSILON, name='batch_norm2') conv2_out = tf.nn.leaky_relu(batch_norm2, name="conv2_out") # 32x32x128 -> 16x16x256 conv3 = tf.layers.conv2d(inputs=conv2_out, filters=256, kernel_size=[5, 5], strides=[2, 2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name='conv3') batch_norm3 = tf.layers.batch_normalization(conv3, training=True, epsilon=EPSILON, name='batch_norm3') conv3_out = tf.nn.leaky_relu(batch_norm3, name="conv3_out") # 16x16x256 -> 16x16x512 conv4 = tf.layers.conv2d(inputs=conv3_out, filters=512, kernel_size=[5, 5], strides=[1, 1], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name='conv4') batch_norm4 = tf.layers.batch_normalization(conv4, training=True, epsilon=EPSILON, name='batch_norm4') conv4_out = tf.nn.leaky_relu(batch_norm4, name="conv4_out") # 16x16x512 -> 8x8x1024 conv5 = tf.layers.conv2d(inputs=conv4_out, filters=1024, kernel_size=[5, 5], strides=[2, 2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV), name='conv5') batch_norm5 = tf.layers.batch_normalization(conv5, training=True, epsilon=EPSILON, name='batch_norm5') conv5_out = tf.nn.leaky_relu(batch_norm5, name="conv5_out") flatten = tf.reshape(conv5_out, (-1, 8*8*1024)) logits = tf.layers.dense(inputs=flatten, units=1, activation=None) out = tf.sigmoid(logits) return out, logitsIn [4]: def model_loss(input_real, input_z, output_channel_dim): g_model = generator(input_z, output_channel_dim, True) noisy_input_real = input_real + tf.random_normal(shape=tf.shape(input_real), mean=0.0, stddev=random.uniform(0.0, 0.1), dtype=tf.float32) d_model_real, d_logits_real = discriminator(noisy_input_real, reuse=False) d_model_fake, d_logits_fake = discriminator(g_model, reuse=True) d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real, labels=tf.ones_like(d_model_real)*random.uniform(0.9, 1.0))) d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake, labels=tf.zeros_like(d_model_fake))) d_loss = tf.reduce_mean(0.5 * (d_loss_real + d_loss_fake)) g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake, labels=tf.ones_like(d_model_fake))) return d_loss, g_lossIn [5]: def model_optimizers(d_loss, g_loss): t_vars = tf.trainable_variables() g_vars = [var for var in t_vars if var.name.startswith("generator")] d_vars = [var for var in t_vars if var.name.startswith("discriminator")] update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) gen_updates = [op for op in update_ops if op.name.startswith('generator')] with tf.control_dependencies(gen_updates): d_train_opt = tf.train.AdamOptimizer(learning_rate=LR_D, beta1=BETA1).minimize(d_loss, var_list=d_vars) g_train_opt = tf.train.AdamOptimizer(learning_rate=LR_G, beta1=BETA1).minimize(g_loss, var_list=g_vars) return d_train_opt, g_train_optIn [6]: def model_inputs(real_dim, z_dim): inputs_real = tf.placeholder(tf.float32, (None, *real_dim), name='inputs_real') inputs_z = tf.placeholder(tf.float32, (None, z_dim), name="input_z") learning_rate_G = tf.placeholder(tf.float32, name="lr_g") learning_rate_D = tf.placeholder(tf.float32, name="lr_d") return inputs_real, inputs_z, learning_rate_G, learning_rate_DIn [7]: def show_samples(sample_images, name, epoch): figure, axes = plt.subplots(1, len(sample_images), figsize = (IMAGE_SIZE, IMAGE_SIZE)) for index, axis in enumerate(axes): axis.axis('off') image_array = sample_images[index] axis.imshow(image_array) image = Image.fromarray(image_array) image.save(name+"_"+str(epoch)+"_"+str(index)+".png") plt.savefig(name+"_"+str(epoch)+".png", bbox_inches='tight', pad_inches=0) plt.show() plt.close()In [8]: def test(sess, input_z, out_channel_dim, epoch): example_z = np.random.uniform(-1, 1, size=[SAMPLES_TO_SHOW, input_z.get_shape().as_list()[-1]]) samples = sess.run(generator(input_z, out_channel_dim, False), feed_dict={input_z: example_z}) sample_images = [((sample + 1.0) * 127.5).astype(np.uint8) for sample in samples] show_samples(sample_images, OUTPUT_DIR + "samples", epoch)In [9]: def summarize_epoch(epoch, duration, sess, d_losses, g_losses, input_z, data_shape): minibatch_size = int(data_shape[0]//BATCH_SIZE) print("Epoch {}/{}".format(epoch, EPOCHS), "\nDuration: {:.5f}".format(duration), "\nD Loss: {:.5f}".format(np.mean(d_losses[-minibatch_size:])), "\nG Loss: {:.5f}".format(np.mean(g_losses[-minibatch_size:]))) fig, ax = plt.subplots() plt.plot(d_losses, label='Discriminator', alpha=0.6) plt.plot(g_losses, label='Generator', alpha=0.6) plt.title("Losses") plt.legend() plt.savefig(OUTPUT_DIR + "losses_" + str(epoch) + ".png") plt.show() plt.close() test(sess, input_z, data_shape[3], epoch)In [10]: def get_batches(data): batches = [] for i in range(int(data.shape[0]//BATCH_SIZE)): batch = data[i * BATCH_SIZE:(i + 1) * BATCH_SIZE] augmented_images = [] for img in batch: image = Image.fromarray(img) if random.choice([True, False]): image = image.transpose(Image.FLIP_LEFT_RIGHT) augmented_images.append(np.asarray(image)) batch = np.asarray(augmented_images) normalized_batch = (batch / 127.5) - 1.0 batches.append(normalized_batch) return batchesIn [11]: def train(get_batches, data_shape, checkpoint_to_load=None): input_images, input_z, lr_G, lr_D = model_inputs(data_shape[1:], NOISE_SIZE) d_loss, g_loss = model_loss(input_images, input_z, data_shape[3]) d_opt, g_opt = model_optimizers(d_loss, g_loss) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) epoch = 0 iteration = 0 d_losses = [] g_losses = [] for epoch in range(EPOCHS): epoch += 1 start_time = time.time() for batch_images in get_batches: iteration += 1 batch_z = np.random.uniform(-1, 1, size=(BATCH_SIZE, NOISE_SIZE)) _ = sess.run(d_opt, feed_dict={input_images: batch_images, input_z: batch_z, lr_D: LR_D}) _ = sess.run(g_opt, feed_dict={input_images: batch_images, input_z: batch_z, lr_G: LR_G}) d_losses.append(d_loss.eval({input_z: batch_z, input_images: batch_images})) g_losses.append(g_loss.eval({input_z: batch_z})) summarize_epoch(epoch, time.time()-start_time, sess, d_losses, g_losses, input_z, data_shape)In [12]: # Paths INPUT_DATA_DIR = "/home/andreas_pappamikail/cloud/images/" # Path to the folder with input images. For more info check simspons_dataset.txt OUTPUT_DIR = './{date:%Y-%m-%d_%H:%M:%S}/'.format(date=datetime.datetime.now()) if not os.path.exists(OUTPUT_DIR): os.makedirs(OUTPUT_DIR)In [13]: # Hyperparameters IMAGE_SIZE = 128 NOISE_SIZE = 100 LR_D = 0.00004 LR_G = 0.0004 BATCH_SIZE = 64 EPOCHS = 300 BETA1 = 0.5 WEIGHT_INIT_STDDEV = 0.02 EPSILON = 0.00005 SAMPLES_TO_SHOW = 5In [14]: # Training input_images = np.asarray([np.asarray(Image.open(file).resize((IMAGE_SIZE, IMAGE_SIZE))) for file in glob(INPUT_DATA_DIR + '*')]) print ("Input: " + str(input_images.shape)) np.random.shuffle(input_images) sample_images = random.sample(list(input_images), SAMPLES_TO_SHOW) show_samples(sample_images, OUTPUT_DIR + "inputs", 0) with tf.Graph().as_default(): train(get_batches(input_images), input_images.shape) Input: (3343, 128, 128) --------------------------------------------------------------------------- IndexError Traceback (most recent call last) <ipython-input-14-db5a32a0c488> in <module> 9 10 with tf.Graph().as_default(): ---> 11 train(get_batches(input_images), input_images.shape) <ipython-input-11-73fe85d9d0bc> in train(get_batches, data_shape, checkpoint_to_load) 1 def train(get_batches, data_shape, checkpoint_to_load=None): 2 input_images, input_z, lr_G, lr_D = model_inputs(data_shape[1:], NOISE_SIZE) ----> 3 d_loss, g_loss = model_loss(input_images, input_z, data_shape[3]) 4 d_opt, g_opt = model_optimizers(d_loss, g_loss) 5 IndexError: tuple index out of rangeThen get the error posted above .. Any help greatly appreciated :) RE: Unable to identify Tuple index error - Yoriz - Jun-27-2019 data_shape points to the following tuple (index of each value shown below them)
data_shape[3] gives an index error because the index only goes up to 2
RE: Unable to identify Tuple index error - appmkl - Jun-28-2019 (Jun-27-2019, 05:11 PM)Yoriz Wrote: Thank you for the answer ! Yes I figured that was the problem after looking online. So should I just change the data_value to 2 instead of 3 ? I'm just confused as I followed the. step by step guide on github and only changed the image source, so not sure why the index onnly goes up to 2 ? Could you explain perhaps ? Thank you for your time !! |