def pcbmake(self, pid): if(pid in self.pids): pass else: #This is if the process has not been recorded yet self.pcb.append((pid, process(pid))) self.pids.append(pid)
def forward(self, x): x = self.fc1(x) x = torch.sigmoid(x) x = self.fc2(x) x = torch.sigmoid(x) return x from PimaDataset import test_loader, getTrainLoaders, getDropLoaders batch_size = 1 epochs = 5 log_interval = 0 from Model import Model, process res = '' train_loaders = getTrainLoaders(batch_size, True) for k in train_loaders: print(k) train_loader = train_loaders[k] res += process(k, Net, train_loader, test_loader) print('drop') train_loaders, test_loaders = getDropLoaders(batch_size, True) train_loader, test_loader = train_loaders['drop'], test_loaders['drop'] res += process("drop", Net, train_loader, test_loader) res = res[0:-1] + ','
super(Net, self).__init__() self.fc1 = nn.Linear(6, 10) self.fc2 = nn.Linear(10, 1) self.dropout = nn.Dropout(p=0.5) def forward(self, x): x = self.fc1(x) x = torch.sigmoid(x) x = self.dropout(x) x = self.fc2(x) x = torch.sigmoid(x) return x from PimaDataset import test_loader, getTrainLoaders, getDropLoaders batch_size = 1 epochs = 5 log_interval = 0 from Model import Model, process res = '' print('dropIS') train_loaders, test_loaders = getDropLoaders(batch_size, True) train_loader, test_loader = train_loaders['dropIS'], test_loaders['dropIS'] res += process("dropIS", Net, train_loader, test_loader) res = res[0:-1] + ','
def main(): parser = argparse.ArgumentParser() parser.add_argument( '-s', '--sample', type=str, default='', help='Samples based on input song. Empty string means training.') parser.add_argument('-c', '--concat', dest='concat', action='store_true', help='Enable concatenation.') parser.add_argument('--no-concat', dest='concat', action='store_false', help='Disable concatenation.') parser.set_defaults(concat=False) parser.add_argument('-r', '--record', dest='record', action='store_true', help='Enable recording.') parser.add_argument('--no-record', dest='record', action='store_false', help='Disable recording.') parser.set_defaults( record=False) # Warning: Windows kills python if enabled. args = parser.parse_args() sampling = args.sample != '' if not os.path.exists('Checkpoints_v1'): os.makedirs('Checkpoints_v1') if not os.path.exists('Logs_v1'): os.makedirs('Logs_v1') if not os.path.exists('Samples_v1'): os.makedirs('Samples_v1') if not os.path.exists('Timelines_v1'): os.makedirs('Timelines_v1') filename = 'Dataset/cond_dataset.tfrecord' dataset = tf.data.TFRecordDataset(filename, num_parallel_reads=8) def _parse(example_proto): feature = { 'label': tf.FixedLenFeature([], tf.int64), 'data': tf.FixedLenFeature([], tf.string) } parsed = tf.parse_single_example(example_proto, feature) data = tf.decode_raw(parsed['data'], tf.uint8) label = tf.cast(parsed['label'], tf.uint8) data = tf.py_func(func=np.unpackbits, inp=[data], Tout=tf.uint8) label = tf.py_func(func=np.unpackbits, inp=[label], Tout=tf.uint8) data = tf.cast(data, tf.float32) label = tf.cast(label, tf.float32) data = tf.reshape(data, [CHANNEL_NUM, CLASS_NUM, INPUT_LENGTH]) label.set_shape([8]) label = label[:CHANNEL_NUM] label = tf.expand_dims(tf.expand_dims(label, axis=-1), axis=-1) data = data * 2 - 1 return {'data': data, 'label': label} dataset = dataset.apply(data.shuffle_and_repeat(buffer_size=16384)) dataset = dataset.apply( data.map_and_batch(_parse, batch_size=BATCH_SIZE, num_parallel_batches=16, drop_remainder=True)) dataset = dataset.prefetch(32) dataset = dataset.apply(data.prefetch_to_device('/gpu:0')) iterator = dataset.make_one_shot_iterator() next_data = iterator.get_next() real_input_3 = next_data['data'] label = next_data['label'] input_noise = tf.placeholder(dtype=tf.float32, shape=[None, NOISE_LENGTH], name='input_noise') real_input_2 = tf.layers.average_pooling2d(inputs=real_input_3, pool_size=2, strides=2, padding='same', data_format='channels_first', name='real_input_2') real_input_2 -= tf.reduce_min(real_input_2) real_input_2 /= (tf.reduce_max(real_input_2) + EPSILON) real_input_2 = 2 * real_input_2 - 1 real_input_1 = tf.layers.average_pooling2d(inputs=real_input_2, pool_size=2, strides=2, padding='same', data_format='channels_first', name='real_input_1') real_input_1 -= tf.reduce_min(real_input_1) real_input_1 /= (tf.reduce_max(real_input_1) + EPSILON) real_input_1 = 2 * real_input_1 - 1 train = tf.placeholder(dtype=tf.bool, name='train') # shape: [None, 6, 64, 256] encode = encoder(inputs=real_input_3, update_collection=SPECTRAL_UPDATE_OPS, train=train) # shape: [None, 64] tf.summary.histogram('encode', encode) print('Encoder set') real_input_3_image = tf.expand_dims(real_input_3[:1], axis=-1, name='real_input_3_image') # shape: [1, 6, 128, 512, 1] real_input_2_image = tf.expand_dims(real_input_2[:1], axis=-1, name='real_input_2_image') # shape: [1, 6, 64, 256, 1] real_input_1_image = tf.expand_dims(real_input_1[:1], axis=-1, name='real_input_1_image') # shape: [1, 6, 32, 128, 1] for i in range(CHANNEL_NUM): tf.summary.image('real_input_1_%d' % i, real_input_1_image[:, i]) tf.summary.image('real_input_2_%d' % i, real_input_2_image[:, i]) tf.summary.image('real_input_3_%d' % i, real_input_3_image[:, i]) shared_output = shared_gen(noise=input_noise, label=label, update_collection=SPECTRAL_UPDATE_OPS, train=train) # shape: [None, 64, 16, 64] gen1 = generator1(inputs=shared_output, label=label, update_collection=SPECTRAL_UPDATE_OPS, train=train) output_gen1 = process(gen1, 1, train, SPECTRAL_UPDATE_OPS) * label # shape: [None, 6, 32, 128] gen2 = generator2(inputs=gen1, label=label, update_collection=SPECTRAL_UPDATE_OPS, train=train) output_gen2 = process(gen2, 2, train, SPECTRAL_UPDATE_OPS) * label # shape: [None, 6, 64, 256] gen3 = generator3(inputs=gen2, label=label, update_collection=SPECTRAL_UPDATE_OPS, train=train) output_gen3 = process(gen3, 3, train, SPECTRAL_UPDATE_OPS) * label # shape: [None, 6, 128, 512] print('Generators set') dis1_real = discriminator1(inputs=real_input_1, encode=encode, update_collection=SPECTRAL_UPDATE_OPS) dis1_gen = discriminator1(inputs=output_gen1, encode=encode, update_collection=NO_OPS) dis2_real = discriminator2(inputs=real_input_2, encode=encode, update_collection=SPECTRAL_UPDATE_OPS) dis2_gen = discriminator2(inputs=output_gen2, encode=encode, update_collection=NO_OPS) dis3_real = discriminator3(inputs=real_input_3, encode=encode, update_collection=SPECTRAL_UPDATE_OPS) dis3_gen = discriminator3(inputs=output_gen3, encode=encode, update_collection=NO_OPS) print('Discriminators set') loss_dis1 = tf.reduce_mean(dis1_gen - dis1_real) + lipschitz_penalty( real=real_input_1, gen=output_gen1, encode=encode, discriminator=discriminator1) + DRIFT * tf.reduce_mean( tf.square(dis1_real)) loss_gen1 = -tf.reduce_mean(dis1_gen) loss_dis2 = tf.reduce_mean(dis2_gen - dis2_real) + lipschitz_penalty( real=real_input_2, gen=output_gen2, encode=encode, discriminator=discriminator2) + DRIFT * tf.reduce_mean( tf.square(dis2_real)) loss_gen2 = -tf.reduce_mean(dis2_gen) loss_dis3 = tf.reduce_mean(dis3_gen - dis3_real) + lipschitz_penalty( real=real_input_3, gen=output_gen3, encode=encode, discriminator=discriminator3) + DRIFT * tf.reduce_mean( tf.square(dis3_real)) loss_gen3 = -tf.reduce_mean(dis3_gen) loss_gen = tf.add_n([loss_gen1, loss_gen2, loss_gen3]) / 3 tf.summary.scalar('loss_dis1', loss_dis1) tf.summary.scalar('loss_gen1', loss_gen1) tf.summary.scalar('dis1_real', tf.reduce_mean(dis1_real)) tf.summary.scalar('loss_dis2', loss_dis2) tf.summary.scalar('loss_gen2', loss_gen2) tf.summary.scalar('dis2_real', tf.reduce_mean(dis2_real)) tf.summary.scalar('loss_dis3', loss_dis3) tf.summary.scalar('loss_gen3', loss_gen3) tf.summary.scalar('dis3_real', tf.reduce_mean(dis3_real)) tf.summary.scalar('loss_gen', loss_gen) print('Losses set') gen_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Shared_generator') #gen_var += tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Encoder') for i in range(CHANNEL_NUM): gen_var += tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Generator1_%d' % i) gen_var += tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Generator2_%d' % i) gen_var += tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Generator3_%d' % i) dis1_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Discriminator1') dis1_var += tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Encoder') dis2_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Discriminator2') dis2_var += tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Encoder') dis3_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Discriminator3') dis3_var += tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Encoder') gen_extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Shared_generator') #gen_extra_update_ops += tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Encoder') for i in range(CHANNEL_NUM): gen_extra_update_ops += tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Generator1_%d' % i) gen_extra_update_ops += tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Generator2_%d' % i) gen_extra_update_ops += tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Generator3_%d' % i) dis1_extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Discriminator1') dis1_extra_update_ops += tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Encoder') dis2_extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Discriminator2') dis2_extra_update_ops += tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Encoder') dis3_extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Discriminator3') dis3_extra_update_ops += tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='Encoder') spectral_norm_update_ops = tf.get_collection(SPECTRAL_UPDATE_OPS) with tf.name_scope('optimizers'): with tf.control_dependencies(dis1_extra_update_ops): dis1_train = tf.train.AdamOptimizer(learning_rate=0.0004, beta1=0.5, beta2=0.9).minimize( loss=loss_dis1, var_list=dis1_var, name='dis1_train') print('dis1_train setup') with tf.control_dependencies(dis2_extra_update_ops): dis2_train = tf.train.AdamOptimizer(learning_rate=0.0004, beta1=0.5, beta2=0.9).minimize( loss=loss_dis2, var_list=dis2_var, name='dis2_train') print('dis2_train setup') with tf.control_dependencies(dis3_extra_update_ops): dis3_train = tf.train.AdamOptimizer(learning_rate=0.0004, beta1=0.5, beta2=0.9).minimize( loss=loss_dis3, var_list=dis3_var, name='dis3_train') print('dis3_train setup') with tf.control_dependencies(gen_extra_update_ops): gen_train = tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.5, beta2=0.9).minimize( loss=loss_gen, var_list=gen_var, name='gen_train') print('gen_train setup') print('Optimizers set') gpu_options = tf.GPUOptions(allow_growth=True, allocator_type='BFC') config = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options) saver = tf.train.Saver() with tf.Session(config=config) as sess: merged = tf.summary.merge_all() sess.run(tf.global_variables_initializer()) if tf.train.latest_checkpoint('Checkpoints_v1') is not None: print('Restoring...') saver.restore(sess, tf.train.latest_checkpoint('Checkpoints_v1')) feed_dict = {input_noise: None, train: True} print('preparing complete') if sampling: feed_dict = {input_noise: None, real_input_3: None, train: False} path = args.sample try: feed_dict[real_input_3] = roll(path)[:BATCH_SIZE] except: print('Error while opening file.') exit() feed_dict[input_noise] = get_noise([BATCH_SIZE, NOISE_LENGTH]) samples = sess.run(output_gen3, feed_dict=feed_dict) path = path.split('/')[-1] if not os.path.exists('Samples_v1/sample_%s'): os.mkdir('Samples_v1/sample_%s' % path) np.save(file='Samples_v1/sample_%s' % path + '/%s' % path, arr=samples) unpack_sample(name='Samples_v1/sample_%s' % path + '/%s.npy' % path, concat=args.concat) exit() writer = tf.summary.FileWriter('Logs_v1', sess.graph) run_options = tf.RunOptions(report_tensor_allocations_upon_oom=True) epoch_num = 100001 for train_count in tqdm(range(epoch_num), smoothing=0.7): for i in range(TRAIN_RATIO_DIS): feed_dict[input_noise] = get_noise([BATCH_SIZE, NOISE_LENGTH]) feed_dict[train] = True *_, loss_val_dis1, loss_val_dis2, loss_val_dis3 = sess.run( [ dis1_train, dis2_train, dis3_train, loss_dis1, loss_dis2, loss_dis3 ], feed_dict=feed_dict, options=run_options) for i in range(TRAIN_RATIO_GEN): feed_dict[input_noise] = get_noise([BATCH_SIZE, NOISE_LENGTH]) feed_dict[train] = True summary, _, loss_val_gen = sess.run( [merged, gen_train, loss_gen], feed_dict=feed_dict, options=run_options) sess.run(spectral_norm_update_ops) writer.add_summary(summary, train_count) tqdm.write('%06d' % train_count, end=' ') tqdm.write('Discriminator1 loss : %.7f' % loss_val_dis1, end=' ') tqdm.write('Discriminator2 loss : %.7f' % loss_val_dis2, end=' ') tqdm.write('Discriminator3 loss : %.7f' % loss_val_dis3, end=' ') tqdm.write('Generator loss : %.7f' % loss_val_gen) if train_count % 1000 == 0: feed_dict[input_noise] = get_noise([BATCH_SIZE, NOISE_LENGTH]) feed_dict[train] = False samples = sess.run(output_gen3, feed_dict=feed_dict) np.save(file='Samples_v1/song_%06d' % train_count, arr=samples) unpack_sample('Samples_v1/song_%06d' % train_count) save_path = saver.save( sess, 'Checkpoints_v1/song_%06d' % train_count + '.ckpt') tqdm.write('Model Saved: %s' % save_path) if args.record: trace_options = tf.RunOptions( trace_level=tf.RunOptions.FULL_TRACE) # pylint: disable=E1101 run_metadata = tf.RunMetadata() sess.run([dis1_train, dis2_train, dis3_train, gen_train], feed_dict=feed_dict, options=trace_options, run_metadata=run_metadata) writer.add_run_metadata(run_metadata, 'run_%d' % train_count) tl = timeline.Timeline(run_metadata.step_stats) # pylint: disable=E1101 ctf = tl.generate_chrome_trace_format() with open('Timelines_v1/timeline_%d.json' % train_count, 'w') as f: f.write(ctf) writer.close()