def post(self): fields = ["username", "email"] q_args = ["username", "password"] args = utils.gen_fields(reqparse.RequestParser(), q_args) for arg in q_args: if arg not in args: return en_us.BAD_REQUEST if args[arg] == None or args[arg] == "": return en_us.BAD_REQUEST m_length = 0 users = None for field in fields: length = len(utils.encoder(utils.col.find({field: args['username']}))) if length > m_length: m_length = length users = utils.encoder(utils.col.find({field: args['username']})) if m_length == 0: return en_us.NOT_FOUND user = utils.encoder(users)[0] if not auth.check_password(args['password'], user['password']): return en_us.AUTH_FAILED user.update({"token": auth.generate(user)}) return auth.user(user), 200
def post(self): args = utils.gen_fields(reqparse.RequestParser(), ['username', 'password']) fields = ["username", "email"] m_length = 0 users = None for field in fields: length = len( utils.encoder(utils.col.find({field: args['username']}))) if length > m_length: m_length = length users = utils.encoder(utils.col.find({field: args['username']})) if m_length == 0: return en_us.NOT_FOUND user = utils.encoder(users)[0] if not auth.check_password(args['password'], user['password']): return en_us.AUTH_FAILED user.update({"token": auth.generate(user)}) return auth.user(user), 200
def get(self, client_id): request_token = request.headers.get('authorization') auth_status = auth.verify(client_id, request_token) if auth_status != 200: return auth_status user = utils.encoder(utils.col.find({"id": client_id}))[0] return auth.user(utils.encoder(user))
def post(self, clientid, key): cur_time = int(time.time()) user = utils.col.find({"id": clientid}) if user.count() == 0: return en_us.AUTH_FAILED user = utils.encoder(user)[0] secret = user["salt"] try: enterance_payload = jwt.decode(key, secret, algorithms=["HS256"]) except jwt.exceptions.DecodeError: return en_us.AUTH_FAILED if enterance_payload["expiration"] < cur_time: return en_us.AUTH_FAILED if enterance_payload['user'] != clientid: return en_us.AUTH_FAILED # good to go reset the password, but what is the password? args = utils.gen_fields(reqparse.RequestParser(), ['password']) if args["password"] == "" or args["password"] == None: return en_us.BAD_REQUEST utils.col.update( {"id": clientid}, {"$set": { "password": auth.make_password(args["password"]) }})
def __init__(self, hidden_size, batch_size, learning_rate): self.input_tensor = tf.placeholder(tf.float32, [None, 28 * 28]) with arg_scope([layers.conv2d, layers.conv2d_transpose], activation_fn=tf.nn.elu, normalizer_fn=layers.batch_norm, normalizer_params={'scale': True}): with tf.variable_scope('model') as scope: encoded = encoder(self.input_tensor, hidden_size * 2) mean = encoded[:, :hidden_size] stddev = tf.sqrt(tf.exp(encoded[:, hidden_size:])) epsilon = tf.random_normal([tf.shape(mean)[0], hidden_size]) input_sample = mean + epsilon * stddev output_tensor = decoder(input_sample) with tf.variable_scope('model', reuse=True) as scope: self.sampled_tensor = decoder( tf.random_normal([batch_size, hidden_size])) vae_loss = self.__get_vae_cost(mean, stddev) rec_loss = self.__get_reconstruction_cost(output_tensor, self.input_tensor) loss = vae_loss + rec_loss self.train = layers.optimize_loss(loss, get_or_create_global_step(), learning_rate=learning_rate, optimizer='Adam', update_ops=[]) self.sess = tf.Session() self.sess.run(tf.global_variables_initializer())
def post(self): q_args = ["username", "email", "password"] args = utils.gen_fields(reqparse.RequestParser(), q_args) same_email = utils.col.find({"email": args['email']}) same_username = utils.col.find({"username": args['username']}) for arg in q_args: if arg not in args: return en_us.BAD_REQUEST if args[arg] == None or args[arg] == "": return en_us.BAD_REQUEST if same_email.count() > 0: return en_us.EMAIL_EXISTS if same_username.count() > 0: return en_us.UNAME_EXISTS user = { "username": args['username'], "email": args['email'], "password": auth.make_password(args['password']), "id": account_utils.get_user_id(), "time_created": int(time.time()) } user.update({"salt": auth.salt()}) utils.col.insert(user) user.update({"token": auth.generate(user)}) return auth.user(utils.encoder(user)), 201
def get(self, client_id): request_token = request.headers.get('authorization') auth_status = auth.verify(client_id, request_token) if auth_status != 200: return auth_status return utils.encoder(utils.get_all_services(client_id))
def password_reset(identification): x = utils.col.find({"username": identification}) y = utils.col.find({"email": identification}) z = utils.col.find({"id": identification}) user = None if x.count() > 0: user = x elif y.count() > 0: user = y elif z.count() > 0: user = z if user == None: return 404 # not found # get the single user out of the array it's returned in user = utils.encoder(user)[0] email = user["email"] userid = user["id"] encoded_jwt = jwt.encode({'expiration': int( time.time()) + 600, 'user': userid}, user["salt"], algorithm='HS256') encoded_jwt = encoded_jwt.decode('utf-8') e_tem = template( email, f"https://driplet.cf/reset?={encoded_jwt}&user={userid}") s = r.post( "https://api.sendgrid.com/v3/mail/send", json=e_tem, headers={ "Authorization": "Bearer " + os.getenv("API_KEY"), "Content-Type": "application/json" } ) if s.status_code != 202: return 400
def generate(user): mem_user = copy(user) mem_user.pop('salt') mem_user.pop('_id') mem_user.pop('password') token = jwt.encode(utils.encoder(mem_user), user['salt'] + user['password'], algorithm='HS256') return token.decode('utf-8')
def get(self, client_id, service_id): request_token = request.headers.get('authorization') auth_status = auth.verify(client_id, request_token) if auth_status != 200: return auth_status service = utils.get_service(client_id, service_id) if service.count() == 0: return en_us.SERVICE_NOT_FOUND return utils.encoder(service[0])
def verify(client_id, token): user = utils.encoder(utils.col.find({"id": client_id}))[0] if user == None: return en_us.NOT_FOUND try: payload = jwt.decode(token, user['salt'] + user['password'], algorithms=['HS256']) except: return en_us.AUTH_FAILED if 'id' in payload: if payload['id'] == user['id']: return 200 return en_us.AUTH_FAILED
def _process_wav(file_list, outfile, winlen, winstep, n_mcep, mcep_alpha, minf0, maxf0, q_channels, type): data_dict = {} enc = encoder(q_channels) for f in tqdm(file_list): wav, sr = load(f, sr=None) x = wav.astype(float) _f0, t = world.harvest(x, sr, f0_floor=minf0, f0_ceil=maxf0, frame_period=winstep * 1000) # can't adjust window size f0 = world.stonemask(x, _f0, t, sr) window_size = int(sr * winlen) hop_size = int(sr * winstep) # get mel if type == 'mcc': nfft = 2**(window_size - 1).bit_length() spec = np.abs( stft(x, n_fft=nfft, hop_length=hop_size, win_length=window_size, window='blackman'))**2 h = sptk.mcep(spec, n_mcep - 1, mcep_alpha, eps=-60, etype=2, itype=4).T else: h = mfcc(x, sr, n_mfcc=n_mcep, n_fft=int(sr * winlen), hop_length=int(sr * winstep)) h = np.vstack((h, f0)) # mulaw encode wav = enc(x).astype(np.uint8) id = os.path.basename(f).replace(".wav", "") data_dict[id] = wav data_dict[id + "_h"] = h np.savez(outfile, **data_dict)
def post(self, client_id, service_id): request_token = request.headers.get('authorization') auth_status = auth.verify(client_id, request_token) if auth_status != 200: return auth_status service = utils.get_service(client_id, service_id) if service.count() == 0: return en_us.NOT_FOUND command = { "serviceid": service_id, "content": utils.encoder(service)[0]['restart_command'] } command = json.dumps(command) pub(command.encode('utf-8')) return "", 204
def preprocess_cmu(wav_dir, output, *, q_channels, winlen, winstep, n_mcep, mcep_alpha, minf0, maxf0, type): in_dir = os.path.join(wav_dir) out_dir = os.path.join(output) train_data = os.path.join(out_dir, 'train.npz') test_data = os.path.join(out_dir, 'test.npz') os.makedirs(out_dir, exist_ok=True) files = [os.path.join(in_dir, f) for f in os.listdir(in_dir)] files.sort() train_files = files[:1032] test_files = files[1032:] feature_fn = partial(get_features, winlen=winlen, winstep=winstep, n_mcep=n_mcep, mcep_alpha=mcep_alpha, minf0=minf0, maxf0=maxf0, type=type) n_workers = cpu_count() // 2 print("Running", n_workers, "processes.") data_dict = {} enc = encoder(q_channels) print("Processing training data ...") with ProcessPoolExecutor(n_workers) as executor: futures = [executor.submit(feature_fn, f) for f in train_files] for future in tqdm(futures): name, data, feature = future.result() data_dict[name] = enc(data).astype(np.uint8) data_dict[name + '_h'] = feature np.savez(train_data, **data_dict) data_dict = {} print("Processing test data ...") with ProcessPoolExecutor(n_workers) as executor: futures = [executor.submit(feature_fn, f) for f in test_files] for future in tqdm(futures): name, data, feature = future.result() data_dict[name] = enc(data).astype(np.uint8) data_dict[name + '_h'] = feature np.savez(test_data, **data_dict) calc_stats(train_data, out_dir)
def patch(self, client_id): request_token = request.headers.get('authorization') auth_status = auth.verify(client_id, request_token) if auth_status != 200: return auth_status args = utils.gen_fields(reqparse.RequestParser(), ['username', 'email', 'password']) updates = {} for key in args: if key == "password": args[key] = auth.make_password(args[key]) if args[key] != None: updates.update({key: args[key]}) utils.col.update({'id': client_id}, {"$set": updates}, upsert=False) user = utils.encoder(utils.col.find({"id": client_id}))[0] return auth.user(user), 200
def __init__(self, hidden_size, batch_size, learning_rate, size): img_size = size[0] * size[1] * size[2] self.input_tensor = tf.placeholder(tf.float32, [batch_size, img_size]) with arg_scope([layers.conv2d, layers.conv2d_transpose], activation_fn=tf.nn.elu, normalizer_fn=layers.batch_norm, normalizer_params={'scale': True}): with tf.variable_scope("model") as scope: encoded = encoder(self.input_tensor, hidden_size * 2, size) mean = encoded[:, :hidden_size] stddev = tf.sqrt(tf.exp(encoded[:, hidden_size:])) epsilon = tf.random_normal([tf.shape(mean)[0], hidden_size]) input_sample = mean + epsilon * stddev output_tensor = decoder(input_sample, img_size) with tf.variable_scope("model", reuse=True) as scope: self.sampled_tensor = decoder( tf.random_normal([batch_size, hidden_size]), img_size) self.recons_tensor = output_tensor vae_loss = self.__get_vae_cost(mean, stddev) rec_loss = self.__get_reconstruction_cost( output_tensor, self.input_tensor) # output_tensor: y input_tensor: x loss = vae_loss + rec_loss # loss = vae_loss + rec_loss self.train = layers.optimize_loss( loss, tf.contrib.framework.get_or_create_global_step(), learning_rate=learning_rate, optimizer='Adam', update_ops=[]) # opt = tf.train.AdamOptimizer(2e-4, beta1=0.5) # self.train = opt.minimize(loss) self.sess = tf.Session() self.sess.run(tf.global_variables_initializer())
def post(self, client_id): request_token = request.headers.get('authorization') auth_status = auth.verify(client_id, request_token) if auth_status != 200: return auth_status args = utils.gen_fields(reqparse.RequestParser(), ['name', 'description', 'start_command', 'stop_command', 'restart_command', 'status_command', 'log_command']) service = args service.update( { "id": services_util.new_id(), "associated_to": client_id, "logs": [] } ) utils.services.insert(service) return utils.encoder(service), 201
'logs', name), histogram_freq=1) checkpoint = callbacks.ModelCheckpoint(os.path.join(pathlib.Path().absolute(), 'checkpoints', name, 'model'), save_best_only=True, save_weights_only=True) for i in trange(n_splits, total=n_splits, desc='Splits', unit='split'): train_images, train_labels, test_images, test_labels, result = [None] * 5 ds_data = [] ds_labels = [] files = dataset_files[i::n_splits] for file in tqdm(files, unit='examples', total=dataset_length): ds_labels.append(encoder(pattern.search(file.name).group(1))) ds_data.append( np.array(Image.open(file.path), dtype=np.uint8).reshape( (128, 64, 1)) / 255) files = None (train_images, train_labels), (test_images, test_labels) = ((np.array(ds_data[:split]), np.array(ds_labels[:split])), (np.array(ds_data[split:]), np.array(ds_labels[split:]))) ds_data, ds_labels = None, None model.fit(train_images, train_labels,
t = time.time() if opt.generate: data_all = [ pool.apply_async(generate_data, args=(opt.data_type, opt.encoding)) for i in range(num_samples) ] # data = generate_data(data_type=opt.data_type, # encode=opt.encoding) if opt.encoding: for data in data_all: raw_data.append(data.get()) encoded_data.extend( encoder(data.get(), imageSize, 200 * pq.ms, 20, fill=0.0)) else: for i, data in enumerate(data_all): dat = data[0].to_array().ravel() raw_data.append(data[1]) # Reshape to required format dat = dat.reshape((1, imageSize, imageSize)) binned_data[i] = dat # Normalize data dat = np.divide(dat, np.max(dat)) # data = (data - data.mean()) / data.std() norm_data[i] = dat else: # TODO load data
def __init__(self, input_size, hidden_size, batch_size, learning_rate, log_dir): self.input_tensor = tf.placeholder(tf.float32, [None, 3 * input_size]) self.s_t_p_placeholder = tf.placeholder(tf.float32, [None, hidden_size]) ''' ################################## with open('params.txt') as f: first = f.readline() first = first.strip('\n') temp = first.split(' ') o_p_dim = int(temp[3]); s_p_dim = int(temp[4]); ln = f.readline() for i in range(s_p_dim): temp = f.readline() self.sig_2_init = np.zeros((s_p_dim, s_p_dim), np.float32) for i in range(s_p_dim): temp = f.readline().strip('\n').split(' ') for j in range(s_p_dim): self.sig_2_init[i,j] = float(temp[j]) eig_val , eig_vec = np.linalg.eig(self.sig_2_init) cf = np.sqrt(np.repeat(eig_val,s_p_dim).reshape(s_p_dim,s_p_dim).transpose()) self.r_2_init = np.multiply(cf,eig_vec) self.sig_3_init = np.zeros((o_p_dim, o_p_dim), np.float32) for i in range(o_p_dim): temp = f.readline().strip('\n').split(' ') for j in range(o_p_dim): self.sig_3_init[i,j] = float(temp[j]) eig_val , eig_vec = np.linalg.eig(self.sig_3_init) cf = np.sqrt(np.repeat(eig_val,o_p_dim).reshape(o_p_dim,o_p_dim).transpose()) self.r_3_init = np.multiply(cf,eig_vec) self.a_2_init = np.zeros((s_p_dim, s_p_dim), np.float32) for i in range(s_p_dim): temp = f.readline().strip('\n').split(' ') for j in range(s_p_dim): self.a_2_init[i,j] = float(temp[j]) self.a_3_init = np.zeros((s_p_dim, o_p_dim), np.float32) for i in range(s_p_dim): temp = f.readline().strip('\n').split(' ') for j in range(o_p_dim): self.a_3_init[i,j] = float(temp[j]) ################################### ''' with arg_scope([layers.fully_connected], activation_fn=tf.nn.relu): with tf.variable_scope("encoder"): with tf.variable_scope("encoder_s_t"): self.s_t_minus_1_p = encoder(self.input_tensor[:, :input_size],\ hidden_size) with tf.variable_scope("encoder_s_t", reuse=True): self.s_t_p = encoder(self.input_tensor[:, input_size:2 * input_size],\ hidden_size) with tf.variable_scope("encoder_o_t"): self.o_t_p = encoder(self.input_tensor[:, 2 * input_size:],\ hidden_size) with tf.variable_scope("decoder"): with tf.variable_scope("decoder_s_t"): self.output_s_t_minus_1 = decoder(self.s_t_minus_1_p, input_size) with tf.variable_scope("decoder_s_t", reuse=True): self.output_s_t = decoder(self.s_t_p, input_size) with tf.variable_scope("decoder_s_t", reuse=True): self.s_t_decoded = decoder(self.s_t_p_placeholder, input_size) with tf.variable_scope("decoder_o_t"): self.output_o_t = decoder(self.o_t_p, input_size) self.output_tensor = tf.concat( [self.output_s_t_minus_1, self.output_s_t, self.output_o_t], axis=1) #self.a_2, self.b_2, self.sigma_2, self.a_3, self.b_3, self.sigma_3 = self._MLE_Gaussian_params() self.a_2, self.b_2, self.sigma_2, self.a_3, self.b_3, self.sigma_3 = self._simple_Gaussian_params( ) #self.a_2, self.b_2, self.sigma_2, self.a_3, self.b_3, self.sigma_3 = self._simple_Gaussian_plus_offset_params() self.r_2 = tf.cholesky(self.sigma_2) self.r_3 = tf.cholesky(self.sigma_3) #define reconstruction loss reconstruction_loss = tf.reduce_mean(tf.norm(self.output_tensor - \ self.input_tensor, axis=1)) # define classification loss y_1 = self.s_t_p - tf.matmul(self.s_t_minus_1_p, self.a_2) mvn_1 = tf.contrib.distributions.MultivariateNormalFull( self.b_2, self.sigma_2) #mvn_1 = tf.contrib.distributions.MultivariateNormalTrill(self.b_2, scale_tril=self.r_2) pos_samples_1 = mvn_1.sample(batch_size) y_2 = self.o_t_p - tf.matmul(self.s_t_p, self.a_3) #mvn_2 = tf.contrib.distributions.MultivariateNormalTriL(self.b_3, scale_tril=self.r_3) mvn_2 = tf.contrib.distributions.MultivariateNormalFull( self.b_3, self.sigma_3) pos_samples_2 = mvn_2.sample(batch_size) with tf.variable_scope('discriminator'): with tf.variable_scope('d1'): pos_samples_1_pred = discriminator(pos_samples_1) with tf.variable_scope('d1', reuse=True): neg_samples_1_pred = discriminator(y_1) with tf.variable_scope('d2'): pos_samples_2_pred = discriminator(pos_samples_2) with tf.variable_scope('d2', reuse=True): neg_samples_2_pred = discriminator(y_2) classification_loss_1 = compute_classification_loss( pos_samples_1_pred, neg_samples_1_pred) classification_loss_2 = compute_classification_loss( pos_samples_2_pred, neg_samples_2_pred) classification_loss = classification_loss_1 + classification_loss_2 # define s_t likelihood s_diff = self.s_t_p - tf.matmul(self.s_t_minus_1_p, self.a_2) s_t_likelihood = tf.reduce_sum(mvn_1.log_prob(s_diff)) # define o_t likelihood o_diff = self.o_t_p - tf.matmul(self.s_t_p, self.a_3) o_t_likelihood = tf.reduce_sum(mvn_2.log_prob(o_diff)) self.likelihood = s_t_likelihood + o_t_likelihood # add summary ops tf.summary.scalar('likelihood', self.likelihood) tf.summary.scalar('s_t_likelihood', s_t_likelihood) tf.summary.scalar('o_t_likelihood', o_t_likelihood) tf.summary.scalar('classification_loss', classification_loss) tf.summary.scalar('classification_loss_1', classification_loss_1) tf.summary.scalar('classification_loss_2', classification_loss_2) tf.summary.scalar('reconstruction_loss', reconstruction_loss) # define references to params encoder_params = tf.get_collection( tf.GraphKeys.TRAINABLE_VARIABLES, scope='encoder') decoder_params = tf.get_collection( tf.GraphKeys.TRAINABLE_VARIABLES, scope='decoder') autoencoder_params = encoder_params + decoder_params gaussian_params = [self.a_2, self.a_3, self.r_2, self.r_3] discriminator_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, \ scope='discriminator') global_step = tf.contrib.framework.get_or_create_global_step() # define training steps self.learn_rate = self._get_learn_rate(global_step, learning_rate) # update autoencoder params to minimise reconstruction loss self.train_autoencoder = layers.optimize_loss(reconstruction_loss, \ global_step, self.learn_rate * 0.1, optimizer=lambda lr: \ tf.train.AdamOptimizer(lr), variables=\ #tf.train.MomentumOptimizer(lr, 0.9), variables=\ autoencoder_params, update_ops=[]) # update discriminator self.train_discriminator = layers.optimize_loss(classification_loss, \ global_step, self.learn_rate * 10, optimizer=lambda lr: \ tf.train.MomentumOptimizer(lr, 0.1), variables=\ #tf.train.AdamOptimizer(lr), variables=\ discriminator_params, update_ops=[]) # update encoder params to fool the discriminator self.train_encoder = layers.optimize_loss(-classification_loss, \ global_step, self.learn_rate , optimizer=lambda lr: \ #tf.train.MomentumOptimizer(lr, 0.9), variables=\ tf.train.AdamOptimizer(lr), variables=\ encoder_params, update_ops=[]) self.sess = tf.Session() self.merged = tf.summary.merge_all() self.train_writer = tf.summary.FileWriter(log_dir, \ self.sess.graph) self.sess.run(tf.global_variables_initializer())
def __init__(self, hidden_size, batch_size, learning_rate): self.input_tensor = tf.placeholder(tf.float32, [None, 28 * 28]) self.xs2 = tf.placeholder(tf.float32, [None, 28 * 28]) self.dis = tf.placeholder(tf.float32, [1, None]) self.flag = tf.placeholder(tf.float32, [1, None]) with arg_scope([layers.conv2d, layers.conv2d_transpose], activation_fn=concat_elu, normalizer_fn=layers.batch_norm, normalizer_params={'scale': True}): with tf.variable_scope("model"): D1 = discriminator(self.input_tensor) # positive examples D_params_num = len(tf.trainable_variables()) encoded = encoder(self.input_tensor, hidden_size * 2) mean = encoded[:, :hidden_size] stddev = tf.sqrt(tf.square(encoded[:, hidden_size:])) epsilon = tf.random_normal([tf.shape(mean)[0], hidden_size]) input_sample = mean + epsilon * stddev # G = decoder(tf.random_normal([batch_size, hidden_size])) G_params_num = len(tf.trainable_variables()) G = decoder(input_sample) self.sampled_tensor = G with tf.variable_scope("model", reuse=True): D2 = discriminator(G) # generated examples encoded1 = encoder(self.xs2, hidden_size * 2) mean1 = encoded1[:, :hidden_size] stddev1 = tf.sqrt(tf.square(encoded1[:, hidden_size:])) epsilon1 = tf.random_normal([tf.shape(mean1)[0], hidden_size]) input_sample1 = mean1 + epsilon1 * stddev1 output_tensor1 = decoder(input_sample1) D_loss = self.__get_discrinator_loss(D1, D2) G_loss = self.__get_generator_loss(D2, mean, stddev, mean1) params = tf.trainable_variables() D_params = params[:D_params_num] G_params = params[G_params_num:] # train_discrimator = optimizer.minimize(loss=D_loss, var_list=D_params) # train_generator = optimizer.minimize(loss=G_loss, var_list=G_params) global_step = tf.contrib.framework.get_or_create_global_step() self.train_discrimator = layers.optimize_loss(D_loss, global_step, learning_rate / 10, 'Adam', variables=D_params, update_ops=[]) self.train_generator = layers.optimize_loss(G_loss, global_step, learning_rate, 'Adam', variables=G_params, update_ops=[]) self.sess = tf.Session() self.sess.run(tf.global_variables_initializer())
from utils import discriminator from sklearn.decomposition import PCA from vdpmm_maximizePlusGaussian import * from vdpmm_expectationPlusGaussian import * from sklearn import metrics hidden_size = 1 batch_size = 128 input_tensor = tf.placeholder(tf.float32, [None, 28 * 28]) xs2 = tf.placeholder(tf.float32, [None, 28 * 28]) dis = tf.placeholder(tf.float32, [1, None]) flag = tf.placeholder(tf.float32, [1, None]) with tf.variable_scope("model") as scope: encoded = encoder(input_tensor, hidden_size * 2) mean = encoded[:, :hidden_size] stddev = tf.sqrt(tf.square(encoded[:, hidden_size:])) epsilon = tf.random_normal([tf.shape(mean)[0], hidden_size]) input_sample = mean + epsilon * stddev output_tensor = decoder(input_sample) with tf.variable_scope("model") as scope: encoded1 = encoder(xs2, hidden_size * 2) mean1 = encoded1[:, :hidden_size] stddev1 = tf.sqrt(tf.square(encoded1[:, hidden_size:]))
def __init__(self, hidden_size, batch_size, learning_rate, alpha, beta, gamma, sum_dir, attri_num, add_gan=1, GAN_model="V", similarity_layer=4): print("\nInitializing model with following parameters:") print("batch_size:", batch_size, " learning_rate:", learning_rate, " alpha:", alpha, " beta:", beta, " gamma:", gamma) print("GAN_model:", GAN_model, " similarity_layer:", similarity_layer, "\n") self.input_tensor = tf.placeholder(tf.float32, [batch_size, 64, 64, 3]) #self.input_label = tf.placeholder(tf.int, [batch_size, attri_num]) self.visual_attri = tf.placeholder(tf.float32, [hidden_size]) with arg_scope([layers.conv2d, layers.conv2d_transpose], activation_fn=tf.nn.relu, normalizer_fn=layers.batch_norm, normalizer_params={'scale': True}, padding='SAME'): with tf.variable_scope("model") as scope: #Full VAEGAN structure # Encoder ENC = encoder(self.input_tensor, hidden_size * 2) Enc_params_num = len(tf.trainable_variables()) # Add noise self.mean, stddev = tf.split(1, 2, ENC) stddev = tf.sqrt(tf.exp(stddev)) epsilon = tf.random_normal( [tf.shape(self.mean)[0], hidden_size]) ENC_w_noise = self.mean + epsilon * stddev # Decoder / Generator self.DEC_of_ENC = decoder(ENC_w_noise) Enc_n_Dec_params_num = len(tf.trainable_variables()) # Discriminator if add_gan == 1: DIS_of_DEC_of_ENC = discriminator(self.DEC_of_ENC, GAN_model) Gen_dis_sum = tf.scalar_summary( 'Gen_dis_mean', tf.reduce_mean(DIS_of_DEC_of_ENC)) with tf.variable_scope( "model", reuse=True) as scope: #Computation for Recon_Loss if add_gan == 1: Real_Similarity = discriminator(self.input_tensor, GAN_model, extract=similarity_layer) Gen_Similarity = discriminator( self.DEC_of_ENC, GAN_model, extract=similarity_layer ) #+ tf.random_normal([batch_size, 8, 8, 256]) with tf.variable_scope( "model", reuse=True) as scope: #Computation for GAN_Loss if add_gan == 1: Real_in_Dis = discriminator(self.input_tensor, GAN_model) Real_dis_sum = tf.scalar_summary( 'Real_dis_mean', tf.reduce_mean(Real_in_Dis)) Prior_in_Dis = discriminator( decoder(tf.random_normal([batch_size, hidden_size])), GAN_model) Prior_dis_sum = tf.scalar_summary( 'Prior_dis_mean', tf.reduce_mean(Prior_in_Dis)) with tf.variable_scope( "model", reuse=True) as scope: #Sample from latent space self.sampled_tensor = decoder( tf.random_normal([batch_size, hidden_size])) with tf.variable_scope( "model", reuse=True) as scope: #Add visual attributes #expand_mean = tf.expand_dims(self.mean, -1) print("shape of mean:", np.shape(self.mean), " shape of visual attri:", np.shape(self.visual_attri)) add_attri = self.mean + np.ones( [batch_size, 1] ) * self.visual_attri #[batch size, hidden size] (broadcasting) print("shape of add attri:", tf.shape(add_attri)) self.with_attri_tensor = decoder(add_attri) self.params = tf.trainable_variables() self.Enc_params = self.params[:Enc_params_num] ''' print ('Encoder Param:') for var in Enc_params: print (var.name) ''' self.Dec_params = self.params[Enc_params_num:Enc_n_Dec_params_num] ''' print ('Decoder Param:') for var in Dec_params: print (var.name) ''' if add_gan == 1: self.Dis_params = self.params[Enc_n_Dec_params_num:] ''' print ('Discriminator Param:') for var in Dis_params: print (var.name) ''' self.Prior_loss = self.__get_prior_loss(self.mean, stddev) Prior_loss_sum = tf.scalar_summary('Prior_loss', self.Prior_loss) if add_gan == 1: self.Recon_loss = self.__get_reconstruction_loss( Gen_Similarity, Real_Similarity) Recon_loss_sum = tf.scalar_summary('Recon_loss', self.Recon_loss) self.GAN_loss = self.__get_GAN_loss(Real_in_Dis, Prior_in_Dis, DIS_of_DEC_of_ENC, GAN_model) GAN_loss_sum = tf.scalar_summary('GAN_loss', self.GAN_loss) else: self.Recon_loss = self.__get_reconstruction_loss( self.DEC_of_ENC, self.input_tensor) Recon_loss_sum = tf.scalar_summary('Recon_loss', self.Recon_loss) # merge summary for Tensorboard if add_gan == 1: self.detached_loss_summary_merged = tf.merge_summary([ Prior_loss_sum, Recon_loss_sum, GAN_loss_sum, Real_dis_sum, Prior_dis_sum, Gen_dis_sum ]) #self.dis_mean_value_summary_merged = tf.merge_summary([Real_dis_sum,Prior_dis_sum,Gen_dis_sum]) else: self.detached_loss_summary_merged = tf.merge_summary( [Prior_loss_sum, Recon_loss_sum]) if add_gan == 1: enc_loss = self.Prior_loss + beta * self.Recon_loss dec_loss = gamma * self.Recon_loss + self.GAN_loss dis_loss = (-1) * self.GAN_loss else: total_loss = self.Prior_loss + beta * self.Recon_loss #self.combined_loss_summary_merged = tf.merge_summary([self.prior_loss_sum,self.recon_loss_sum,self.GAN_loss_sum]) if add_gan == 1: self.train_enc = layers.optimize_loss(enc_loss, tf.contrib.framework.get_or_create_global_step(\ ), learning_rate=learning_rate, variables = self.Enc_params, optimizer='RMSProp', update_ops=[]) self.train_dec = layers.optimize_loss(dec_loss, tf.contrib.framework.get_or_create_global_step(\ ), learning_rate=learning_rate, variables = self.Dec_params, optimizer='RMSProp', update_ops=[]) self.train_dis = layers.optimize_loss(dis_loss, tf.contrib.framework.get_or_create_global_step(\ ), learning_rate=learning_rate * alpha, variables = self.Dis_params, optimizer='RMSProp', update_ops=[]) else: self.train = layers.optimize_loss(total_loss, tf.contrib.framework.get_or_create_global_step(\ ), learning_rate=learning_rate, variables = self.params, optimizer='RMSProp', update_ops=[]) config = tf.ConfigProto() config.gpu_options.allow_growth = True self.sess = tf.Session(config=config) self.sess.run(tf.initialize_all_variables()) self.train_writer = tf.train.SummaryWriter(sum_dir + '/train', self.sess.graph)
def __init__(self, model, channel_num, batch_size, seq_len, learning_rate, ws, wg, wt, phase, sum_dir): if phase == 'train' or phase == 'test': self.inputNoiseList = [tf.placeholder(tf.float32, [batch_size, 128, 128, channel_num])\ for _ in range(seq_len)] self.inputCleanList = [tf.placeholder(tf.float32, [batch_size, 128, 128, 3])\ for _ in range(seq_len)] else: self.inputNoiseList = [tf.placeholder(tf.float32, [batch_size, 416, 800, channel_num])\ for _ in range(seq_len)] self.inputCleanList = [tf.placeholder(tf.float32, [batch_size, 416, 800, 3])\ for _ in range(seq_len)] with arg_scope( [layers.conv2d], activation_fn=tf.nn.leaky_relu, #normalizer_fn=layers.batch_norm, normalizer_params={'scale': True}, padding='SAME'): with tf.variable_scope("model") as scope: #Full VAEGAN structure if phase == 'train' or phase == 'test': inpH, inpW = 128, 128 else: inpH, inpW = 416, 800 if model == 'RAE': with tf.name_scope("initalize_RNN_cell"): cell1 = rnn.ConvLSTMCell(2, [inpH, inpW, 32], 32, [3, 3], name='rnn1') cell2 = rnn.ConvLSTMCell(2, [inpH / 2, inpW / 2, 43], 43, [3, 3], name='rnn2') cell3 = rnn.ConvLSTMCell(2, [inpH / 4, inpW / 4, 57], 57, [3, 3], name='rnn3') cell4 = rnn.ConvLSTMCell(2, [inpH / 8, inpW / 8, 76], 76, [3, 3], name='rnn4') cell5 = rnn.ConvLSTMCell(2, [inpH / 16, inpW / 16, 101], 101, [3, 3], name='rnn5') cell6 = rnn.ConvLSTMCell(2, [inpH / 32, inpW / 32, 101], 101, [3, 3], name='rnn6') # Encoder l1, l2, l3, l4, l5, out = encoderRNN(self.inputNoiseList, batch_size, cell1, cell2, cell3, \ cell4, cell5, cell6, (inpH, inpW), reuse_vars=False) elif model == "AE": l1, l2, l3, l4, l5, out = encoder(self.inputNoiseList, batch_size, reuse_vars=False) Enc_params_num = len(tf.trainable_variables()) # Decoder / Generator self.denoised_imgList = decoder(l1, l2, l3, l4, l5, out, (inpH, inpW), reuse_vars=False) Enc_n_Dec_params_num = len(tf.trainable_variables()) self.params = tf.trainable_variables() self.Enc_params = self.params[:Enc_params_num] self.Dec_params = self.params[Enc_params_num:Enc_n_Dec_params_num] print(len(self.params)) for var in self.params: print(var.name) self.Spatial_loss = self.__get_L1_loss(self.denoised_imgList, self.inputCleanList) Spatial_loss_sum = tf.summary.scalar('Spatial_loss', self.Spatial_loss) self.Gradient_loss = self.__get_grad_L1_loss(self.denoised_imgList, self.inputCleanList) Gradient_loss_sum = tf.summary.scalar('Gradient_loss', self.Gradient_loss) if model == 'RAE': self.Temporal_loss = self.__get_tem_L1_loss( self.denoised_imgList, self.inputCleanList) Temporal_loss_sum = tf.summary.scalar('Temporal_loss', self.Temporal_loss) # merge summary for Tensorboard self.detached_loss_summary_merged = tf.summary.merge( [Spatial_loss_sum, Gradient_loss_sum, Temporal_loss_sum]) # loss function total_loss = ws * self.Spatial_loss + wg * self.Gradient_loss + wt * self.Temporal_loss elif model == 'AE': self.detached_loss_summary_merged = tf.summary.merge( [Spatial_loss_sum, Gradient_loss_sum]) # loss function total_loss = ws * self.Spatial_loss + wg * self.Gradient_loss # self.train = layers.optimize_loss(total_loss, tf.train.get_or_create_global_step(\ # ), learning_rate=learning_rate, variables = self.params, optimizer='RMSProp', update_ops=[]) self.train = tf.train.AdamOptimizer(learning_rate=learning_rate, beta1=0.9, beta2=0.99, epsilon=1e-08, name='Adam').minimize( total_loss, var_list=self.params) config = tf.ConfigProto() config.gpu_options.allow_growth = True self.sess = tf.Session(config=config) self.sess.run(tf.global_variables_initializer()) #.replace('\\','/') self.train_writer = tf.summary.FileWriter(sum_dir, self.sess.graph)
def __init__(self, hidden_size, batch_size, learning_rate, log_dir): self.input_tensor = tf.placeholder(tf.float32, [None, 28 * 28]) # add gaussian noise to the input input_with_noise = gaussian_noise_layer(self.input_tensor, 0.3) with arg_scope([layers.fully_connected], activation_fn=tf.nn.relu): with tf.variable_scope("encoder"): self.latent_representation = encoder(input_with_noise, hidden_size) encoder_params_num = len(tf.trainable_variables()) with tf.variable_scope('encoder', reuse=True): self.true_latent_representation = encoder(self.input_tensor, hidden_size) with tf.variable_scope('decoder'): self.recons = decoder(self.latent_representation) autoencoder_params_num = len(tf.trainable_variables()) with tf.variable_scope('decoder', reuse=True): self.sampled_imgs = decoder(tf.random_normal([batch_size, hidden_size])) pos_samples = tf.random_normal([batch_size, hidden_size], stddev=5.) neg_samples = self.latent_representation with tf.variable_scope('discriminator'): pos_samples_pred = discriminator(pos_samples) with tf.variable_scope('discriminator', reuse=True): neg_samples_pred = discriminator(neg_samples) #define losses reconstruction_loss = tf.reduce_mean(tf.square(self.recons - self.input_tensor)) #* 28 * 28 scale recons loss classification_loss = tf.losses.sigmoid_cross_entropy(\ tf.ones(tf.shape(pos_samples_pred)), pos_samples_pred) +\ tf.losses.sigmoid_cross_entropy(tf.zeros( tf.shape(neg_samples_pred)), neg_samples_pred) tf.summary.scalar('reconstruction_loss', reconstruction_loss) tf.summary.scalar('classification_loss', classification_loss) # define references to params params = tf.trainable_variables() encoder_params = params[:encoder_params_num] decoder_params = params[encoder_params_num:autoencoder_params_num] autoencoder_params = encoder_params + decoder_params discriminator_params = params[autoencoder_params_num:] # record true positive rate and true negative rate correct_pred_pos = tf.equal(tf.cast(pos_samples_pred>0, tf.float32), tf.ones(tf.shape(pos_samples_pred))) self.true_pos_rate = tf.reduce_mean(tf.cast(correct_pred_pos, tf.float32)) correct_pred_neg = tf.equal(tf.cast(neg_samples_pred<0, tf.float32), tf.ones(tf.shape(pos_samples_pred))) self.true_neg_rate = tf.reduce_mean(tf.cast(correct_pred_neg, tf.float32)) tf.summary.scalar('true_pos_rate', self.true_pos_rate) tf.summary.scalar('true_neg_rate', self.true_neg_rate) global_step = tf.contrib.framework.get_or_create_global_step() self.learn_rate = self._get_learn_rate(global_step, learning_rate) self.train_autoencoder = layers.optimize_loss(reconstruction_loss, global_step, self.learn_rate/10, optimizer=lambda lr: \ tf.train.MomentumOptimizer(lr, momentum=0.9), variables= autoencoder_params, update_ops=[]) self.train_discriminator = layers.optimize_loss(classification_loss, global_step, self.learn_rate, optimizer=lambda lr: \ tf.train.MomentumOptimizer(lr, momentum=0.1), variables= discriminator_params, update_ops=[]) self.train_encoder = layers.optimize_loss(-classification_loss, global_step, self.learn_rate/10, optimizer=lambda lr: \ tf.train.MomentumOptimizer(lr, momentum=0.1), variables= encoder_params, update_ops=[]) self.sess = tf.Session() self.merged = tf.summary.merge_all() self.train_writer = tf.summary.FileWriter(log_dir, self.sess.graph) self.sess.run(tf.global_variables_initializer())