def lolpolpolpo(): # Generate a random flame f = GenRandom(*(randopt for i in range(random.randint(2, 5)))) # Normalize weights of xforms in this flame # to a sum of 0.5 utils.normalize_weights(f, norm=0.5) # Choose a random xform. Delete it and create a new one # with the same weight using variations in special_vars # choosing 3 of them delx = random.choice(f.xform) del_weight = delx.weight del_color = delx.color delx.delete() Xform.random(f, xv=special_vars, n=3, xw=del_weight, col=del_color) # Add one more all-linear xform with weight 0.5 # with the magic rotation & offset lastx = f.add_xform(weight=0.5, color_speed=0) lastx.rotate(random.uniform(rand_angle_min, rand_angle_max)) lastx.c = random.uniform(-0.5, 0.5) lastx.f = random.uniform(-0.5, 0.5) f.reframe() return f
def lolpolpolpo(): # Generate a random flame f = GenRandomFlame(randopt, numbasic=5) # Normalize weights of xforms in this flame # to a sum of 0.5 utils.normalize_weights(f,norm=0.5) # Choose a random xform. Delete it and create a new one # with the same weight using variations in special_vars # choosing 3 of them delx = random.randint(0,len(f.xform)-1) delxw = f.xform[delx].weight delcol = f.xform[delx].color f.xform[delx].delete() Xform.random(f, xv=special_vars, n=3, xw=delxw, col=delcol) # Add one more all-linear xform with weight 0.5 # with the magic rotation & offset lastx = f.add_xform(weight=0.5, color_speed=0) lastx.rotate(random.uniform(rand_angle_min,rand_angle_max)) lastx.c = random.uniform(-0.5, 0.5) lastx.f = random.uniform(-0.5, 0.5) # reframe and name the flame f.reframe() return f
def fit(self, successes, trials, n_samples=1000, baseline=0.0, values=None, smoothing=1.0): ''' Generate the weights for each arm based on bandit history. Parameters: successes (array): A 1 x n array with total successes for each arm trials (array): A 1 x n array with total trials for each arm n_samples (int): The number of samples to pull from each arm's distribution for Thompson Sampling. baseline (float): The minimum weight to give each ar values (array): A 1 x n array with the reward value for each arm, or None smoothing (float): The constant factor by which to divide all trials and successes Updates self.weights (array): A 1 x n array with normalized weights for each arm ''' self.values = utils.set_values(values, len(trials)) self.samples = utils.get_samples(trials, successes, n_samples, smoothing, self.values) self._raw_weights = utils.get_weights(self.samples) self.weights = utils.normalize_weights(self._raw_weights, baseline)
def generate_portfolio(self, **kwargs): kwargs = dotdict(kwargs) symbols = list(kwargs.cov_matrix.columns) self.gene_length = len(symbols) # Create initial genes initial_genes = self.generate_initial_genes(symbols) for i in range(self.iterations): # Select top_genes = self.select(kwargs.sample_returns, initial_genes) # print("Iteration %d Best Sharpe Ratio: %.3f" % (i, top_genes[0][0])) top_genes = [item[1] for item in top_genes] # Mutate mutated_genes = self.mutate(top_genes) initial_genes = mutated_genes top_genes = self.select(kwargs.sample_returns, initial_genes) best_gene = top_genes[0][1] # Gene is a distribution of weights for different stocks # transposed_gene = np.array(best_gene).transpose() # returns = np.dot(return_matrix, transposed_gene) # returns_cumsum = np.cumsum(returns) n_best = normalize_weights(best_gene) weights = {symbols[x]: n_best[x] for x in range(0, len(best_gene))} return weights
def AdaBoost_Algo(train_set, how_many_times_to_run, hypo_function): weights = [] for i in range(0, len(train_set)): # give equal weights to any data point weights.append(1 / len(train_set)) H_set_of_hypos = [] for i in range(0, how_many_times_to_run): # run r times lowest_err_hypo = hypo_function( train_set, weights) # get the best hypo (weighted err wise) alpha_for_hypo = (1 / 2) * ln( (1 - lowest_err_hypo[3]) / lowest_err_hypo[3]) H_set_of_hypos.append( (lowest_err_hypo, alpha_for_hypo)) # collect all hypos for this round if lowest_err_hypo[ 3] >= 0.5: # if eps (hypos weighted err) is at least half you can "skip" round - as alpha zero break utils.update_weights(alpha_for_hypo, lowest_err_hypo, train_set, weights, len(train_set), hypo_function) # update and normalize weights utils.normalize_weights(weights, len(weights)) return H_set_of_hypos
def calculate_style_loss(original_style, generated_style, style_layer_weights): normalized_weights = normalize_weights(style_layer_weights) gram_original = [gram_matrix(layer) for layer in original_style] gram_generated = [gram_matrix(layer) for layer in generated_style] style_loss = 0 for i in range(len(original_style)): layer = original_style[i] # Layers have shape of n_batch * n_activation_height * n_activation_width * n_channel num_channel = layer.shape[-1] activation_size = layer.shape[1] * layer.shape[2] style_loss = style_loss + (normalized_weights[i] * tf.reduce_sum( (gram_generated[i] - gram_original[i]) ** 2) / (4 * num_channel**2 * activation_size**2)) return style_loss
def generate_portfolio(self, **kwargs): """ Inspired by: https://srome.github.io/Eigenvesting-II-Optimize-Your-Portfolio-With-Optimization/ """ kwargs = dotdict(kwargs) inverse_cov_matrix = np.linalg.pinv(kwargs.cov_matrix) ones = np.ones(len(inverse_cov_matrix)) inverse_dot_ones = np.dot(inverse_cov_matrix, ones) min_var_weights = inverse_dot_ones / np.dot(inverse_dot_ones, ones) min_var_weights = normalize_weights(min_var_weights) weights = { kwargs.cov_matrix.columns[i]: min_var_weights[i] for i in range(min_var_weights.shape[0]) } return weights
def generate_portfolio(self, **kwargs): """ Inspired by: https://srome.github.io/Eigenvesting-I-Linear-Algebra-Can-Help-You-Choose-Your-Stock-Portfolio/ """ kwargs = dotdict(kwargs) eigh_values, eigh_vectors = np.linalg.eigh(kwargs.cov_matrix) # We don't need this but in case someone wants to analyze # market_eigen_portfolio = eig_vectors[:, -1] / np.sum(eig_vectors[:, -1]) # This is a portfolio that is uncorrelated to market and still yields good returns eigen_portfolio = eigh_vectors[:, -kwargs.p_number] / \ np.sum(eigh_vectors[:, -kwargs.p_number]) # if kwargs.long_only: # weights = {kwargs.cov_matrix.columns[i]: max(0, eigen_portfolio[i]) # for i in range(eigen_portfolio.shape[0])} # else: eigen_portfolio = normalize_weights(eigen_portfolio) weights = { kwargs.cov_matrix.columns[i]: eigen_portfolio[i] for i in range(eigen_portfolio.shape[0]) } return weights
def generate_portfolio(self, **kwargs): """ Inspired by: Eigen Portfolio Selection: A Robust Approach to Sharpe Ratio Maximization, https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3070416 """ kwargs = dotdict(kwargs) inverse_cov_matrix = np.linalg.pinv(kwargs.cov_matrix) ones = np.ones(len(inverse_cov_matrix)) numerator = np.dot(inverse_cov_matrix, kwargs.pred_returns) denominator = np.dot(np.dot(ones.transpose(), inverse_cov_matrix), kwargs.pred_returns) msr_portfolio_weights = numerator / denominator msr_portfolio_weights = normalize_weights(msr_portfolio_weights) weights = { kwargs.cov_matrix.columns[i]: msr_portfolio_weights[i] for i in range(len(msr_portfolio_weights)) } return weights
files = glob(file_path) models, res = [], [] for f in files: try: if pull_from_db: data = np.load('{}.npz'.format(f['file_path'])) else: data = np.load(f) model_name = data['model_name'] siamese = data['siamese'] dataset = data['dataset'] inner_steps = data['inner_steps'] # Using weight norm? wn = data['wn'] if wn: num_objects_center = normalize_weights(data, 'num_objects', 'center') # noqa num_objects_scale = normalize_weights(data, 'num_objects', 'scale') # noqa object_size_center = normalize_weights(data, 'object_size', 'center') # noqa object_size_scale = normalize_weights(data, 'object_size', 'scale') # noqa object_location_center = normalize_weights(data, 'object_location', 'center') # noqa object_location_scale = normalize_weights(data, 'object_location', 'scale') # noqa else: num_objects_center = data['num_objects_center'] num_objects_scale = data['num_objects_scale'] object_size_center = data['object_size_center'] object_size_scale = data['object_size_scale']
def main(): from vgg16 import model dirname = os.path.dirname(os.path.abspath(__file__)) layer_idx = 18 img_disp = cv2.imread('{}/images/woh.png'.format(dirname)) img_disp = cv2.resize(img_disp, (224, 224)) img = img_disp[np.newaxis, :, :, :] img = img.astype(np.float32) img = img - np.array([103.939, 116.779, 123.68]) # bgr for i, layer in enumerate(model.layers): print(i, layer) compute_weight = True is_changed = True while True: if is_changed: is_changed = False out = utils.activation(img, model, layer_idx) if len(out.shape) == 4: is_conv = True is_fc = False out = np.transpose(out, (3, 1, 2, 0)) else: is_conv = False is_fc = True out = np.transpose(out, (1, 0)) out = utils.normalize(out) disp = utils.combine_and_fit(out, is_conv=is_conv, is_fc=is_fc, disp_w=800) cv2.imshow('input', img_disp) cv2.imshow('disp', disp) if compute_weight: compute_weight = False weight = model.get_weights()[ 0] # only first layer is interpretable for *me* weight = utils.normalize_weights(weight, 'conv') weight = np.transpose(weight, (3, 0, 1, 2)) weight_disp = utils.combine_and_fit(weight, is_weights=True, disp_w=400) cv2.imshow('weight_disp', weight_disp) val = cv2.waitKey(1) & 0xFF if val == ord('q'): break elif val == ord('w'): if layer_idx < 22: layer_idx += 1 is_changed = True print(model.layers[layer_idx].name) elif val == ord('s'): if layer_idx > 1: layer_idx -= 1 is_changed = True print(model.layers[layer_idx].name)
def experiment(param_path, category, dataset_dir, steps, n, used_wn=True): """Run a dataset-adv experiment. Pull from DB or use defaults.""" # Set default training parameters device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(('Using device: {}'.format(device))) # Load dataset params and get name of dataset old_cat = np.copy(category) category = category.replace('_', ' ') assert os.path.exists(param_path), 'Could not find {}'.format(param_path) dataset = param_path.split(os.path.sep)[-1].split('_')[0] params = np.load(param_path) if used_wn: # Dataset optimized using weight norm if dataset == 'biggan': params = { 'noise_vector_center_g': params.f.noise_vector_center_g, 'noise_vector_center_v': params.f.noise_vector_center_v, 'noise_vector_scale_g': params.f.noise_vector_scale_g, 'noise_vector_scale_v': params.f.noise_vector_scale_v, 'noise_vector_factor_g': params.f.noise_vector_factor_g, 'noise_vector_factor_v': params.f.noise_vector_factor_v, } elif dataset == 'psvrt': raise NotImplementedError else: if dataset == 'biggan': params = { 'noise_vector_center': params.f.noise_vector_center, 'noise_vector_scale': params.f.noise_vector_scale, 'noise_vector_factor': params.f.noise_vector_factor } elif dataset == 'psvrt': raise NotImplementedError if dataset == 'biggan': num_classes = 1000 elif dataset == 'psvrt': num_classes = 2 else: raise NotImplementedError(dataset) # Add hyperparams and model info to DB dt = datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d-%H_%M_%S') ds_name = os.path.join(dataset_dir, '{}_{}'.format(dataset, dt)) # Create results directory utils.make_dir(dataset_dir) utils.make_dir(ds_name) # Initialize dataset object if dataset == 'biggan': img_size = 256 elif dataset == 'psvrt': img_size = 80 # 160 ds = import_module('data_generators.{}'.format(dataset)) P = ds.Generator(dataset=dataset, img_size=img_size, device=device, siamese=False, task='sd', wn=False, num_classes=num_classes) P = P.to(device) if used_wn: lambda_0_r = utils.normalize_weights(P=params, name='noise_vector', prop='center') lambda_0_scale_r = utils.normalize_weights(P=params, name='noise_vector', prop='scale') lambda_0_factor_r = utils.normalize_weights(P=params, name='noise_vector', prop='factor') else: raise NotImplementedError # Pull out original params class_vector = one_hot_from_names([category]).repeat(n, 0) lambda_0 = P.dists[0]['lambda_0'].cpu().numpy() lambda_0_scale = P.dists[0]['lambda_0_scale'].cpu().numpy() lambda_0_factor = P.dists[0]['lambda_0_factor'].cpu().numpy() interp = np.linspace(0, 1, steps) f = plt.figure() for b, itp in tqdm(enumerate(interp), desc='Interpolation steps', total=steps): # Do linear combinations of original and final i_lambda_0 = (1 - itp) * lambda_0 + itp * lambda_0_r i_lambda_scale_0 = (1 - itp) * lambda_0_scale + itp * lambda_0_scale_r i_lambda_factor_0 = (1 - itp) * lambda_0_factor + itp * lambda_0_factor_r it_params = { 'noise_vector_center': i_lambda_0, 'noise_vector_scale': i_lambda_scale_0, 'noise_vector_factor': i_lambda_factor_0 } with torch.no_grad(): images, labels = P.sample_batch(n, force_params=it_params, class_vector=class_vector, force_mean=True) images = images.detach().cpu().numpy().transpose(0, 2, 3, 1) norm_mean = P.norm_mean.cpu().numpy().reshape(1, 1, 3) norm_std = P.norm_std.cpu().numpy().reshape(1, 1, 3) images = images * norm_std + norm_mean row_ids = np.arange(b, steps * n, steps) + 1 for idx, row in enumerate(row_ids): plt.subplot(n, steps, row) plt.axis('off') plt.imshow(images[idx]) f.text(0.05, 0.5, 'Mean image -2 to +2 SDs', va='center', rotation='vertical') f.text(0.5, 0.04, 'Interpolation from start to optimized parameters', ha='center') plt.gcf().subplots_adjust(left=0.15) # plt.tight_layout() # plt.ylabel('Mean image -2 to +2 SDs') # plt.xlabel('Interpolation from start to optimized parameters') plt.savefig(os.path.join(ds_name, '{}.pdf'.format(old_cat)), dpi=300) plt.show()