def example_color_img():
'''Produces a three channel color image of a Green fractal'''
num_frames = 64
theta_range = 2 * math.pi / 512
d_theta = theta_range / num_frames
params_r = np.array([[1.0, 1.0, 1.0]]).T
params_g = np.array([[1.0, 1.0, 1.0]]).T
params_b = np.array([[1.0, 1.0, 1.0]]).T
xform_r = utils.rotate_xform(d_theta, 0, 0)
xform_g = utils.rotate_xform(0, d_theta, 0)
xform_b = utils.rotate_xform(0, 0, d_theta)
generator_r = generate.Generator(params_r, xform_r, num_frames)
generator_g = generate.Generator(params_g, xform_g, num_frames)
generator_b = generate.Generator(params_b, xform_b, num_frames)
image.generate_color_image(generator_r, generator_g, generator_b)
def get_pop_similarity(pop):
generator = generate.Generator(num_params=NUM_PARAMS)
pop_points = []
for vec in pop:
points = generator.generate_return_pts(vec)
pop_points.append(points)
hsums = []
for i in range(len(pop_points)):
for j in range(i, len(pop_points)):
hsums.append(directed_hausdorff(pop_points[i], pop_points[j])[0])
return np.mean(hsums)
def example_img():
'''Produces a image of a Green fractal'''
num_frames = 128
theta_range = 2 * math.pi / 1
d_theta = theta_range / num_frames
params = np.array([[0.0, 1.0, 1.0]]).T
xform = utils.rotate_xform(d_theta, d_theta, d_theta)
generate.Generator(params, xform, num_frames)
def visualize(lam_array, num_params, trials, load_dir):
generator = generate.Generator(num_params)
data_key = ['DIF', 'DIT']
#data_key = ['DIT']
sparse_key = ['SF', 'ST']
#sparse_key = ['SF']
exp_names = []
sparse_flags = []
for s in sparse_key:
if s == 'SF':
pass
for d in data_key:
sparse_flags.append(False)
exp_names.append(d + '_' + s + '_')
else:
d = 'DIT'
for lam in lam_array:
sparse_flags.append(True)
exp_names.append(d + '_' + s + '_' + str(lam) + '_')
exp_latents = []
for i in range(len(exp_names)):
exp_latents.append(
generator.get_latent(exp_names[i], sparse_flags[i], trials,
load_dir))
print(exp_names)
for i in range(len(exp_latents)):
#Plot performances of all objects
pops = exp_latents[i]
name = exp_names[i]
print(name)
for j in range(len(pops)):
pop = pops[j]
#pop = np.reshape(pops,(-1,num_params))
rxs = []
rys = []
performances = []
for latent in pop:
pts = 10 * generator.generate_return_pts(latent)
radii = ee.getMinVolEllipse(P=pts)
rx = radii[0]
ry = radii[1]
rxs.append(rx)
rys.append(ry)
performances.append(ee.performance_from_radii(rx, ry))
ed.plot_data(rxs, rys, performances)
def visualize_pts(lam_array, num_params, trials, load_dir):
generator = generate.Generator(num_params)
data_key = ['DIF', 'DIT']
sparse_key = ['SF', 'ST']
exp_names = []
sparse_flags = []
for s in sparse_key:
if s == 'SF':
pass
for d in data_key:
sparse_flags.append(False)
exp_names.append(d + '_' + s + '_')
else:
d = 'DIT'
for lam in lam_array:
sparse_flags.append(True)
exp_names.append(d + '_' + s + '_' + str(lam) + '_')
exp_latents = []
for i in range(len(exp_names)):
exp_latents.append(
generator.get_latent(exp_names[i], sparse_flags[i], trials,
load_dir))
print(exp_names)
#for pops in exp_latents[1]:
#Plot performances of all objects
pops = exp_latents
for pop in pops:
pop = exp_latents[1]
pop = np.reshape(pops, (-1, num_params))
pop = pop.tolist()
rxs = []
rys = []
performances = []
random.shuffle(pop)
for latent in pop[0:3]:
latent = np.asarray(latent)
pts = 10 * generator.generate_return_pts(latent)
xpts = pts[0]
ypts = pts[1]
zpts = pts[2]
ed.plot_ellipsoid_points(xpts, ypts, zpts)
def get_trainset_similarity(pop):
generator = generate.Generator(num_params=NUM_PARAMS)
#Get GA population point set
pop_points = []
for vec in pop:
points = generator.generate_return_pts(vec)
pop_points.append(points)
#Get Training Set point set
train_vecs, _ = generator.load_training_objects(300, SEED)
train_points = []
for vec in train_vecs:
points = generator.generate_return_pts(vec)
train_points.append(points)
hsums = []
for ppoints in pop_points:
for tpoints in train_points:
hsums.append(directed_hausdorff(ppoints, tpoints)[0])
return np.mean(hsums)
def visualize_training(num_samples, num_params=1024):
generator = generate.Generator(num_params)
for i in range(5):
latents, names = generator.load_training_objects(num_samples, i)
#print('Loading ' + name)
rxs = []
rys = []
performances = []
for latent in latents:
pts = 10 * generator.generate_return_pts(
latent) #unnormalize from AtlasNet
#Performance
radii = ee.getMinVolEllipse(P=pts)
rx = radii[0]
ry = radii[1]
performance = ee.performance_from_radii(rx, ry)
rxs.append(rx)
rys.append(ry)
performances.append(performance)
ed.plot_data(rxs, rys, performances)
def setUp(self):
self.gener = generate.Generator("folder7")
self.gener.generate()
self.cl = clean.MyClean()
import numpy as np
from PIL import Image, ImageDraw
import random, math
import generate as gen
import world
w = 5
h = 5
def main_loop(layers, width, height, generator):
for layer in range(layers):
generator.one_pass(100)
generator.save_image()
if __name__ == "__main__":
gen = gen.Generator(w, h)
main_loop(10, w, h, gen)
wrld = world.worldify(Image.open("output.png", "r"))
image = wrld.clean(w, h)
gen.set_image(image)
return radii
def performance_from_radii(rx, ry):
performances = [[5, 4, 3, 4, 5], [4, 3, 2, 3, 4], [3, 2, 1, 2, 3],
[4, 3, 2, 3, 4], [5, 4, 3, 4, 5]]
cluster_centers = [1, 3, 5, 7, 9]
x_cluster = cluster_centers.index(
min(cluster_centers, key=lambda x: abs(x - rx)))
y_cluster = cluster_centers.index(
min(cluster_centers, key=lambda y: abs(y - ry)))
performance = performances[x_cluster][y_cluster]
return performance
if __name__ == '__main__':
import generate
generator = generate.Generator(num_params=1024)
latent_vectors, _ = generator.load_training_objects(300)
for latent in latent_vectors:
points = 10 * generator.generate_return_pts(latent)
radii = getMinVolEllipse(P=points)
performance = performance_from_radii(radii[0], radii[1])
print(performance)
#load_file = './AtlasNet/data/ellipsoid_points/ellipsoid_2439.pkl'
#import pickle
#with open(load_file,'rb') as f:
# points = pickle.load(f)
#radii = getMinVolEllipse(P=points)
#performance = performance_from_radii(radii[0],radii[1])
import pickle
import torch
import generate as g
with open("character_data.pickle", "rb") as f:
(chars, indx_to_chars, chars_to_indx, n_chars) = pickle.load(f)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
input_size = n_chars
hidden_size = 50
dropout = 0.25
n_layers = 2
path = "model.mod"
gen = g.Generator(input_size, hidden_size, dropout, device, n_layers, path)
print(gen.generate(indx_to_chars, chars_to_indx, -1))
"""
Test routines for generate.py
author: Eduardo Villasenor
created-on: 028/08/17
"""
import generate
generator = generate.Generator()
# Initial parameters
ps = 0.0
pm = 0.009
pg = 0.009
pn = 0.0
system_size = 4
parity = "Z"
function = "LOCAL"
# Calculate chi matrix
chi = generator.ask_model(ps=ps, pm=pm, pg=pg, pn=pn, stab_size=system_size,
parity=parity, protocol=function)
def run_evo(data_init=True,
sparse=False,
lam=1e-5,
num_params=1024,
load_file=None,
maxiter=5,
out_name=None,
bound=1,
pop_size=120,
mutation_rate=0.05,
recomb_rate=0.9,
norm=0):
pickle_file = './pickle/' + out_name + '.pkl'
trial = int(out_name[-1])
if os.path.exists(pickle_file) == False:
Generator = generate.Generator(num_params)
start = 0
learning_curve = []
if sparse:
adj_learning_curve = []
max_scores = []
max_name = 'no score'
population = []
init_names = []
l0_norms = []
if data_init:
population, init_names = Generator.load_training_objects(
pop_size, trial
) #we seed the initialization per trial for fair comparisions
else:
for i in range(0, pop_size):
indv = []
for j in range(num_params):
indv.append(np.random.normal())
population.append(indv)
else:
print('Loading from pickle file')
with open(pickle_file, 'rb') as f: # Python 3: open(..., 'rb')
if sparse:
population, learning_curve, adj_learning_curve, max_scores, max_name, l0_norms, init_pop, Generator = pickle.load(
f)
else:
population, learning_curve, max_scores, max_name, l0_norms, init_pop, Generator = pickle.load(
f)
start = len(learning_curve)
print("Start: {}".format(start))
tictoc = TicToc()
previous_generation = []
num_cores = mp.cpu_count()
if (not max_scores):
max_score = 1e6
else:
max_score = max_scores[-1]
for i in range(start, maxiter):
tictoc.tic()
worker_args = []
res = []
current_generation = []
for j in range(0, pop_size):
#--- MUTATION ---------------------+
# select three random vector index positions [0, popsize), not including current vector (j)
candidates = list(range(0, pop_size))
candidates.remove(j)
random_index = random.sample(candidates, 3)
x_1 = population[random_index[0]]
x_2 = population[random_index[1]]
x_3 = population[random_index[2]]
x_t = population[j] # target individual
# subtract x3 from x2, and create a new vector (x_diff)
x_diff = [x_2_i - x_3_i for x_2_i, x_3_i in zip(x_2, x_3)]
# multiply x_diff by the mutation factor (F) and add to x_1
v_donor = [
x_1_i + mutation_rate * x_diff_i
for x_1_i, x_diff_i in zip(x_1, x_diff)
]
v_donor = evalu.ensure_bounds(v_donor, (-bound, bound))
#--- RECOMBINATION ----------------+
v_trial = []
for k in range(len(x_t)):
crossover = random.random()
if crossover <= recomb_rate:
v_trial.append(v_donor[k])
else:
v_trial.append(x_t[k])
name = "G" + str(i) + "_i" + str(j)
points = 10 * Generator.generate_return_pts(
v_trial
) #multiply by 10 to undo AtlasNet's normalization of PCs
worker_args.append((name, points, v_trial, sparse, lam, norm))
pool = mp.Pool(num_cores - 1)
res = pool.starmap(evalu._EllipsoidEvalFunc,
worker_args) #or _EvaluationFunction for boats
current_generation = []
for r in res:
if r is not None:
current_generation.append(r)
pool.close()
pool.join()
# sort the dictionary by "output" and take the t
current_generation.extend(previous_generation)
current_generation = sorted(current_generation,
key=lambda k: k["output"])
curr_scores = [k["output"] for k in current_generation]
curr_names = [k["name"] for k in current_generation]
curr_l0 = [k["l0"] for k in current_generation]
if (sparse):
adj_scores = [k["adj_score"] for k in current_generation]
adj_learning_curve.append(np.mean(adj_scores))
l0_norms.append(np.mean(curr_l0))
previous_generation = current_generation[:pop_size]
population = [genome["input"] for genome in previous_generation]
if i == 0:
init_pop = population
#adjust the scores for l_0 norm penalty for learning curve plot for direct comparisons
# if sparse:
# adj_scores = []
# for j in range(len(curr_scores)):
# adj_scores.append(curr_scores[j] - lam*curr_l0[j]/num_params)
learning_curve.append(np.mean(curr_scores))
if (curr_scores[0] < max_score):
max_name = curr_names[0]
max_score = curr_scores[0]
max_scores.append(max_score)
#dump pickle file
with open(pickle_file, 'wb') as f:
if sparse:
pickle.dump([
population, learning_curve, adj_learning_curve, max_scores,
max_name, l0_norms, init_pop, Generator
], f)
else:
pickle.dump([
population, learning_curve, max_scores, max_name, l0_norms,
init_pop, Generator
], f)
#print stuff
print('GENERATION: {}'.format(i))
print('Average Score This Generation: {}'.format(np.mean(curr_scores)))
if sparse:
print('Average Adjusted Score This Generation: {}'.format(
np.mean(adj_scores)))
print('Average l0-Norm This Generation: {}'.format(np.mean(curr_l0)))
