def update(self, pops=None):
"""Master update function for the UI - redraw the visuals each update.
"""
plt.clf()
bg = np.max(self.terrain.heightmap) - self.terrain.heightmap
plt.imshow(bg, cmap='Blues', interpolation='nearest')
vmap = util.mask(self.terrain.vegetation, 1e-8)
plt.imshow(self.norm(vmap), cmap='Greens', alpha=0.8)
plt.imshow(util.mask(self.terrain.climates, 0.1),
cmap='Oranges',
interpolation='none',
alpha=0.3)
# render Terran populations
if pops is not None:
for i in range(len(pops)):
if len(pops[i].terrans) > 0:
pmap = pops[i].get_positions()[0]
pmap = util.mask(pmap, 0.1)
plt.imshow(pmap, cmap='Spectral', interpolation='none')
# render storms
if np.max(self.weather.weathermap) > 0:
plt.imshow(util.mask(self.weather.weathermap, 0.1),
cmap='Purples',
interpolation='none',
alpha=0.6)
plt.draw()
plt.pause(0.0001)
def inst():
yield delay(200 * nsec)
addr = Signal(intbv(0x10)[len(bus.A):])
while 1:
yield system.CLK.posedge
bus.CS_B.next = 0
bus.RAS_B.next = 0
bus.A.next = 0x4
bus.BA.next = 0x2
yield system.CLK.posedge
bus.CS_B.next = 1
bus.RAS_B.next = 1
bus.A.next = ~0 & mask(bus.A)
bus.BA.next = ~0 & mask(bus.BA)
yield system.CLK.posedge
bus.CS_B.next = 0
bus.CAS_B.next = 0
bus.A.next = addr
bus.BA.next = 0
yield system.CLK.posedge
bus.CS_B.next = 1
bus.CAS_B.next = 1
bus.A.next = ~0 & mask(bus.A)
bus.BA.next = ~0 & mask(bus.BA)
addr.next = 0
if addr != n - 1:
addr.next = addr + 4
yield system.CLK.posedge
bus.CS_B.next = 0
bus.CAS_B.next = 0
bus.A.next = addr
yield system.CLK.posedge
bus.CS_B.next = 1
bus.CAS_B.next = 1
bus.A.next = ~0 & mask(bus.A)
addr.next = 0
if addr != n - 1:
addr.next = addr + 4
yield delay(interval - 1)
def __init__(self, width, data = None):
self.width = width
self.buf = []
if data:
mask = util.mask(self.width)
self.buf = [x & mask for x in data]
self.wr_idx = len(self.buf)
self.rd_idx = 0
def __init__(self, width, data = None):
self.width = width
self.buf = []
if data:
mask = util.mask(self.width)
self.buf = [x & mask for x in data]
self.wr_idx = len(self.buf)
self.rd_idx = 0
def masks(n_ite, ifrun):
'''对utils里的mask 的集成
'''
#n_ite=1
path = 'D:\\result\\train_result\\' + str(n_ite) + 'ite'
name_from = [
'predict_' + str(n_ite) + '_sub1_merge',
'predict_' + str(n_ite) + '_sub2_merge',
'predict_' + str(n_ite) + '_sub3_merge'
]
name_to = [
'predict_' + str(n_ite) + '_sub1_mask_correct',
'predict_' + str(n_ite) + '_sub2_mask_correct',
'predict_' + str(n_ite) + '_sub3_mask_correct'
]
if ifrun[0]:
'''sub1'''
if not os.path.exists(path + '\\' + name_to[0]):
os.makedirs(path + '\\' + name_to[0])
util.mask(path + '\\' + name_from[0], path + '\\' + name_to[0])
if ifrun[1]:
'''sub2'''
if not os.path.exists(path + '\\' + name_to[1]):
os.makedirs(path + '\\' + name_to[1])
util.mask(path + '\\' + name_from[1], path + '\\' + name_to[1])
if ifrun[2]:
'''sub3'''
if not os.path.exists(path + '\\' + name_to[2]):
os.makedirs(path + '\\' + name_to[2])
util.mask(path + '\\' + name_from[2], path + '\\' + name_to[2])
def __init__(self, game):
"""
Constructor for the Dragon
"""
grid = util.str_to_array(graphics.DRAGON)
grid_col = util.tup_to_array(grid.shape,
(col.Back.RED, col.Fore.BLACK))
grid_col = util.mask(grid, grid_col)
self.game = game
super().__init__(grid, \
np.array([config.WIDTH - 50, 0], dtype="float64"), \
0, grid_col, config.DRAGONBOSS_LIVES, self.game)
def __init__(self, position, orientation=None):
"""
Constructor for FireBeam
Args:
position [px, py] : Initial position of the FireBeam
orientation (int) : 0 -> config.FIREBEAM_MAX, type of FireBeam
"""
if orientation is None or orientation < 0 or orientation > config.FIREBEAM_MAX:
orientation = util.randint(0, config.FIREBEAM_MAX - 1)
rep = util.str_to_array(graphics.FIREBEAM[orientation])
color = util.tup_to_array(rep.shape, (col.Back.RED, col.Fore.YELLOW))
super().__init__(rep, position, np.array([-2., 0.]),
util.mask(rep, color))
def update(self):
"""Master update function for the weather map."""
self.weathermap = np.zeros((self.size, self.size))
# update storms & add them to map
if (len(self.storms) > 0):
new_storms = []
for i in range(len(self.storms)):
self.storms[i][0][0] += self.storms[i][1][0]
self.storms[i][0][1] += self.storms[i][1][1]
# wrap storms around map
if self.storms[i][0][0] >= self.size:
self.storms[i][0][0] = 0
if self.storms[i][0][1] >= self.size:
self.storms[i][0][1] = 0
if self.storms[i][0][0] < 0:
self.storms[i][0][0] = self.size - 1
if self.storms[i][0][1] < 0:
self.storms[i][0][1] = self.size - 1
self.storms[i][2] *= (1 - self.storm_decay)
if self.storms[i][2] > 0.1:
new_storms.append(self.storms[i])
self.weathermap[int(self.storms[i][0][0]),
int(self.storms[i][0][1])] = self.storms[i][2]
self.storms = new_storms
self.weathermap = proc_smooth(self.weathermap, self.sigma)
self.weathermap = util.mask(self.weathermap,
np.average(self.weathermap) * 1.2)
if random.random() < self.storm_chance:
# generate random position vector for storm
coords = [
random.randint(0, self.size - 1),
random.randint(0, self.size - 1)
]
# generate random movement vector for storm
direction = [
random.uniform(-self.storm_speed, self.storm_speed),
random.uniform(-self.storm_speed, self.storm_speed)
]
self.storms.append([coords, direction, 1.0])
def get_rep(self, phase_offset=0):
"""
Returns the live representation of dragon
"""
rep = np.full((self.height, self.width), " ")
color = util.tup_to_array(rep.shape, (col.Back.BLACK, col.Fore.GREEN))
dragon_head = util.str_to_array(graphics.DRAGON_HEAD)
head_h, head_w = dragon_head.shape
# phase_offset = 4 * (phase_offset // 4)
_h, _w = self.get_shape()
body_width = _w - head_w
_y = np.sin(np.linspace(-np.pi, np.pi, body_width) + phase_offset)
_y *= (_h / 2)
_y += (_h / 2)
_y = _y.astype(int)
for i in range(body_width):
rep[_y[i]][i] = "~"
if _y[i] > self.height - 2:
rep[_y[i] - 2][i] = "~"
else:
rep[_y[i] + 1][i] = "~"
if _y[i] == 0:
rep[2][i] = "~"
else:
rep[_y[i] - 1][i] = "~"
beg_h = int(min(_y[-1], self.height - head_h))
rep[beg_h:beg_h + head_h, -head_w:] = dragon_head
self.head = self.get_position() + beg_h
color = util.mask(rep, color)
return rep, color
def from_string(rep,
position=np.array([0., 0.]),
velocity=np.array([0., 0.]),
accel=np.array([0., 0.]),
gravity=0,
color=("", "")):
"""
Creates a GameObject from string
Args:
rep (2D np.array) : The object representation (How does it look?)
position ([x, y]) : Initial position of the object
velocity ([vx, vy]) : Speed with which the object moves to left
accel ([fx, fy]) : accel in both dir
gravity (float) : Gravitational accel on that object
color (str, str) : Color of each character (bg, fg)
Returns:
GameObject with all the parameters
"""
grid = util.str_to_array(rep)
color = util.mask(grid, util.tup_to_array(grid.shape, color))
return GameObject(grid, position, velocity, accel, gravity, color)
def post_process(self):
self.init_metrics()
self.mean_times = util.mask(self.times).cumsum(axis=0).mean(axis=1)
# self.mean_times = np.mean(np.array([np.cumsum(self.times[i]) for i in \
# range(self.k)]),axis=0)
def metrics(A, b, X):
d = X.shape[1]
diff = A.dot(X) - np.tile(b, (d, 1)).T
error = 0.5 * np.diag(diff.T.dot(diff))
RMSE = np.sqrt(error / b.size)
den = np.sum(b) / np.sqrt(b.size)
pRMSE = RMSE / den
plus = A.dot(X) + np.tile(b, (d, 1)).T
# GEH metric [See https://en.wikipedia.org/wiki/GEH_statistic]
GEH = np.sqrt(2 * diff**2 / plus)
meanGEH = np.mean(GEH, axis=0)
maxGEH = np.max(GEH, axis=0)
GEHunder5 = np.mean(GEH < 5, axis=0)
GEHunder1 = np.mean(GEH < 1, axis=0)
GEHunder05 = np.mean(GEH < 0.5, axis=0)
GEHunder005 = np.mean(GEH < 0.05, axis=0)
return {
'error': error,
'RMSE': RMSE,
'pRMSE': pRMSE,
'mean_GEH': meanGEH,
'max_GEH': maxGEH,
'GEH_under_5': GEHunder5,
'GEH_under_1': GEHunder1,
'GEH_under_0.5': GEHunder05,
'GEH_under_0.05': GEHunder005,
}
def populate(d, m):
for (k, v) in m.iteritems():
if k not in d:
d[k] = []
d[k].append(v)
return d
for i, (train, test) in enumerate(self.kf):
d = len(self.states[i])
b_train, A_train = self.b[train], self.A[train, :]
b_test, A_test = self.b[test], self.A[test, :]
self.x_hat = self.N.dot(np.array(self.states[i]).T) + \
np.tile(self.x0,(d,1)).T
# Aggregate error
m = metrics(A_train, b_train, self.x_hat)
self.train = populate(self.train, m)
logging.debug(
'Train: %8.5e to %8.5e (%8.5e)' %
(m['RMSE'][0], m['RMSE'][-1], m['RMSE'][0] - m['RMSE'][-1]))
m = metrics(A_test, b_test, self.x_hat)
self.test = populate(self.test, m)
logging.debug(
'Test: %8.5e to %8.5e (%8.5e)' %
(m['RMSE'][0], m['RMSE'][-1], m['RMSE'][0] - m['RMSE'][-1]))
# TODO deprecate
x_last = self.x_hat[:, -1]
dist_from_true = np.max(np.abs(x_last - self.x_true))
start_dist_from_true = np.max(np.abs(self.x_true - self.x0))
logging.debug('max|x-x_true|: %.2f\nmax|x_init-x_true|: %.2f' \
% (dist_from_true, start_dist_from_true))
# Error metric by link class
inds = np.digitize(b_train, self.bins)
indts = np.digitize(b_test, self.bins)
train_bin, test_bin = {}, {}
for j in range(1, self.nbins + 2):
ind = inds == j
indt = indts == j
if np.all(indt == False) or np.all(ind == False):
for k in KEYS:
if k not in train_bin:
train_bin[k] = []
train_bin[k].append(None)
for k in KEYS:
if k not in test_bin:
test_bin[k] = []
test_bin[k].append(None)
continue
b_bin, A_bin = b_train[ind], A_train[ind, :]
b_bint, A_bint = b_test[indt], A_test[indt, :]
m = metrics(A_bin, b_bin, self.x_hat)
train_bin = populate(train_bin, m)
m = metrics(A_bint, b_bint, self.x_hat)
test_bin = populate(test_bin, m)
self.train_bin = populate(self.train_bin, train_bin)
self.test_bin = populate(self.test_bin, test_bin)
# Summary metrics
self.mean_time = np.mean([np.cumsum(self.times[i])[-1] for i in \
range(self.k)])
self.mean_error = np.mean([self.test['error'][i][-1] for i in \
range(self.k)])
self.mean_RMSE = np.mean([self.test['RMSE'][i][-1] for i in \
range(self.k)])
logging.debug('mean time: %8.5e, mean error: %8.5e' %
(self.mean_time, self.mean_error))
print '\n\n'
def __call__(self, sample):
gene = np.array(list(sample['gene'].sequence))
next_gene = np.array(list(sample['next_gene'].sequence))
gene_seq = mutate(gene, self.mutate_prob, self.vocab)
gene_seq = mask(gene_seq, prob=self.mask_prob, mask_chr=self.mask_chr)
return {'gene_seq': gene_seq, 'next_seq': next_gene}
def seq():
if self.RD:
self.DAT.next = self.ADR & mask(self.DAT)
