def update_texture_generator(self, x, y, t=None, l=None, VGGfeatures=None, style_targets=None): fake_y = self.G_T(x) fake_concat = torch.cat((x, fake_y), dim=1) fake_output = self.D_T(fake_concat) LTadv = -fake_output.mean()*self.lambda_tadv Lrec = self.loss(fake_y, y) * self.lambda_l1 LT = LTadv + Lrec if t is not None: with torch.no_grad(): t[:,0:1] = gaussian(t[:,0:1], stddev=0.2) source_mask = self.G_S(t, l).detach() source = source_mask.clone() source[:,0:1] = gaussian(source[:,0:1], stddev=0.2) smaps_fore = [(A.detach()+1)*0.5 for A in self.getmask(source_mask[:,0:1])] smaps_back = [1-A for A in smaps_fore] fake_t = self.G_T(source) out = VGGfeatures(fake_t) style_losses1 = [self.style_weights[a] * self.gramloss(A*smaps_fore[a], style_targets[0][a]) for a,A in enumerate(out)] style_losses2 = [self.style_weights[a] * self.gramloss(A*smaps_back[a], style_targets[1][a]) for a,A in enumerate(out)] Lsty = (sum(style_losses1)+ sum(style_losses2)) * self.lambda_sty LT = LT + Lsty #global id #if id % 20 == 0: # viz_img = to_data(torch.cat((x[0], y[0], fake_y[0]), dim=2)) # save_image(viz_img, '../output/texturee_result%d.jpg'%id) #id += 1 self.trainerG_T.zero_grad() LT.backward() self.trainerG_T.step() return LTadv.data.mean(), Lrec.data.mean(), Lsty.data.mean() if t is not None else 0
def plot_linear_fit(ax, x_array, y_array, fit_function, fit_sigma, color, cmap): xlim = (min(x_array), max(x_array)) ylim = (min(y_array), max(y_array)) ax.set_xlim(*xlim) ax.set_ylim(*ylim) x_range = np.linspace(*xlim) y_range = np.linspace(*ylim) ax.scatter(x_array, y_array, lw=0, alpha=0.5, color=color) fit_line = [fit_function(x) for x in x_range] ax.plot(x_range, fit_line, color=color) xx, yy = np.meshgrid(x_range, y_range) zz = xx + yy for i in range(len(x_range)): for j in range(len(y_range)): zz[j, i] = gaussian(yy[j, i], fit_function(xx[j, i]), fit_sigma) im = ax.imshow( zz, origin='lower', interpolation='bilinear', cmap=cmap, alpha=0.5, aspect='auto', extent=(xlim[0], xlim[-1], ylim[0], ylim[-1]), vmin=0.0, vmax=gaussian(0, 0, fit_sigma) ) return ax, im
def list_of_gaus(arrival_time, intensities, fitted_parameters_f, fitted_parameters_r, norm_factor): """Parses results into a master nested list used for presentation and evaluation. Also parses error information. Args: arrival_time: Arrival time series intensities: ATD curve (distribution) fitted_parameters_f: Parameters for fitted peaks of the forward method [[height1, mean1, sd1],...] fitted_parameters_r: Parameters for fitted peaks of the reverse method [[height1, mean1, sd1],...] norm_factor: Scale factor for unnormalised data Returns: gausslist: List of gaussian distributions for each fitting method [[average], [forward], [reverse]] min_error: Minimum error between fitting methods errorlist: List of error values [forward, reverse, average] """ average = weighted_average(fitted_parameters_f, fitted_parameters_r, ) average = list(average) average = [list(i) for i in average] gausslist = [[], [], []] #[[average], [forward], [reverse]] for i in range(len(fitted_parameters_r)): gausslist[2].append(utils.gaussian(arrival_time, *fitted_parameters_r[i])) gausslist[1].append(utils.gaussian(arrival_time, *fitted_parameters_f[i])) for i in range(len(average)): gausslist[0].append(utils.gaussian(arrival_time, *average[i])) #Get sum of fitted peaks to compare to ATD curve fit_av = list(np.zeros((len(intensities)))) fit_f = list(np.zeros((len(intensities)))) fit_r = list(np.zeros((len(intensities)))) for i in gausslist[0]: fit_av = map(add, fit_av, i) for i in gausslist[1]: fit_f = map(add, fit_f, i) for i in gausslist[2]: fit_r = map(add, fit_r, i) #The last element of each list in gausslist is the ATD curve and the second #last the fit produced from the respective method gausslist[2].append(fit_r) gausslist[1].append(fit_f) gausslist[0].append(fit_av) gausslist[2].append(intensities) gausslist[1].append(intensities) gausslist[0].append(intensities) #Calculate errors normalising with scaling factor error_f = utils.rmsd(fit_f, intensities) * norm_factor error_r = utils.rmsd(fit_r, intensities) * norm_factor error_av = utils.rmsd(gausslist[0][-2], intensities) * norm_factor errorlist = [error_av, error_f, error_r] min_error = min(errorlist) erind = errorlist.index(min_error) parlist = [average, fitted_parameters_f, fitted_parameters_r] return parlist[erind], gausslist, min_error, errorlist
def __init__(self): self.n_server = 2 self.servers_capacity = [gaussian(1.2, 0.05), gaussian(0.8, 0.05)] # self.servers_capacity = [gaussian(1,0.4),gaussian(0.85,0.05),uniform(0.3,0.7),uniform(0.75,1.15)] self.max_queue_length = 10 self.time_lam = 2 # self.task_lam = 3 self.num_actions = self.n_server
def main(): # parse options parser = TestOptions() opts = parser.parse() # data loader print('--- load data ---') text = load_image(opts.text_name, opts.text_type) label = opts.scale step = opts.scale_step * 2.0 if opts.gpu: text = to_var(text) # model print('--- load model ---') netGlyph = GlyphGenerator(n_layers=6, ngf=32) netTexture = TextureGenerator(n_layers=6) netGlyph.load_state_dict(torch.load(opts.structure_model)) netTexture.load_state_dict(torch.load(opts.texture_model)) if opts.gpu: netGlyph.cuda() netTexture.cuda() netGlyph.eval() netTexture.eval() print('--- testing ---') text[:, 0:1] = gaussian(text[:, 0:1], stddev=0.2) if label == -1: # 默认值 -1 scale = -1.0 noise = text.data.new(text[:, 0:1].size()).normal_(0, 0.2) result = [] while scale <= 1.0: img_str = netGlyph(text, scale) img_str[:, 0:1] = torch.clamp(img_str[:, 0:1] + noise, -1, 1) result1 = netTexture(img_str).detach() result = result + [result1] scale = scale + step else: img_str = netGlyph(text, label * 2.0 - 1.0) img_str[:, 0:1] = gaussian(img_str[:, 0:1], stddev=0.2) result = [netTexture(img_str)] if opts.gpu: for i in range(len(result)): result[i] = to_data(result[i]) print('--- save ---') # directory if not os.path.exists(opts.result_dir): os.mkdir(opts.result_dir) for i in range(len(result)): if label == -1: result_filename = os.path.join(opts.result_dir, (opts.name + '_' + str(i) + '.png')) else: result_filename = os.path.join(opts.result_dir, (opts.name + '.png')) save_image(result[i][0], result_filename)
def update_structure_generator(self, x, xl, l, t=None): fake_x = self.G_S(xl, l) # fake_x : [32,3,256,256] fake_output = self.D_S(fake_x) # 向量 LSadv = -fake_output.mean() * self.lambda_sadv LSrec = self.loss(fake_x, x) * self.lambda_l1 LS = LSadv + LSrec if t is not None: # weight map based on the distance field # whose pixel value increases with its distance to the nearest text contour point of t Mt = (t[:, 1:2] + t[:, 2:3]) * 0.5 + 1.0 t_noise = t.clone() t_noise[:, 0:1] = gaussian(t_noise[:, 0:1], stddev=0.2) fake_t = self.G_S(t_noise, l) LSgly = self.loss(fake_t * Mt, t * Mt) * self.lambda_gly LS = LS + LSgly self.trainerG_S.zero_grad() LS.backward() self.trainerG_S.step() # global id # if id % 60 == 0: # viz_img = to_data(torch.cat((x[0], xl[0], fake_x[0]), dim=2)) # save_image(viz_img, '../output/structure_result%d.jpg'%id) # id += 1 return LSadv.data.mean(), LSrec.data.mean(), LSgly.data.mean( ) if t is not None else 0
def get_denom(self, xi_t): probs = 0.0 for k in range(self.n_components): mu_t_k = self.gmm.means_[k][0] var_t_k = self.gmm.covariances_[k][0,0] probs += gaussian(xi_t, mu_t_k, var_t_k) return probs
def train(epoch, model, optimizer, training_data_loader, mean, stddev, criterion): epoch_loss = 0 for iteration, data in enumerate(training_data_loader, 1): target = data _input, noise = gaussian(target, mean, stddev) if device == 'cuda': _input = Variable(_input.cuda()) noise = Variable(noise.cuda()) target = Variable(target.cuda()) output = model(_input) loss = criterion(output, noise) epoch_loss += loss.item() loss.backward() optimizer.step() optimizer.zero_grad() print("===> Epoch[{}]({}/{}): Loss: {:.4f}".format( epoch, iteration, len(training_data_loader), loss.item())) print("===> Epoch {} Complete: Avg. Loss: {:.4f}".format( epoch, epoch_loss / len(training_data_loader)))
def rp_dilutedpdf(pop,r=1,dr=0.1,fb=0.4,n=1e4,fig=None,plot=True,allpdfs=False): #add contrast curves here simr = rand.normal(size=n)*dr + r mainpdf = utils.gaussian(r,dr,norm=1-fb) inds = rand.randint(size(pop.dkepmag),size=n) diluted1 = utils.kde(dilutedradius(simr,pop.dkepmag[inds]),norm=fb/2,adaptive=False) diluted2 = utils.kde(dilutedradius(simr,-pop.dkepmag[inds]),norm=fb/2,adaptive=False) diluted2.renorm((fb/2)**2/quad(diluted2,0,20)[0]) totpdf = mainpdf + diluted1 + diluted2 if plot: pu.setfig(fig) rs = arange(0,2*r,0.01) p.plot(rs,totpdf(rs)) if allpdfs: p.plot(rs,mainpdf(rs)) p.plot(rs,diluted1(rs)) p.plot(rs,diluted2(rs)) if allpdfs: return totpdf,mainpdf,diluted1,diluted2 else: return totpdf
def add_to_image(self, image, beam=None): """ Add component to given instance of ``Image`` class. """ # Cellsize [rad] dx, dy = image.dx, image.dy # Center of image [pix] x_c, y_c = image.x_c, image.y_c # Parameters of component try: # Jy, mas, mas, mas, , rad flux, x0, y0, bmaj, e, bpa = self._p # If we call method inside ``CGComponent`` except ValueError: flux, x0, y0, bmaj = self._p e = 1. bpa = 0. # There's ONE place to convert them x0 *= mas_to_rad y0 *= mas_to_rad bmaj *= mas_to_rad # TODO: Is it [Jy/beam]?? # Amplitude of gaussian component [Jy/beam] # amp = flux / (2. * math.pi * (bmaj / mas_to_rad) ** 2. * e) # amp = flux / (2. * math.pi * (bmaj / abs(image.pixsize[0])) ** 2. * e) amp = 4. * np.log(2) * flux / (np.pi * (bmaj / abs(image.pixsize[0]))**2 * e) # Create gaussian function of (x, y) with given parameters gaussf = gaussian(amp, x0, y0, bmaj, e, bpa=bpa) # Calculating angular distances of cells from center of component # from cell numbers to relative distances # arrays with elements from 1 to imsize x, y = np.mgrid[1:image.imsize[0] + 1, 1:image.imsize[1] + 1] # from -imsize/2 to imsize/2 x = x - x_c y = y - y_c # the same in rads x = x * dx y = y * dy ## relative to component center #x = x - x0 #y = y - y0 ## convert to mas cause all params are in mas #x = x / mas_to_rad #y = y / mas_to_rad # Creating grid with component's flux at each cell fluxes = gaussf(x, y) if beam is not None: fluxes = beam.convolve(fluxes) # Adding component's flux to image grid image._image += np.rot90(fluxes)[::-1, ::]
def stylize_text(model, inputs): text_name = inputs["input_image"] text = load_image(text_name, 1) text = to_var(text) label = inputs["scale"] text[:, 0:1] = gaussian(text[:, 0:1], stddev=0.2) img_str = model['netGlyph'](text, label * 2.0 - 1.0) img_str[:, 0:1] = gaussian(img_str[:, 0:1], stddev=0.2) result = to_data(model['netTexture'](img_str)) output = save_image(result[0]) return {"output_image": output}
def estimate(self, xi_t): result = 0.0 for k in range(self.n_components): xi_s_k_head = self.xi_s_k(xi_t, k) mu_t_k = self.gmm.means_[k][0] var_t_k = self.gmm.covariances_[k][0,0] beta_k = gaussian(xi_t, mu_t_k, var_t_k) / self.get_denom(xi_t) result += xi_s_k_head * beta_k return result
def plot_experiment(self, path=""): color = self.color data = self.experiment_data cmap = sns.light_palette(color, as_cmap=True) fig, ax = plt.subplots() occupants, readings = (np.array(array) for array in zip(*data)) # ax_left, im_left = plot_linear_fit( # ax_left, occupants, readings, self.model, self.model_sigma, color, # cmap) ax, im = plot_linear_fit( ax, readings, occupants, self.predictor, self.predictor_sigma, color, cmap ) ax.set_xlabel("{} sensor readout ({})".format(self.name, self.units)) ax.set_ylabel("Number of train car occupants") # cax, kw = mpl.colorbar.make_axes( # [ax_left, ax_right], location="bottom" # ) # norm = mpl.colors.Normalize(vmin=0, vmax=1) # cbar = mpl.colorbar.ColorbarBase( # ax, cmap=cmap, norm=norm, alpha=0.5) cbar = plt.colorbar(im, alpha=0.5, extend='neither', ticks=[ gaussian(3 * self.predictor_sigma, 0, self.predictor_sigma), gaussian(2 * self.predictor_sigma, 0, self.predictor_sigma), gaussian(self.predictor_sigma, 0, self.predictor_sigma), gaussian(0, 0, self.predictor_sigma), ]) # cbar.solids.set_edgecolor("face") cbar.set_ticklabels( ['$3 \sigma$', '$2 \sigma$', '$\sigma$', '{:.2%}'.format( gaussian(0, 0, self.predictor_sigma))], update_ticks=True ) fig.savefig(os.path.join(path, self.name+".svg"))
def get_observation_continuous(self, curr_pos=None): if isinstance(curr_pos, np.ndarray): curr_pos = curr_pos[0] elif curr_pos == None: # Default to state of current instance curr_pos = self.robot_state door = 0 for door_loc in self.door_locations: door += 0.6*utils.gaussian(curr_pos, door_loc, 0.5) # Doors left = (-np.tanh(5 * (curr_pos + 13)) + 1) / 2 # Left wall right = (np.tanh(5 * (curr_pos - 13)) + 1) / 2 # Right wall return (door, left, right)
def update_emission(self): """ Calculate the emission matrix given the estimated mus and sigmas Only the log scale is saved. """ F = np.zeros((self.n, self.k)) for i in range(self.k): F[:, i] = gaussian(self.obs, self.mu[i], self.sigma[i]) self.log_F = np.log(F)
def likelihood_field(self, sensor_data): p_hit = 0.9 p_rand = 0.1 sig_hit = 6.0 q = 0 plist = utils.EndPoint(self.pos, self.bot_param, sensor_data) for i in range(len(plist)): if sensor_data[i] > self.bot_param[3] - 1 or sensor_data[i] < 1: continue dist = self.nearest_dist(plist[i][0], plist[i][1], 3, 0.2) q += math.log(p_hit * utils.gaussian(0, dist, sig_hit) + p_rand / self.bot_param[3]) return q
def __call__(self, landmarks, input_resolution): """ Returns a Tensor which contains the generated heatmaps of all elements in the :attr:`landmarks` tensor. Args: landmarks (ndarray): ndarray ( 2 x N ) contains N two dimensional landmarks. input_resolution: resolution ( H x W ) is the resoultion/dimension in which the landmarks are given. Returns: Tensor: The generated heatmaps ( N x outputH x outputW ). """ self.inputH = input_resolution[0] self.inputW = input_resolution[1] self.outputH = self.resolution[0] self.outputW = self.resolution[1] heatmaps = np.zeros((landmarks.shape[1], self.outputH, self.outputW)) for i in range(landmarks.shape[1]-1): if not np.isnan(landmarks[:, i]).any(): tmp = utils.gaussian(np.array([self.inputH, self.inputW]), landmarks[:, i], self.gauss) scaled_tmp = sp.misc.imresize(tmp, [self.outputH, self.outputW]) scaled_tmp = (scaled_tmp - min(scaled_tmp.flatten())) / ( max(scaled_tmp.flatten()) - min(scaled_tmp.flatten())) else: scaled_tmp = np.zeros([self.outputH, self.outputW]) heatmaps[i] = scaled_tmp tmp = utils.gaussian(np.array([self.inputH, self.inputW]), landmarks[:, -1], 4 * self.gauss) scaled_tmp = sp.misc.imresize(tmp, [self.outputH, self.outputW]) scaled_tmp = (scaled_tmp - min(scaled_tmp.flatten())) / ( max(scaled_tmp.flatten()) - min(scaled_tmp.flatten())) heatmaps[landmarks.shape[1]-1] = scaled_tmp return torch.from_numpy(heatmaps)
def LikelihoodField(self, sensor_data): p_hit = 0.9 p_rand = 0.1 sig_hit = 3.0 q = 1 plist = utils.EndPoint(self.pos, self.bot_param, sensor_data) for i in range(len(plist)): if sensor_data[i] > self.bot_param[3] - 1 or sensor_data[i] < 1: continue dist = self.NearestDistance(plist[i][0], plist[i][1], 4, 0.2) q = q * (p_hit * utils.gaussian(0, dist, sig_hit) + p_rand / self.bot_param[3]) #q += math.log(p_hit*utils.gaussian(0,dist,sig_hit) + p_rand/self.bot_param[3]) return q
def __init__(self, args): # parameters self.epoch = args.epoch self.sample_num = 64 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type # networks init self.En = encoder(self.dataset) self.De = decoder(self.dataset) self.VAE = VAE_T(self.En, self.De) self.VAE_optimizer = optim.Adam(self.VAE.parameters(),lr=args.lrG, betas=(args.beta1, args.beta2)) if self.gpu_mode: self.VAE.cuda() self.BCE_loss = nn.BCELoss().cuda() else: self.BCE_loss = nn.BCELoss() print('---------- Networks architecture -------------') utils.print_network(self.De) utils.print_network(self.En) print('-----------------------------------------------') # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST('data/mnist', train=True, download=False, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader( datasets.FashionMNIST('data/fashion-mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 self.z_n = utils.gaussian(self.batch_size, self.z_dim) # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.from_numpy(self.z_n).type(torch.FloatTensor).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.from_numpy(self.z_n).type(torch.FloatTensor), volatile=True)
def encrypt_raw(cls, pp: RegevPublicParameters, k: RegevKey, mes: np.ndarray, mes_mod: int = 2, seed=None): rng = SeededRNG(seed or secrets.token_bytes(32)) if mes.ndim != 1: raise MessageWrongDimensions() if mes.shape[0] != pp.bs: raise MessageWrongSize( f"Expected message size {pp.bs}, got {mes.shape[0]}") mes = mes % mes_mod r = uniform(2, rng, lbound=-1, shape=(1, pp.m)) # print(r.tolist()) c1 = r @ k.A % pp.cipher_mod b = (c1 @ k.sec + gaussian(pp.bound, rng, shape=(pp.m, pp.bs))) % pp.cipher_mod c2 = (b + mround(pp.cipher_mod / mes_mod) * mes) % pp.cipher_mod return BatchedRegevCiphertext(c1, c2, mes_mod)
def get_heat_source(image_size, batch_size): ''' Return a Gaussian heat source. ''' heat_src = [] for i in range(batch_size): scale = np.random.uniform(3, 3.5) / (image_size**2) f = -utils.gaussian(image_size - 2) * scale # Negative f = torch.Tensor(f).unsqueeze(0) f = utils.pad_boundary(f, torch.zeros(1, 4)) # (1 x image_size x image_size) heat_src.append(f) heat_src = torch.cat(heat_src, dim=0) if torch.cuda.is_available(): heat_src = heat_src.cuda() return heat_src
def __init__(self, args): # parameters self.epoch = args.epoch self.sample_num = 64 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = False self.model_name = args.gan_type # networks init self.En = encoder(self.dataset) self.De = decoder(self.dataset) self.VAE = VAE_T(self.En, self.De) self.VAE_optimizer = optim.Adam(self.VAE.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2)) if self.gpu_mode: self.VAE.cuda() self.BCE_loss = nn.BCELoss().cuda() else: self.BCE_loss = nn.BCELoss() print('---------- Networks architecture -------------') utils.print_network(self.De) utils.print_network(self.En) print('-----------------------------------------------') # load dataset self.data_loader = DataLoader() self.z_dim = 62 self.z_n = utils.gaussian(self.batch_size, self.z_dim) # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.from_numpy(self.z_n).type( torch.FloatTensor).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.from_numpy(self.z_n).type( torch.FloatTensor), volatile=True)
def validate(model, testing_data_loader, mean, stddev, criterion): avg_psnr = 0 model.eval() with torch.no_grad(): for data in testing_data_loader: target = data _input, noise = gaussian(target, mean, stddev) _input = Variable(_input.cuda()) noise = Variable(noise.cuda()) target = Variable(target.cuda()) output = model(_input) mse = criterion(output, noise) psnr = 10 * log10(1 / mse.item()) avg_psnr += psnr print("===> Avg. PSNR: {:.4f} dB".format(avg_psnr / len(testing_data_loader)))
def EM_gaussian_E_step(data, alpha, mu, sigma): """ Function that computes the E-step of the EM algorithm Params: data: data set alpha= proportion of each Gaussian. mu= list with mean values sigma= list with covariate matrices Returns: Tau: matrix with the probabilities P(z=j|x,tetha) """ tau = np.zeros((data.shape[0], len(alpha))) for j in np.arange(0, len(alpha)): tau[:, j] = alpha[j] * gaussian(data, mu[j], sigma[j]) denominator = tau.sum(1) for j in np.arange(0, len(alpha)): tau[:, j] = tau[:, j] / denominator return tau
def MixtureGaus_loglike(data, alpha, mu, sigma): """ Params: data: data set alpha: proportion of each Gaussian. mu: list with mean values sigma: list with covariate matrices Returns: loglike: loglikelihood of the observations """ aux_loglike = np.zeros((data.shape[0], len(alpha))) for j in np.arange(0, len(alpha)): aux_loglike[:, j] = alpha[j] * gaussian(data, mu[j], sigma[j]) aux_loglike = np.apply_along_axis(lambda x: np.log(np.sum(x)), 1, aux_loglike) loglike = np.sum(aux_loglike) / float(len(data)) return loglike
def nll_loss(alpha, sigma, mu, t): """ Loss function, minimizes the negative log-likelihood. :param alpha: mixing coefficients (priors) :param sigma: covariances, one per kernel :param mu: expected value of each kernel :param t: batch of target vectors :return: loss """ batch_size = alpha.shape[0] k = alpha.shape[1] t_dim = int(mu.shape[1] / k) loss = torch.zeros(batch_size) if torch.cuda.is_available(): loss = loss.cuda() for i in range(k): likelihood_t = gaussian(t, mu[:, i * t_dim:(i + 1) * t_dim], sigma[:, i]) loss += alpha[:, i] * likelihood_t loss = torch.mean(-torch.log(loss)) return loss
def write_word(i, word): # randomized font_path = font_paths[i % 2] underlined = True if i % 3 == 1 else False inverted = True if i % 3 == 1 else False font = ImageFont.truetype(font_path, np.random.randint(16, 20)) img_pil = Image.fromarray(np.ones((h, w, 3), np.uint8) * 255) draw = ImageDraw.Draw(img_pil) # add text draw.text((x, y), word, font=font, fill=color) # add underline tw, th = draw.textsize(word, font=font) if underlined: draw.line((x, y + th + 1, x + tw, y + th + 1), fill=color) if inverted: img_pil = ImageOps.invert(img_pil) # rotate slightly angle = np.random.uniform(-0.2, 0.2) img_pil = img_pil.rotate(angle) # crop img = np.array(img_pil)[y:y + th + 4, x:x + tw] # add gaussian noise to image img = gaussian(img) print(i, word) with open(f"out/img_{i}.txt", 'w') as f: f.write(word) cv2.imwrite(f"out/img_{i}.png", img)
def class_probability(target_val): prob = target_dist[target_val] for attr in dataset.inputs: prob *= gaussian(means[target_val][attr], deviations[target_val][attr], example[attr]) return prob
def train_VAE(_model): feature_a, neighbour1_a, degree1_a, logrmin_a, logrmax_a, smin_a, smax_a, modelnum_a, \ pointnum1_a, maxdegree1_a, L1_a, cotw1_a = utils.load_data(featurefile_a, vcgan.resultmin, vcgan.resultmax, useS=vcgan.useS) # dataname_a = _model.dataset_name_a # featurefile_a = './'+dataname_a+'.mat' # resultmax = 0.95 # resultmin = -0.95 # useS = True # feature_a, neighbour1_a, degree1_a, logrmin_a, logrmax_a, smin_a, smax_a, modelnum_a, \ # pointnum1_a, maxdegree1_a, L1_a, cotw1_a = utils.load_data(featurefile_a, resultmin, resultmax, useS=useS) # self.feature_a, self.neighbour1_a, self.degree1_a, self.logrmin_a, self.logrmax_a, self.smin_a, self.smax_a, self.modelnum_a, \ # self.pointnum1_a, self.maxdegree1_a, self.L1_a, self.cotw1_a = utils.load_data(featurefile_a, resultmin, resultmax, useS=useS) # Ilf = np.zeros((_model.batch_size, 1)) rng = np.random.RandomState(23456) # if False: if os.path.isfile("id.dat"): id = pickle.load(open('id.dat', 'rb')) id.show() Ia = id.Ia # Ib = id.Ib else: Ia = np.arange(len(feature_a)) # Ib = np.arange(len(_model.feature_b)) Ia = random.sample(list(Ia), int(len(feature_a) * (1 - vcgan.vae_ablity))) # Ib = random.sample(list(Ib), int(len(_model.feature_b) * (1 - vcgan.vae_ablity))) # id = Id(Ia, Ib) id = utils.Id(Ia) #id.show() f = open('id.dat', 'wb') pickle.dump(id, f, 0) f.close() id = pickle.load(open('id.dat', 'rb')) id.show() _model.file.write("VAE start\n") # for step in xrange(_model.start_step_vae, vcgan.n_epoch_Vae): for step in range(_model.start_step_vae, vcgan.n_epoch_Vae): rng.shuffle(Ia) # rng.shuffle(Ib) # train each batch for i in range(0, len(Ia), _model.batch_size): timeserver1 = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) feature = feature_a[Ia[i:i + _model.batch_size]] random_a = utils.gaussian(len(feature), _model.hidden_dim) _, cost_generation_a, cost_latent_a, l2_loss_a = _model.sess.run( [ _model.train_op_vae_a, _model.neg_loglikelihood_a, _model.KL_divergence_a, _model.r2_a ], feed_dict={ _model.inputs_a: feature, _model.random_a: random_a }) print("%s Processed %d|%d" % (timeserver1, i + _model.batch_size, len(Ia))) timeserver1 = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) print( "|%s step: [%2d|%d]cost_generation_a: %.8f, cost_latent_a: %.8f, l2_loss_a: %.8f" % (timeserver1, step + 1, vcgan.n_epoch_Vae, cost_generation_a, cost_latent_a, l2_loss_a)) # feature_a = _model.feature_a[Ia] ## feature_b = _model.feature_b[Ib] # random_a = utils.gaussian(len(feature_a), _model.hidden_dim) ## random_b = gaussian(len(feature_b), _model.hidden_dim) # # # ------------------------------------VAE a # _, cost_generation_a, cost_latent_a, l2_loss_a = _model.sess.run( # [_model.train_op_vae_a, _model.neg_loglikelihood_a, _model.KL_divergence_a, _model.r2_a], # feed_dict={_model.inputs_a: feature_a, _model.random_a: random_a}) # print("|%s step: [%2d|%d]cost_generation_a: %.8f, cost_latent_a: %.8f, l2_loss_a: %.8f" % ( # timeserver1, step + 1, vcgan.n_epoch_Vae, cost_generation_a, cost_latent_a, l2_loss_a)) ## # ------------------------------------VAE b ## _, cost_generation_b, cost_latent_b, l2_loss_b = _model.sess.run( ## [_model.train_op_vae_b, _model.neg_loglikelihood_b, _model.KL_divergence_b, _model.r2_b], ## feed_dict={_model.inputs_b: feature_b, _model.random_b: random_b}) ## print("|%s step: [%2d|%d]cost_generation_b: %.8f, cost_latent_b: %.8f, l2_loss_b: %.8f" % ( ## timeserver1, step + 1, vcgan.n_epoch_Vae, cost_generation_b, cost_latent_b, l2_loss_b)) _model.file.write("|%s Epoch: [%5d|%d] cost_generation_a: %.8f, cost_latent_a: %.8f, l2_loss_a: %.8f\n" \ % (timeserver1, step + 1, vcgan.n_epoch_Vae, cost_generation_a, cost_latent_a, l2_loss_a)) # _model.file.write("|%s Epoch: [%5d|%d] cost_generation_b: %.8f, cost_latent_b: %.8f, l2_loss_b: %.8f\n" \ # % (timeserver1, step + 1, vcgan.n_epoch_Vae, cost_generation_b, cost_latent_b, l2_loss_b)) _model.file_vae.write( "A %d %.8f %.8f %.8f\n" % (step + 1, cost_generation_a, cost_latent_a, l2_loss_a)) # _model.file_vae.write("B %d %.8f %.8f %.8f\n" % (step + 1, cost_generation_b, cost_latent_b, l2_loss_b)) if vcgan.tb and (step + 1) % 20 == 0: # s = _model.sess.run(_model.merge_summary, # feed_dict={_model.inputs_a: feature_a, _model.inputs_b: feature_b, # _model.random_a: random_a, # _model.random_b: random_b, _model.lf_dis: Ilf}) s = _model.sess.run(_model.merge_summary, feed_dict={ _model.inputs_a: feature, _model.random_a: random_a }) _model.write.add_summary(s, step) if (step + 1) % 20 == 0: print('Saving model...\n') # print(vcgan.logfolder) # if vcgan.test_vae: # test_utils.test_vae(_model, step) save_path = _model.saver_vae_a.save(_model.sess, _model.checkpoint_dir_vae_a + '/vae_a.model', global_step=step + 1) print("Model saved in path: %s\n" % save_path) print("Testing the model...\n") test_utils.recons_error_a(_model, step) # self.saver_vae_b.save(self.sess, self.checkpoint_dir_vae_b + '/vae_b.model', global_step=step + 1) # _model.saver_vae_all.save(_model.sess, _model.checkpoint_dir_vae_all + '/vae_all.model', global_step=step + 1) print( '---------------------------------train VAE success!!----------------------------------' )
if verbose: print "No synthetic emission data found. Re-scanning temperature range." resp = load_temp_responses() if n_params == 1: resp /= resp[2, :] resp[np.isnan(resp)] = 0 if verbose: print resp.min(axis=1), np.nanmin(resp, axis=1) print resp.max(axis=1), np.nanmax(resp, axis=1) logt = np.arange(0, 15.05, 0.05) delta_t = logt[1] - logt[0] model = np.memmap( filename="synth_emiss_{}pars".format(n_params), dtype="float32", mode="w+", shape=(n_vals, n_wlens) ) for p, params in enumerate(parvals): dem = gaussian(logt, *params) f = resp * dem model[p, :] = np.sum(f, axis=1) * delta_t if verbose: print model.max(axis=0) print model[np.isnan(model)].size if n_params == 1: normmod = model[:, 2].reshape((n_vals, 1)) model /= normmod model.flush() if verbose: print model.max(axis=0) else: model = None model = comm.bcast(model, root=0)
def update_texture_generator(self, x, y, t=None, l=None, VGGfeatures=None, style_targets=None): fake_y = self.G_T(x) # 计算L_distance # 风格距离图变为黑白图 BW = x[:, 0, :, :].clone().detach().unsqueeze(dim=1) # print(BW.shape) BW = BW.expand(BW.shape[0], 3, BW.shape[2], BW.shape[3]) C = BW D = x X = fake_y C.require_grad_ = False D.require_grad_ = False # Ldistance = 1e-6 * torch.sum((C * D - X * D)) Ldistance = torch.norm(C * D - X * D, 'fro') * 0.5 * self.lambda_distance fake_concat = torch.cat((x, fake_y), dim=1) fake_output = self.D_T(fake_concat) LTadv = -fake_output.mean() * self.lambda_tadv Lrec = self.loss(fake_y, y) * self.lambda_l1 LT = LTadv + Lrec + Ldistance if t is not None: with torch.no_grad(): t[:, 0:1] = gaussian(t[:, 0:1], stddev=0.2) source_mask = self.G_S(t, l).detach() source = source_mask.clone() source[:, 0:1] = gaussian(source[:, 0:1], stddev=0.2) smaps_fore = [(A.detach() + 1) * 0.5 for A in self.getmask(source_mask[:, 0:1])] smaps_back = [1 - A for A in smaps_fore] fake_t = self.G_T(source) out = VGGfeatures(fake_t) style_losses1 = [ self.style_weights[a] * self.gramloss(A * smaps_fore[a], style_targets[0][a]) for a, A in enumerate(out) ] style_losses2 = [ self.style_weights[a] * self.gramloss(A * smaps_back[a], style_targets[1][a]) for a, A in enumerate(out) ] Lsty = (sum(style_losses1) + sum(style_losses2)) * self.lambda_sty LT = LT + Lsty # global id # if id % 20 == 0: # viz_img = to_data(torch.cat((x[0], y[0], fake_y[0]), dim=2)) # save_image(viz_img, '../output/texturee_result%d.jpg'%id) # id += 1 self.trainerG_T.zero_grad() LT.backward() self.trainerG_T.step() return Ldistance.data.mean(), LTadv.data.mean(), Lrec.data.mean( ), Lsty.data.mean() if t is not None else 0
def forward(self, x, l): x[:, 0:1] = gaussian(x[:, 0:1], stddev=0.2) xl = self.G_S(x, l) xl[:, 0:1] = gaussian(xl[:, 0:1], stddev=0.2) return self.G_T(xl)
def class_probability(targetval): prob = target_dist[targetval] for attr in dataset.inputs: prob *= gaussian(means[targetval][attr], deviations[targetval][attr], example[attr]) return prob