data.combine([ # map(lambda x: x[:30], data.digits_session_dependence_1_dataset(channels=range(1, 8))), # map(lambda x: x[:30], data.digits_session_dependence_2_dataset(channels=range(1, 8))), # map(lambda x: x[:40], data.digits_session_dependence_3_dataset(channels=range(1, 8))), validation_sequence_groups, ])) # Pads or truncates each sequence to length length = 2000 # 300,600 training_sequence_groups = data.transform.pad_truncate( training_sequence_groups, length) validation_sequence_groups = data.transform.pad_truncate( validation_sequence_groups, length) # Format into sequences and labels train_sequences, train_labels = data.get_inputs(training_sequence_groups) val_sequences, val_labels = data.get_inputs(validation_sequence_groups) # Calculate sample weights class_weights = compute_class_weight('balanced', np.unique(train_labels), train_labels) train_weights = class_weights[list(train_labels)] train_labels = tf.keras.utils.to_categorical(train_labels) val_labels = tf.keras.utils.to_categorical(val_labels) print np.shape(train_sequences) print np.shape(train_labels) print np.shape(val_sequences) print np.shape(val_labels)
1, 1, 4, 2, 4, 1, 4, 1, 4, 2, 2, 2, 1, 1, 3, 2, 4, 1, 3, 0, 3, 4, 3, 4, 3, 4, 3, 1, 2, 3, 3, 0, 4, 3, 0, 2, 2, 0, 4, 4, 3, 4, 1, 3, 4, 4, 0, 3, 0, 4, 3, 1, 2, 1, 3, 0, 1, 1, 3, 1, 2, 3, 0, 3, 0, 2, 3, 1, 3, 3, 3, 2, 2, 0, 2, 0, 4, 2, 3, 3, 2, 2, 4, 1, 0, 0, 4, 2, 1, 1, 0, 1, 0, 0, 0, 4, 0, 2, 3, 2, 4, 0, 4, 2, 3, 2, 4, 0, 4, 1, 2, 0, 1, 0, 1, 1, 0, 4, 2, 1, 1, 4, 4, 1, 1, 2, 3, 3, 2, 4, 2, 2, 0, 3, 0, 2, 1, 4, 2, 2, 3, 1, 2, 4, 2, 1, 2, 4, 0 ] sequence_groups = transform_data( data.process_scrambled(labels, ['arnav1.txt'], channels=channels, sample_rate=250)) print len(sequence_groups) print map(len, sequence_groups) lengths = map(len, data.get_inputs(sequence_groups)[0]) print min(lengths), np.mean(lengths), max(lengths) # Split sequence_groups into training and validation data training_sequence_groups, validation_sequence_groups = data.split( sequence_groups, 1. / 3) # Manually selecting different training and validation datasets #training_sequence_groups = transform_data(data.digits_session_1_dataset()) #validation_sequence_groups = transform_data(data.digits_session_4_dataset()) # Pads or truncates each sequence to length length = 450 # DO NOT CHANGE training_sequence_groups = data.transform.pad_truncate( training_sequence_groups, length) validation_sequence_groups = data.transform.pad_truncate(
with arg_scope([conv2d], batch_norm_params=batch_norm_params, stddev=0.02, activation=lrelu, weight_decay=1e-5): inp = inp-0.5 o = conv2d(inp, num_filters_out=n, kernel_size=(3, 3), stride=1) o = conv2d(o, num_filters_out=n, kernel_size=(3, 3), stride=2) o = conv2d(o, num_filters_out=n, kernel_size=(3, 3), stride=2) o = conv2d(o, num_filters_out=n, kernel_size=(3, 3), stride=2) o = conv2d(o, num_filters_out=n, kernel_size=(3, 3), stride=1) flat = flatten(o) #flat = flatten(avg_pool(o, kernel_size=3)) z = fc(flat, num_units_out=z_dim, activation=tf.nn.tanh)/2+.5 return z batch_size = 32 with tf.variable_scope("data"): images, _ = data.get_inputs(batch_size) with tf.variable_scope("generator") as gen_scope: z = tf.random_uniform([batch_size, z_dim], 0, 1) generated = generator(z) gen_scope.reuse_variables() gen_vars = [x for x in tf.trainable_variables() if x.name.startswith(gen_scope.name)] with tf.variable_scope("discriminator") as scope: real_probs = discriminator(images) with tf.variable_scope("discriminator", reuse=True) as scope: fake_probs = discriminator(generated) with tf.variable_scope("encoder") as encoder_scope: enc_z = encoder(images, z_dim)
# pipeline # input_batch -> samples -> train_model # descriminator --> works on sets of samples? # RNN? # Sample a grid of points and run on that. # sample a subset of image and run on that. # Checks real image data against sampled image data # sample section of image. Sample corresponding secion from CPPN. # lets try a VAE first. # goal is unsupervised. gradient descent back from input image to latent space to get code variables. # adversarial there is no linking between the two. imgs, labels = data.get_inputs(batch_size=10) def linear(input_, output_size, scope=None, stddev=0.02, bias_start=0.0, with_w=False): shape = input_.get_shape().as_list() with tf.variable_scope(scope or "Linear"): matrix = tf.get_variable("Matrix", [shape[1], output_size], tf.float32, tf.random_normal_initializer(stddev=stddev)) bias = tf.get_variable("bias", [output_size], initializer=tf.constant_initializer(bias_start)) if with_w: return tf.matmul(input_, matrix) + bias, matrix, bias else: return tf.matmul(input_, matrix) + bias def sample_img(img, n_samples):
with arg_scope([conv2d, conv2d_transpose], batch_norm_params=batch_norm_params, stddev=0.02): z = z*2-1 d = 8 z = fc(z, num_units_out=d*d*32, batch_norm_params=batch_norm_params) c = z.get_shape()[1].value / (d*d) z = tf.reshape(z, (-1, d, d, c)) o = conv2d_transpose(z, n, (3, 3), stride=(2, 2)) o = conv2d_transpose(o, n, (3, 3), stride=(2, 2)) o = conv2d(o, num_filters_out=n*2, kernel_size=(3, 3), stride=1) o = conv2d(o, num_filters_out=1, kernel_size=(3, 3), stride=1, padding="VALID", batch_norm_params=None) out = o[:, 1:29, 1:29, :] return out with tf.variable_scope("data"): images, _ = data.get_inputs(128) with tf.variable_scope("generator") as gen_scope: z = tf.random_uniform([128, 16*8], 0, 1) generated = generator(z) gen_scope.reuse_variables() gen_vars = [x for x in tf.trainable_variables() if x.name.startswith(gen_scope.name)] with tf.variable_scope("discriminator") as scope: real_probs = discriminator(images) with tf.variable_scope("discriminator", reuse=True) as scope: fake_probs = discriminator(generated) dis_vars = [x for x in tf.trainable_variables() if x.name.startswith(scope.name)]