def findPath(self,a,start):
tmp = start
last = np.copy(tmp)
end = False
lim = self.game.dim-1
while(end == False):
if tmp[0] < lim and a[tmp[0]+1,tmp[1]] < a[tmp[0],tmp[1]]and a[tmp[0]+1,tmp[1]] >= 0:
last = numpy.copy(tmp)
tmp = ar([tmp[0]+1,tmp[1]])
elif tmp[0]>0 and a[tmp[0]-1,tmp[1]]< a[tmp[0],tmp[1]]and a[tmp[0]-1,tmp[1]] >= 0:
last = np.copy(tmp)
tmp = ar([tmp[0]-1,tmp[1]])
elif tmp[1] < lim and a[tmp[0],tmp[1]+1]< a[tmp[0],tmp[1]]and a[tmp[0],tmp[1]+1] >= 0:
last = np.copy(tmp)
tmp = ar([tmp[0],tmp[1]+1])
elif tmp[1]>0 and a[tmp[0],tmp[1]-1]< a[tmp[0],tmp[1]] and a[tmp[0],tmp[1]-1] >= 0:
last = np.copy(tmp)
tmp = ar([tmp[0],tmp[1]-1])
else:
end=True
dire = last - self.snake[0]
return dire
def serial_thread(PORT, BAUD, qu):
sensorvals = ar([0., 0., 0., 0.])
line = ''
sport = None
SFLAG = 0
while True:
if (SFLAG == 0):
try:
sport = serial.Serial(PORT, BAUD)
SFLAG = 1
except:
SFLAG = 0
else:
try:
line = sport.readline().strip()
strvals = line.split('\t')
#print(line)
except:
SFLAG = 0
sport.close()
try:
sensorvals = ar([float(i) for i in strvals])
#print "Serial Thread: "+str(sensorvals)
qu.append(sensorvals)
except:
pass
def stringToDir(self,strg):
if strg == 'left':
return ar([-1,0])
elif strg == 'up':
return ar([0,1])
elif strg == 'right':
return ar([1,0])
elif strg == 'down':
return ar([0,-1])
def calcAntenaVert(self):
xy =self.posi * self.s + self.offset
d = self.snake.direc
rotMat = np.vstack([d,d[::-1]])
v = ar([self.s,0.5*self.s])
w = ar([self.s,-0.5*self.s])
vv = xy + np.dot(rotMat,v)
ww = xy + np.dot(rotMat,w)
r = np.vstack([vv,xy,ww]).reshape(6)
return list(r)
def get_statistics(self,population,sample,get_distances=False,original_fitnesses=False):
if original_fitnesses:
original_fitnesses = ar(self.fitness_many(population))
sample_fitnesses = ar(self.fitness_many(sample))
if original_fitnesses == False:
original_fitnesses = sample_fitnesses
if get_distances:
differences = sample_fitnesses - original_fitnesses
distances = [distance.hamming(population[k],sample[k]) for k in range(len(sample))]
else:
differences = []
distances = []
return original_fitnesses,sample_fitnesses,differences,distances
def draw(self):
self.clear(self.viewport, globals.background)
dirties=set(self.level.getDirtyLocations()).union(self.perception.getDirtyLocations())
#dirties=[(i,j) for j in xrange(self.height) for i in xrange(self.width)]
gray=globals.darkest_gray
gray=ar((gray,gray,gray))
white=1.0
white=ar((white,white,white))
npcs=[]
for loc in dirties:
if self.perception[loc].cover==1.0:
self[loc].hue=copy(gray)
else:
self[loc].hue=copy(white)
#obj = self.perception[loc].top().obj if self.perception[loc].top() else None
#if isinstance(obj, Actor) and obj!=self.perception.actor:
# npcs.append((ar(loc), obj.facing, STATE_HUE_MAP[obj.state]))
"""
for loc, facing, hue in npcs:
print loc, facing, hue
index=HEX_NEIGHBORS.index(facing)
self[tuple(loc+facing)].hue+=hue
self[tuple(loc+HEX_NEIGHBORS[index-1])].hue+=hue/2
try:
self[tuple(loc+HEX_NEIGHBORS[index+1])].hue+=hue/2
except IndexError:
self[tuple(loc+HEX_NEIGHBORS[0])].hue+=hue/2
"""
for loc in dirties:
try:
element=self.perception[loc].top()
#self[loc].image = globals.font.render(element.symbol,True,ar(map(max,map(min, self[loc].hue, MAX_COLOR), MIN_COLOR))*element.hue*(255,255,255))
self[loc].image = element.obj.render(ar(map(max,map(min, self[loc].hue, MAX_COLOR), MIN_COLOR))*(255,255,255))
if element.facing and element.obj != self.ctx.pc and (element.facing[0] or element.facing[1]):
h, w = globals.cell_height-1, globals.cell_width-1
pointlist = ()
vertical, horizontal = h*((element.facing[0] or element.facing[1])*0.5+0.5), w*((element.facing[1]-element.facing[0])*0.5+0.5)
print horizontal, w/2.0
if horizontal == w/2.0:
pointlist = ((horizontal-3, vertical-cmp(vertical, 1)*3), (horizontal, vertical), (horizontal+3, vertical-cmp(vertical,1)*3))
else:
pointlist = ((horizontal, vertical-cmp(vertical,1)*3), (horizontal, vertical), (horizontal-cmp(horizontal,1)*3, vertical))
draw.lines(self[loc].image, STATE_HUE_MAP[element.obj.state], False, pointlist, True)
except AttributeError:
pass
pygame.display.update(super(GridView, self).draw(self.viewport))
for tile in self.level.tiles:
tile.dirty=0
for tile in self.perception.tiles:
tile.dirty=0
def checkLBUBMix(self, opts, lb, ub):
# these are indices to bound
lbindices = (0,3)
ubindices = {}
ubindices["t"] = (3,6)
ubindices["n"] = "a"
ubindices["N"] = "a"
ubindices["l"] = [3,4,5]
ubindices["a"] = ar([3,4,5],dtype=uint)
ubindices["f"] = ar([3,4,5],dtype=float64)
ubvalues = {}
ubvalues["s"] = ub
ubvalues["l"] = [ub, ub, ub]
ubvalues["a"] = ar([ub, ub, ub])
lbvalues = {}
lbvalues["s"] = lb
lbvalues["l"] = [lb, lb, lb]
lbvalues["a"] = ar([lb, lb, lb])
lp = LP()
lp.setLowerBound(lbindices, lbvalues[opts[1]])
if opts[0] == "N":
lp.getIndexBlock(ubindices["N"], 3)
lp.setUpperBound(ubindices[opts[0]], ubvalues[opts[1]])
lp.setObjective([1,1,1,-1,-1,-1])
for num_times in range(2): # make sure it's same anser second time
lp.solve()
self.assertAlmostEqual(lp.getObjectiveValue(), lb*3 - ub*3)
v = lp.getSolution()
self.assert_(len(v) == 6)
self.assertAlmostEqual(v[0], lb)
self.assertAlmostEqual(v[1], lb)
self.assertAlmostEqual(v[2], lb)
self.assertAlmostEqual(v[3], ub)
self.assertAlmostEqual(v[4], ub)
self.assertAlmostEqual(v[5], ub)
def __init__(self,
train_in,
train_out,
input_names=None,
gaussian_radius=0.3):
train_in = matrix(train_in, dtype=float)
train_out = ar(train_out)
order = train_out.argsort()
train_in = train_in[order, ]
train_out = train_out[order]
inputs_num = train_in.shape[1]
self._classes = unique(train_out,
return_index=True,
return_inverse=True,
return_counts=True)
self._classes_num = len(self._classes[0])
if input_names is None: input_names = [None for i in range(inputs_num)]
self._input_layer = NeuronsLayer(
[InputNeuron(name=input_names[i]) for i in range(inputs_num)])
self._pattern_layer = NeuronsLayer([
PatternNeuron(train_in[i, ].tolist()[0], gaussian_radius)
for i in range(train_in.shape[0])
])
self._summa_layer = NeuronsLayer([
SummaNeuron(int(self._classes[3][i]))
for i in range(self._classes_num)
])
self._out_neuron = OutputNeuron(int(self._classes_num),
self._classes[0].astype(str))
def ForceSystem(self):
XRotated = np.hstack([
ar(self.Concrete.StressPolygon.Centroid[0]),
self.Reinforcements.Coordinate.X
])
YRotated = np.hstack([
ar(self.Concrete.StressPolygon.Centroid[1]),
self.Reinforcements.Coordinate.Y
])
Compression = np.hstack([
ar(self.Concrete.CompressionForce),
self.Reinforcements.CompressionForce
])
return force_system(
coordinate(XRotated, YRotated).rotate(-self.Concrete.Angle),
Compression, self.PnMax)
def sin(self, val, degree=False):
"""Calculates SIN of a value and its errors"""
if degree:
val = self.deg2rad(val)
ret = sin(val[0]) * cos(val[1])
eret = sin(val[1]) * cos(val[0])
return (ar([ret, eret]))
def mean_read(self, number):
self.logger.log("Calculating mean and standard deviation of ({}) samples".format(number))
try:
data = []
c = 0
self.con = self.connect()
for i in range(number):
d = self._read_data_()
if d is not None:
data.append(d)
c += 1
sleep(0.01)
self.close()
data = ar(data)
mean_data = mean(data, axis=0)
stdv_mag = std(data[:, 1])
stdv_sqm_mag = std(data[:, 2])
stdv_tmp = std(data[:, 3])
return({"JD": mean_data[0], "Mag": mean_data[1], "STDV": stdv_mag,
"CMag": mean_data[2], "CSTDV": stdv_sqm_mag,
"Temperature": mean_data[3], "TemperatureSTDV": stdv_tmp,
"N": number, "Valid": c})
except Exception as e:
self.logger.log(e)
self.close()
def __equal_linear_altitude_slicer__(self, pieces):
"""Generates AltAz for given pieces"""
self.logger.log("Calculating altitudes for {} pieces".format(pieces))
try:
return rad2deg(arccos(ar(range(0, pieces + 1)) / pieces))
except Exception as excpt:
self.logger.log(excpt)
def findDirection(self):
sm = self.makeScoreMap()
dbm,cm = self.makeClimbMat(sm)
bestBonIdx = self.findBestBonus(dbm)
dire = self.snake.direc
if bestBonIdx > -1:
goTo = self.game.bonusList[bestBonIdx].posi
dire = self.findPath(cm,goTo)
#~ Else, we pick randomly a point near the middle:
else:
found = False
i = 0.05
while (found == False and i < 0.5):
XY = np.random.normal((self.game.dim-1)/2,i*self.game.dim,2).astype(int)
#~ Determines validity of the point:
#~ The 3x3 area around is empty
area = cm[XY[0]-1:XY[0]+2,XY[1]-1:XY[1]+2]
t0 = (np.sum(area < 0) == 0)
t1 = np.all(XY > 0)and np.all(XY < self.game.dim)
test = t0 and t1
if test:
dire = self.findPath(cm,XY)
found=True
else:
i+=0.05
#~ by default:
if found == False:
dire = ar([0,0])
toCent = self.snake[0] - self.game.dim/2
q = max(abs(toCent))
if not q==0:
toCent = -toCent/q
if toCent[0] == toCent[1]:
if toCent[0] == 1:
toCent[0] = 0
if toCent[0] == -1:
toCent[0] = 0
if toCent[0] == 0:
toCent[0] = 1
dire = toCent
else:
dire = ar([1,0])
self.addDirAsKeyStack(dire)
def readPolyline(self):
"""Lee solo dos tipos de linea LWPOLYLINE (2D) y POLYLINE (3D), y devuelve un array con el siguiente formato: \n
--> X, Y, Z, File, Layer, Atrib, IDx """
count = 0
s = 0
t = 0
tt = []
File = self.NameFile
PointResult = []
Project = "Test_1"
Period = 1
for idx, Gpline in enumerate(self.Sheet.query('LWPOLYLINE')):
Elev = Gpline.dxf.elevation
Index = idx
Layer = Gpline.dxf.layer
Atrib1 = 'Cut' if Layer[:3] in {
'Cut', "Abi", "POL"
} else 'Road' # Por lo pronto depende del nombre
Element_type = 'Road' if Atrib1 == 'Road' else 'Cut' if Gpline.dxf.flags == 1 else 'aa' # Por lo pronto depende del nombre
Atrib = [
Elev, File, Layer, Atrib1, Index, Element_type, Project, Period
]
with Gpline.points() as Lines:
for pp, point in enumerate(Lines):
count += 1
if Atrib[5] == 'aa':
tt.append(Atrib[2])
continue
else:
PointIter = list(point[:2]) + list(Atrib)
PointResult.append(PointIter)
s = idx
s += 1
for idx, GGpoly in enumerate(self.Sheet.query('POLYLINE')):
Index = idx + s
Layer = GGpoly.dxf.layer
Atrib1 = 'Cut' if Layer[:3] in {
'Cut', "Abi", "POL"
} else 'Road' # Por lo pronto depende del nombre
Element_type = 'Road' if Atrib1 == 'Road' else 'Cut' if Gpline.dxf.flags == 1 else 'bb' # Por lo pronto depende del nombre
Atrib = [File, Layer, Atrib1, Index, Element_type, Project, Period]
for i, locations in enumerate(GGpoly.points()):
count += 1
if Atrib[5] == 'bb':
tt.append(Atrib[2])
continue
else:
PointIter = next if Element_type == None else list(
locations) + Atrib
PointResult.append(PointIter)
g = Conq.LoadData(File, Project)
g.LoadRoads(PointResult)
VecPoly = ar(PointResult)
tt1 = list(np.unique(tt, return_counts=True)[0])
print("Corte {} se encuentra abierto, por favor revisar".format(tt1))
# TableResult = pd.DataFrame(data=VecPoly, columns=[
# "X", "Y", "Z", "File", "Layer", "Atrib", "IDx", "Element_type", "Project", "Period"])
# TableResult.to_csv("Poly.csv")
return VecPoly
def save_numpy(self, src, arr, dm=" ", h=""):
"""Writes an array to a file"""
self.logger.log("Writing to {0}".format(src))
try:
arr = ar(arr)
savetxt(src, arr, delimiter=dm, newline='\n', header=h)
except Exception as excpt:
self.logger.log(excpt)
def _vectorize(self, segment):
if segment is None:
return None
seg=ar(segment)
vector=seg[1]-seg[0]
vector/=sqrt(sum(pow(vector,2)))
seg[1]=vector
return seg
def write_array(self, src, arr, dm=" ", h=""):
"""Writes an array to a file"""
self.logger.info("Writing to {0}".format(src))
try:
arr = ar(arr)
savetxt(src, arr, delimiter=dm, newline='\n', header=h)
except Exception as e:
self.logger.error(e)
def __equal_area_azimuth_slicer__(self, pieces):
"""Generates AltAz widenings"""
self.logger.log(
"Calculating number of areas for {} pieces".format(pieces))
try:
return 1 + ar(range(0, pieces)) * 2
except Exception as excpt:
self.logger.log(excpt)
def create_population_with_unif_cross(self,sampled_population,population,cross_rate=0.1):
new_population = []
for i,p in enumerate(population):
mask = np.where(np.random.binomial(1,cross_rate,len(p)) == 1)[0]
crossed = ar(p)
crossed[[mask]] = sampled_population[i][[mask]]
new_population.append(crossed)
return new_population
def multiply(self, val1, val2):
"""Calculates multipication of two value and their errors"""
try:
ret = val1[0] * val2[0]
except Exception as e:
self.etc.print_if(e)
ret = None
try:
eret = ret * power(
power(val1[1] / val1[0], 2) + power(val2[1] / val2[0], 2), 0.5)
except Exception as e:
self.etc.print_if(e)
eret = None
if eret is not None:
return (ar([ret, abs(eret)]))
else:
return (ar([ret, eret]))
def _recognize(self, X):
inp = self._input_layer.feed(X, False)
pattern = ar(self._pattern_layer.feed(inp, True))
summa_inp = list()
for i in range(len(self._classes[0])):
summa_inp.append(pattern[self._classes[2] == i])
summa = self._summa_layer.feed(summa_inp, False)
return self._out_neuron.feed(summa)
def ar_sum_inner(self, in_arr):
"""Calculates sum of all values and their error given in an array
Calls sum method to do so"""
the_sum = in_arr[0]
for i in in_arr[1:]:
the_sum = self.sum(the_sum, i)
return (ar(the_sum))
def checkInconsistentSubarrays(self, opts):
values = {}
indices = {}
indices["t"] = (0,3)
indices["n"] = "a"
indices["N"] = "a"
indices["l"] = [0,1,2]
indices["a"] = ar([0,1,2],dtype=uint)
indices["f"] = ar([0,1,2],dtype=float64)
indices["e"] = None # empty
A = [[1,0, 0],
[0,1], # inconsistent; does this get caught?
[0,0.5,0]]
values = {}
values["L"] = A
values["l"] = [ar(le) for le in A]
values["B"] = [[1, 0, 0], [[1,0,0]], [0,1,1]]
values["C"] = ones((1,3,3) )
values["D"] = [[1, 0, 0], [1,1,[1]], [0,1,1]]
values["E"] = [[1, 0, 0], (1,1,1), [0,1,1]]
targets = {}
targets["s"] = 1
targets["l"] = [1,1,1]
targets["a"] = ar([1,1,1],dtype=uint)
targets["f"] = ar([1,1,1],dtype=float64)
lp = LP()
if opts[0] == "N":
lp.getIndexBlock(indices["N"], 3)
io = indices[opts[0]]
vl = values [opts[1]]
tr = targets[opts[2]]
ob = [1,2,3]
if io is None:
self.assertRaises(ValueError, lambda: lp.addConstraint(vl, ">=", tr))
else:
self.assertRaises(ValueError, lambda: lp.addConstraint( (io, vl), ">=", tr))
def equal_angle(self, n_alt, n_az):
try:
altitudes = linspace(0, 90, n_alt + 1)
azimuths = linspace(0, 360, n_az + 1)
ret = []
for altitude in range(len(altitudes) - 1):
for azimuth in range(len(azimuths) - 1):
ret.append(
ar([
altitudes[altitude:altitude + 2],
azimuths[azimuth:azimuth + 2]
]))
return ar(ret)
except Exception as excpt:
self.logger.log(excpt)
def stdv(self, in_arr):
"""Calculates standard deviation of given values and their errors"""
try:
mean = self.mean(in_arr)
the_subs = []
for i in in_arr:
the_subs.append(
self.minor.power(self.minor.sum(i, -1 * mean), 2))
the_subs = ar(the_subs)
sq_sum = self.minor.ar_sum_inner(the_subs)
sq_sum_o_num = self.minor.multiply(sq_sum, [1 / len(the_subs), 0])
ret = self.minor.power(sq_sum_o_num, 0.5)
except Exception as e:
self.etc.print_if(e)
ret = ar([None, None])
return (ret)
def ar_multiply_inner(self, in_arr):
"""Calculates multipication of all values and
their error given in an array
Calls multiply method to do so"""
the_mul = in_arr[0]
for i in in_arr[1:]:
the_mul = self.multiply(the_mul, i)
return (ar(the_mul))
def addDirAsKeyStack(self,dire):
dirStr=''
if sum(dire == ar([-1,0],dtype=int)) == 2:
dirStr="left"
elif sum(dire == ar([1,0],dtype=int)) == 2:
dirStr="right"
elif sum(dire == ar([0,-1],dtype=int)) == 2:
dirStr= "down"
elif sum(dire == ar([0,1],dtype=int)) == 2:
dirStr="up"
if sum(dire == self.snake.direc) == 2: #avoid boost
dirStr =''
if dirStr != '':
self.keyStack.append(dirStr)
def traj_callback(self, traj):
"""stores the trajectory"""
for i in range(len(traj.points)):
posx = traj.points[i].transforms[0].translation.x
posy = traj.points[i].transforms[0].translation.y
posz = traj.points[i].transforms[0].translation.z
velx = traj.points[i].velocities[0].linear.x
vely = traj.points[i].velocities[0].linear.y
velz = traj.points[i].velocities[0].linear.z
accx = traj.points[i].accelerations[0].linear.x
accy = traj.points[i].accelerations[0].linear.y
accz = traj.points[i].accelerations[0].linear.z
dirx = traj.points[i].accelerations[0].angular.x
diry = traj.points[i].accelerations[0].angular.y
dirz = traj.points[i].accelerations[0].angular.z
# "time_from_start" in MultiDOFJointTrajectory is rospy.Duration, to_sec() is needed to convert that to seconds
tt = traj.points[i].time_from_start.to_sec()
self.despos.append(ar([[posx], [posy], [posz]]))
self.desvel.append(ar([[velx], [vely], [velz]]))
self.desacc.append(ar([[accx], [accy], [accz]]))
self.desdirection.append(ar([[dirx], [diry],
[dirz]])) # a dummy direction for now
self.trajectory_time.append(tt)
self.controller = 0 # position controller
f4 = open('trajectory_generated_subscribed.txt', 'a')
f4.write(
"%s, %s, %s, %s, %s, %s, %s, %s, %s, %s\n" %
(tt, posx, posy, posz, velx, vely, velz, accx, accy, accz))
if len(self.trajectory_time) > 100:
self.trajectory_time.pop(0)
self.despos.pop(0)
self.desvel.pop(0)
self.desacc.pop(0)
self.desdirection.pop(0)
#if len(self.trajectory_time) >2000:
# self.trajectory_time.pop(); self.despos.pop(); self.desvel.pop(); self.desacc.pop(); self.desdirection.pop()
"""
def power(self, bs, pw):
"""Calculates power of a value to a constant and its errors"""
try:
ret = power(bs[0], pw)
eret = ret * pw * (bs[1] / bs[0])
except:
ret = None
eret = None
return (ar([ret, abs(eret)]))
def fun(arg):
if len(arg) > 1:
scoreMat = arg[0]
s0 = arg[1]
bonus = np.zeros((1,1),dtype = int) #no used !
out = np.zeros(scoreMat.shape,dtype=int)
C_AI.Lee2(scoreMat,s0,bonus,out)
return out
else:
return ar([0])
def recognize(self, X, y=None):
X = ar(X)
ndims = len(X.shape)
if (ndims == 1):
res = [self._recognize(X)]
elif (ndims == 2):
res = list()
prints = not y is None
if prints:
n = X.shape[0]
i = 0
for row in X:
recognized = self._recognize(row)
res.append(recognized)
if prints:
print(f"{i+1}/{n}", y[i], "recognized as", recognized,
f"({+(recognized==y[i])})")
i += 1
return ar(res)
def background(self, data, isar=False):
"""background of data"""
self.logger.log("Getting Background of data")
try:
bkg = Background(data)
if isar:
bkg = ar(bkg)
return bkg
except Exception as excpt:
self.logger.log(excpt)
def checkUB(self, opts, ub):
# these are indices to bound
indices = {}
indices["t"] = (0,3)
indices["N"] = "a"
indices["l"] = [0,1,2]
indices["a"] = ar([0,1,2],dtype=uint)
indices["f"] = ar([0,1,2],dtype=float64)
ubvalues = {}
ubvalues["s"] = ub
ubvalues["l"] = [ub, ub, ub]
ubvalues["a"] = ar([ub, ub, ub])
lp = LP()
if opts[0] == "N":
lp.getIndexBlock(indices["N"], 3)
lp.setObjective([1,1,1,1,1,1])
lp.addConstraint( ((3,6), [[1,0,0],[0,1,0],[0,0,1]]), "<=", 10)
lp.setMaximize()
lp.setLowerBound(indices[opts[0]], None)
lp.setUpperBound(indices[opts[0]], ubvalues[opts[1]])
for num_times in range(2): # make sure it's same anser second time
lp.solve()
self.assertAlmostEqual(lp.getObjectiveValue(), ub*3 + 10 * 3)
v = lp.getSolution()
self.assert_(len(v) == 6)
self.assertAlmostEqual(v[0], ub)
self.assertAlmostEqual(v[1], ub)
self.assertAlmostEqual(v[2], ub)
self.assertAlmostEqual(v[3], 10)
self.assertAlmostEqual(v[4], 10)
self.assertAlmostEqual(v[5], 10)
def checkUB(self, opts, ub):
# these are indices to bound
indices = {}
indices["t"] = (0, 3)
indices["N"] = "a"
indices["l"] = [0, 1, 2]
indices["a"] = ar([0, 1, 2], dtype=uint)
indices["f"] = ar([0, 1, 2], dtype=float64)
ubvalues = {}
ubvalues["s"] = ub
ubvalues["l"] = [ub, ub, ub]
ubvalues["a"] = ar([ub, ub, ub])
lp = LP()
if opts[0] == "N":
lp.getIndexBlock(indices["N"], 3)
lp.setObjective([1, 1, 1, 1, 1, 1])
lp.addConstraint(((3, 6), [[1, 0, 0], [0, 1, 0], [0, 0, 1]]), "<=", 10)
lp.setMaximize()
lp.setLowerBound(indices[opts[0]], None)
lp.setUpperBound(indices[opts[0]], ubvalues[opts[1]])
for num_times in range(2): # make sure it's same anser second time
lp.solve()
self.assertAlmostEqual(lp.getObjectiveValue(), ub * 3 + 10 * 3)
v = lp.getSolution()
self.assert_(len(v) == 6)
self.assertAlmostEqual(v[0], ub)
self.assertAlmostEqual(v[1], ub)
self.assertAlmostEqual(v[2], ub)
self.assertAlmostEqual(v[3], 10)
self.assertAlmostEqual(v[4], 10)
self.assertAlmostEqual(v[5], 10)
def plot_pblh_diff(y_train, y_test, p_train, p_test, t, ax, bx):
ax.cla()
bx.cla()
# PLOT TRAINING TIME SERIES
ts_train = ar(len(y_train)) # TIME SERIES INPUTS
ax.plot(ts_train, pblh_diff(y_train, p_train), 'b', lw=2)
ax.set_ylim([0, 2])
ax.set_ylabel('$|y_{PBLH}-p_{PBLH}|$ in km')
ax.set_title('training data ')
# PLOT TESTING TIME SERIES
ts_test = ar(len(y_test))
bx.plot(ts_test, pblh_diff(y_test, p_test), 'g', lw=2)
bx.set_ylim([0, 2])
bx.set_ylabel('|y_{PBLH}-p_{PBLH}|$ in km')
bx.set_title('test data : ')
plt.pause(1.0 / 60.0)
def one80(self):
"""Returns 180's value with 10^-9 error"""
try:
ret = 180
eret = 0
except Exception as e:
self.etc.print_if(e)
ret = None
eret = None
return (ar([ret, eret]))
def sphere_demo():
center=np.array((0,0,0))
r=1
cs=sphere_CSTri(center=center,r=r)
cs.center=center
cs.r=r
start_pt=ar([0,0,1])
start_c=0.1
cs.alpha_err=pi/18
cs.gen_triangles(start_pt,start_c)
plotc(cs,before=lambda :plot_sphere(center,r))
def PnMax(self):
FsAtCompStrainLim = np.full(
self.Reinforcements.Fy.shape,
self.Concrete.CompStrainLim * self.Reinforcements.E)
Fs = np.min(ar([self.Reinforcements.Fy, FsAtCompStrainLim]), axis=0)
Ps = np.sum(self.Reinforcements.As * Fs)
Pc = self.Concrete.Abbr * self.Concrete.fc * (
(self.Concrete.B) *
(self.Concrete.H) - np.sum(self.Reinforcements.As))
PnMax = (Pc + Ps) * self.Reinforcements.PhiPureC
return PnMax
def log(self, val):
"""Calculates natural logarithm of a value and its errors"""
try:
ret = log(val[0])
eret = val[1] / val[0]
except Exception as e:
self.etc.print_if(e)
ret = None
eret = None
return (ar([ret, abs(eret)]))
def pi(self):
"""Returns Pi's value with 10^-9 error"""
try:
ret = 3.14159265
eret = 10**-9
except Exception as e:
self.etc.print_if(e)
ret = None
eret = None
return (ar([ret, eret]))
def __init__(self, coord_blocks_triple):
(x, y, self.blocksLOS)=coord_blocks_triple
self.id=(x,y)
self.d_2=x*x+y*y-x*y
coord=Locus.T.dot((x,y,1))
factor=sqrt(coord[0]*coord[0]+coord[1]*coord[1])*2.0
n=ar((-coord[1]/factor, coord[0]/factor)) #rotate -pi/2 and scale producing the 'left' normal
self.coord=coord[0:2]
self.n=n
self.cover_left=0.0
self.cover_right=0.0
def polygon(self, shape, points, rev=False):
img = Image.new('L', shape, 0)
ImageDraw.Draw(img).polygon(points, outline=1, fill=1)
mask = ar(img)
the_mask = mask == 1
if rev:
return(lnot(the_mask))
else:
return(the_mask)
def frame_converter(size, fold):
c = 0
matrices = []
for d in ['house', 'lab', 'office']:
for i in range(3):
for h in ['Lhand', 'Rhand']:
images = os.listdir('E:/CEDL/' + fold + '/' + d + '/' +
str(i + 1) + '/' + h + '/')
for j in range(len(images)):
matrix = imread(
'E:/CEDL/' + fold + '/' + d + '/' + str(i + 1) + '/' +
h + '/Image' + str(j + 1) + '.png', 'L')
matrix = imresize(matrix, size, 'nearest')
matrix = matrix / 255
matrices += [ar([matrix], dtype='float32')]
c += 1
if c % 100 == 0:
print(c)
matrices = ar(matrices, dtype='float32')
numpy.save('E:/matrices_' + fold + '.npy', matrices)
def e(self):
"""Returns Euler's number's value with 10^-9 error"""
try:
ret = 2.71828182
eret = 10**-9
except Exception as e:
self.etc.print_if(e)
ret = None
eret = None
return (ar([ret, eret]))
def points_in_path(path):
points = [(ar([0, 0]), 0)]
current_count = 0
for direction, steps in path:
current_point = points[-1][0]
for i in range(1, steps + 1):
current_count += 1
points.append((tuple(
(current_point + direction * i).tolist()), current_count))
points[0] = (tuple(points[0][0].tolist()), 0)
return points
def calculate_changes_in_fitness(self,population,number_of_trials):
original_fitnesses = ar(self.fitness_many(population))
print original_fitnesses.shape
sample = [self.sample_dA([i]) for i in population]
# print sample.shape
sample_fitnesses = ar(self.fitness_many([j for j in sample]))
# return original_fitnesses,sample,sample_fitnesses
print sample_fitnesses.shape
print sample_fitnesses[0:10]
differences = sample_fitnesses - original_fitnesses
distances = [[distance.hamming(population[k],sample[k]) for k in range(len(sample))]]
# pdb.set_trace()
for i in range(number_of_trials):
print "trial:",i
new_sample = [self.sample_dA([j]) for j in population]
new_sample_fitnesses = ar(self.fitness_many([j for j in new_sample]))
new_difference = new_sample_fitnesses - original_fitnesses
sample_fitnesses = np.vstack((sample_fitnesses,new_sample_fitnesses))
differences = np.vstack((differences,new_difference))
distances.append([distance.hamming(population[k],sample[k]) for k in range(len(sample))])
return sample_fitnesses,differences,distances
def __hexagon_creator__(self, center, radus, ang_offset=0):
"""Creates corner points of a hexagon"""
try:
points = []
for ang in range(0, 360, 60):
angle = ang_offset + ang
x = radus * cos(deg2rad(angle)) + center[1]
y = radus * sin(deg2rad(angle)) + center[0]
points.append([x, y])
return ar(points)
except Exception as excpt:
self.logger.log(excpt)
def ini_makePosiDirList(self):
thr = self.dim / (len(self.players) * 5)
center = ar([self.dim // 2, self.dim // 2], dtype=int)
pdl = list()
while len(pdl) < len(self.players):
r = numpy.random.rand(2)
XY = (numpy.around((center - self.dim // 10) * 2 * r) + self.dim // 10).astype(int)
ok = True
for j in pdl: # check distance
if sum(abs(XY - j[0])) < thr:
ok = False
if ok:
r = numpy.random.randint(4)
if r == 0:
pdl.append((XY, ar([-1, 0])))
elif r == 1:
pdl.append((XY, ar([0, 1])))
elif r == 2:
pdl.append((XY, ar([1, 0])))
elif r == 3:
pdl.append((XY, ar([0, -1])))
return pdl
def checkLB(self, opts, lb):
# these are indices to bound
indices = {}
indices["t"] = (0,3)
indices["N"] = "a"
indices["l"] = [0,1,2]
indices["a"] = ar([0,1,2],dtype=uint)
indices["f"] = ar([0,1,2],dtype=float64)
lbvalues = {}
lbvalues["s"] = lb
lbvalues["l"] = [lb, lb, lb]
lbvalues["a"] = ar([lb, lb, lb])
lp = LP()
if opts[0] == "N":
lp.getIndexBlock(indices["N"], 3)
lp.setObjective([1,1,1,1,1,1])
lp.setLowerBound(indices[opts[0]], lbvalues[opts[1]])
for num_times in range(2): # make sure it's same anser second time
lp.solve()
self.assertAlmostEqual(lp.getObjectiveValue(), lb*3)
v = lp.getSolution()
self.assert_(len(v) == 6)
self.assertAlmostEqual(v[0], lb)
self.assertAlmostEqual(v[1], lb)
self.assertAlmostEqual(v[2], lb)
self.assertAlmostEqual(v[3], 0)
self.assertAlmostEqual(v[4], 0)
self.assertAlmostEqual(v[5], 0)
def experiment(self,name,no_trials=10,corruption_level=0.2):
ensure_dir("results/autoencoder/".format(name))
all_strings,good_strings=self.generate_good_strings(10000)
self.train_dA(ar(good_strings),corruption_level=corruption_level)
original_fitnesses = self.fitness_many(all_strings)
f,d,dist = self.calculate_changes_in_fitness(all_strings,no_trials)
data = {
"original":original_fitnesses,
"fitnesses_sampled":f,
"differences_in_fitness":d,
"distances":dist,
"no_trials":no_trials,
"corruption_level":corruption_level,
"all_strings":all_strings,
"good_strings":good_strings
}
pickle.dump(data,open("results/autoencoder/{0}.pkl".format(name),"wb"))
return data
def rayPairFromFF(facing, fov):
fov=2*pi-fov
reflex=fov>=pi
facing=Locus.T.dot((facing[0],facing[1],1.0))
logger.debug('facing:'+str(facing)+' reflex: '+str(reflex))
facing=-facing[0:2]
#left, right = [ar((-facing[1]/2.0,facing[0]/2.0)), facing], [ar((facing[1]/2.0,-facing[0]/2.0)), facing]
left, right = [ar((0,0)), facing], [ar((0,0)), facing]
# rotation matrix = [[ cos -sin ] [ sin cos ]] , rotates COUNTERCLOCKWISE
ltheta, rtheta = fov/2.0, -fov/2.0
cos_theta=cos(rtheta)
sin_ltheta=sin(ltheta)
sin_rtheta=-sin_ltheta #sin is symmetrical
rotate_left=ar(((cos_theta, sin_rtheta),(sin_ltheta, cos_theta)))
rotate_right=ar(((cos_theta, sin_ltheta),(sin_rtheta, cos_theta)))
#left, right = (rotate_left*matrix(left[0]).transpose(), rotate_left*matrix(left[1]).transpose()),(rotate_right*matrix(right[0]).transpose(), rotate_right*matrix(right[1]).transpose())
left, right = (left[0], rotate_left*matrix(left[1]).transpose()),(right[0], rotate_right*matrix(right[1]).transpose())
#left, right = (ar(left[0].transpose())[0], ar(left[1].transpose())[0]), (ar(right[0].transpose())[0],ar(right[1].transpose())[0])
left, right = ar((left[0], ar(left[1].transpose())[0])), ar((right[0],ar(right[1].transpose())[0]))
logger.debug("left:"+str(left)+" right:"+str(right))
rp=RayPair(None, None, reflex)
(rp._left, rp._right)=(left, right)
return rp
def get_statistics(self,population,sample):
original_fitnesses = ar(self.fitness_many(population))
sample_fitnesses = ar(self.fitness_many([j for j in sample]))
differences = sample_fitnesses - original_fitnesses
distances = [distance.hamming(population[k],sample[k]) for k in range(len(sample))]
return original_fitnesses,sample_fitnesses,differences,distances
def iterative_algorithm(
self,
name,
pop_size=100,
genome_length=20,
lim_percentage=20,
lim=20,
trials=10,
corruption_level=0.2,
num_epochs=50,
lr = 0.1,
online_training=False,
pickle_data=False,
max_evaluations=200000,
save_data=False,
cross_rate=0.9):
self.mask = np.random.binomial(1,0.5,genome_length)
results_path = "results/autoencoder/{0}/".format(name)
ensure_dir(results_path)
trials = max_evaluations/pop_size
population_limit = lim
cross_rate = cross_rate
if lim_percentage > 0:
population_limit = int(pop_size*(lim_percentage/100.0))
print "population_limit:",population_limit
print "{0}*({1}/100.0) = {2}".format(pop_size,lim_percentage,int(pop_size*(lim_percentage/100.0)))
fitfile = open("{0}fitnesses.dat".format(results_path),"w")
self.dA = Deep_dA(n_visible=genome_length,n_hidden=[60])
self.dA.build_dA(corruption_level)
self.build_sample_dA_2(k=5)
all_strings,good_strings=self.generate_good_strings(pop_size,genome_length,population_limit)
self.train_dA(ar(good_strings),corruption_level=corruption_level,num_epochs=num_epochs,lr=lr,output_folder=results_path,iteration=0)
# sampled_population = [self.sample_dA([i]) for i in self.get_new_population_rw(all_strings)]
fit_p_pop = self.get_new_population_rw(all_strings)
sampled_population = np.array(self.sample_dA(fit_p_pop[0:pop_size/5]),"b").reshape(-1,genome_length)
print "len sampled:",sampled_population.shape
new_population = self.create_population_with_unif_cross(sampled_population,fit_p_pop,cross_rate)
# print "s:",sampled_population
original_fitnesses,sample_fitnesses,differences,distances = self.get_statistics(all_strings,new_population)
if save_data:
self.save_population(sampled_population,0)
self.save_training_data(good_strings,0)
random_pop = [self.generate_random_string(genome_length) for z in range(1000)]
print random_pop[0]
sampled_r_pop = self.sample_dA(random_pop)
self.save_sampled_random_population([r for r in sampled_r_pop],0)
self.save_random_population(random_pop,0)
self.save_pop_fitnesses(sample_fitnesses,"fitness_pop",0)
self.save_pop_fitnesses(self.fitness_many(good_strings),"fitness_training_data",0)
print "writing..."
fitfile.write("{0},{1},{2},{3}\n".format(np.mean(original_fitnesses),np.min(original_fitnesses),np.max(original_fitnesses),np.std(original_fitnesses)))
fitfile.write("{0},{1},{2},{3}\n".format(np.mean(sample_fitnesses),np.min(sample_fitnesses),np.max(sample_fitnesses),np.std(original_fitnesses)))
print "{0},{1},{2}\n".format(np.mean(original_fitnesses),np.min(original_fitnesses),np.max(original_fitnesses))
print "{0},{1},{2}\n".format(np.mean(sample_fitnesses),np.min(sample_fitnesses),np.max(sample_fitnesses))
print "writing over"
for iteration in range(0,trials):
print "iteration:",iteration
print "choosing pop:"
population = self.get_new_population_rw(new_population,sample_fitnesses)
population[0] = new_population[np.argmax(sample_fitnesses)]
print "choosing pop over"
if online_training == False:
print "building model..."
self.dA = Deep_dA(n_visible=genome_length,n_hidden=100)
self.dA.build_dA(corruption_level)
self.build_sample_dA()
good_strings,good_strings_fitnesses=self.get_good_strings(population,population_limit,unique=True)
# return self.get_good_strings(population,population_limit,unique=True)
for f in good_strings_fitnesses:
print "good_strings_fitnesses:",f
self.train_dA(ar(good_strings),corruption_level=corruption_level,num_epochs=num_epochs,lr=lr,output_folder=results_path,iteration=iteration+1)
print "sampling..."
sampled_population = np.array(self.sample_dA(population[0:pop_size/5]),"b").reshape(-1,genome_length)
print "sampled pop:",sampled_population.shape
new_population = self.create_population_with_unif_cross(sampled_population,population,cross_rate)
new_population[0:1] = good_strings[0:1]
print "sampling over"
print "getting_statistics..."
original_fitnesses,sample_fitnesses,differences,distances = self.get_statistics(population,new_population)
print "statistics over"
fitfile.write("{0},{1},{2},{3}\n".format(np.mean(sample_fitnesses),np.min(sample_fitnesses),np.max(sample_fitnesses),np.std(sample_fitnesses)))
fitfile.flush()
print "{0},{1},{2}\n".format(np.mean(sample_fitnesses),np.min(sample_fitnesses),np.max(sample_fitnesses))
print "best from previous:",self.fitness(new_population[np.argmax(sample_fitnesses)])
print "np.argmax(sample_fitnesses):",np.argmax(sample_fitnesses)
print "new_population[np.argmax(sample_fitnesses)]:",new_population[np.argmax(sample_fitnesses)]
print "best fitnesses:",sorted(sample_fitnesses,reverse=True)[0:10]
print new_population[np.argmax(sample_fitnesses)]
print self.fitness(new_population[np.argmax(sample_fitnesses)])
print "sample_fitnesses[np.argmax(sample_fitnesses)]:",sample_fitnesses[np.argmax(sample_fitnesses)]
if save_data:
print "saving stuff..."
self.save_population(sampled_population,iteration+1)
self.save_training_data(good_strings,iteration+1)
random_pop = [self.generate_random_string(genome_length) for z in range(1000)]
print random_pop[0]
sampled_r_pop = self.sample_dA(random_pop)
self.save_sampled_random_population([r for r in sampled_r_pop],iteration+1)
self.save_random_population(random_pop,iteration+1)
self.save_pop_fitnesses(sample_fitnesses,"fitness_pop",iteration+1)
self.save_pop_fitnesses(good_strings_fitnesses,"fitness_training_data",iteration+1)
print "saving over"
fitfile.close()
def __init__(self):
self.blocks_los=False
self.long_description=self.__doc__
self.short_description=self.__doc__
self.symbol=' '
self.hue=ar((1.0,1.0,1.0))
def __init__(self, loc):
super(PseudoHexTile, self).__init__(loc)
self.rect=pygame.sprite.Rect(((loc[1]-loc[0])*(globals.cell_width+int(globals.cell_width*globals.scale_horizontally*0.75)), (loc[1]+loc[0])*globals.cell_height/2),(globals.cell_width,globals.cell_height))
self.hue=ar((0.0,0.0,0.0))
import math
import logging
import pygame
from pygame.rect import Rect
from pygame import draw
from copy import copy
import globals
from reality import Grid
from objects import State, Actor
from lie.reality import HEX_NEIGHBORS
from lie.context import Context as Context
logger=logging.getLogger(__name__)
MAX_COLOR=ar((1.0,1.0,1.0))
MIN_COLOR=ar((0.0,0.0,0.0))
STATE_HUE_MAP={
State.Friendly: ar((0.2,1.0,0.2))*(255,255,255),
State.Neutral: ar((0.2,0.2,1.0))*(255,255,255),
State.Unaware: ar((1.0,1.0,1.0))*(255,255,255),
State.Alert: ar((1.0,1.0,0.2))*(255,255,255),
State.Hostile: ar((1.0,0.2,0.2))*(255,255,255)
}
class RenderableTile(pygame.sprite.DirtySprite):
__metaclass__ = abc.ABCMeta
BLANK_IMAGE = None
@abc.abstractmethod
def checkBindSandwich(self, opts):
idxlist = [{}, {}]
idxlist[0]["t"] = (0,3)
idxlist[0]["N"] = "a"
idxlist[0]["l"] = [0,1,2]
idxlist[0]["a"] = ar([0,1,2])
idxlist[0]["r"] = ar([0,0,1,1,2,2])[::2]
idxlist[0]["f"] = ar([0,1,2],dtype=float64)
idxlist[1]["t"] = (3,6)
idxlist[1]["n"] = "b"
idxlist[1]["l"] = [3,4,5]
idxlist[1]["a"] = ar([3,4,5])
idxlist[1]["r"] = ar([3,3,4,4,5,5])[::2]
idxlist[1]["f"] = ar([3,4,5],dtype=float64)
lp = LP()
if opts[0] == "N":
self.assert_(lp.getIndexBlock(idxlist[0]["N"], 3) == (0,3) )
# Now bind the second group
lp.bindSandwich(idxlist[0][opts[0]], idxlist[1][opts[1]])
if opts[2] == "u":
lp.addConstraint( (idxlist[0][opts[0]], 1), ">=", 1)
elif opts[2] == "l":
lp.addConstraint( (idxlist[0][opts[0]], 1), "<=", -1)
lp.setUnbounded(idxlist[0][opts[0]])
else:
assert False
lp.setObjective( (idxlist[1][opts[1]], [1,2,3]) )
lp.setMinimize()
lp.solve()
v = lp.getSolution()
v0 = 1 if opts[2] == "u" else -1
self.assert_(len(v) == 6, "len(v) = %d != 6" % len(v))
self.assertAlmostEqual(v[0], v0)
self.assertAlmostEqual(v[1], 0)
self.assertAlmostEqual(v[2], 0)
self.assertAlmostEqual(v[3], 1)
self.assertAlmostEqual(v[4], 0)
self.assertAlmostEqual(v[5], 0)
if opts[0] in "nN" and opts[1] in "nN":
d = lp.getSolutionDict()
self.assert_(set(d.iterkeys()) == set(["a", "b"]))
self.assertAlmostEqual(d["a"][0], v0)
self.assertAlmostEqual(d["a"][1], 0)
self.assertAlmostEqual(d["a"][2], 0)
self.assertAlmostEqual(d["b"][0], 1)
self.assertAlmostEqual(d["b"][1], 0)
self.assertAlmostEqual(d["b"][2], 0)
def checkBindEach(self, opts):
idxlist = [{}, {}]
idxlist[0]["t"] = (0,3)
idxlist[0]["N"] = "a"
idxlist[0]["l"] = [0,1,2]
idxlist[0]["a"] = ar([0,1,2])
idxlist[0]["r"] = ar([0,0,1,1,2,2])[::2]
idxlist[0]["f"] = ar([0,1,2],dtype=float64)
idxlist[1]["t"] = (3,6)
idxlist[1]["n"] = "b"
idxlist[1]["l"] = [3,4,5]
idxlist[1]["a"] = ar([3,4,5])
idxlist[1]["r"] = ar([3,3,4,4,5,5])[::2]
idxlist[1]["f"] = ar([3,4,5],dtype=float64)
lp = LP()
if opts[0] == "N":
self.assert_(lp.getIndexBlock(idxlist[0]["N"], 3) == (0,3) )
# Now bind the second group
if opts[2] == "g":
self.assert_(
lp.bindEach(idxlist[1][opts[1]], ">", idxlist[0][opts[0]])
== [0,1,2])
elif opts[2] == "l":
self.assert_(
lp.bindEach(idxlist[0][opts[0]], "<", idxlist[1][opts[1]])
== [0,1,2])
elif opts[2] == "e":
self.assert_(
lp.bindEach(idxlist[0][opts[0]], "=", idxlist[1][opts[1]])
== [0,1,2])
elif opts[2] == "E":
self.assert_(
lp.bindEach(idxlist[1][opts[1]], "=", idxlist[0][opts[0]])
== [0,1,2])
else:
assert False
# Forces some to be defined implicitly above to catch that case
lp.addConstraint( (idxlist[0][opts[0]], 1), ">=", 1)
lp.setObjective( (idxlist[1][opts[1]], [1,2,3]) )
lp.setMinimize()
lp.solve()
v = lp.getSolution()
self.assert_(len(v) == 6, "len(v) = %d != 6" % len(v))
self.assertAlmostEqual(v[0], 1)
self.assertAlmostEqual(v[1], 0)
self.assertAlmostEqual(v[2], 0)
self.assertAlmostEqual(v[3], 1)
self.assertAlmostEqual(v[4], 0)
self.assertAlmostEqual(v[5], 0)
if opts[0] in "nN" and opts[1] in "nN":
d = lp.getSolutionDict()
self.assert_(set(d.iterkeys()) == set(["a", "b"]))
self.assertAlmostEqual(d["a"][0], 1)
self.assertAlmostEqual(d["a"][1], 0)
self.assertAlmostEqual(d["a"][2], 0)
self.assertAlmostEqual(d["b"][0], 1)
self.assertAlmostEqual(d["b"][1], 0)
self.assertAlmostEqual(d["b"][2], 0)
def __init__(self,length = 0,posi = ar([0,0]) , direc = ar([0,1])):
deque.__init__(self)
self.ini_snake(length,posi,direc)
def iterative_algorithm(
self,
name,
pop_size=100,
genome_length=20,
lim_percentage=20,
lim=20,
trials=10,
corruption_level=0.2,
num_epochs=50,
lr = 0.1,
online_training=False,
pickle_data=False,
max_evaluations=200000,
save_data=False):
results_path = "results/autoencoder/{0}/".format(name)
ensure_dir(results_path)
trials = max_evaluations/pop_size
population_limit = lim
if lim_percentage > 0:
population_limit = int(pop_size*(lim_percentage/100.0))
print "population_limit:",population_limit
print "{0}*({1}/100.0) = {2}".format(pop_size,lim_percentage,int(pop_size*(lim_percentage/100.0)))
fitfile = open("{0}fitnesses.dat".format(results_path),"w")
self.dA = dA(n_visible=genome_length,n_hidden=50)
self.dA.build_dA(corruption_level)
self.build_sample_dA()
all_strings,good_strings=self.generate_good_strings(pop_size,genome_length,population_limit)
self.train_dA(ar(good_strings),corruption_level=corruption_level,num_epochs=num_epochs,lr=lr,output_folder=results_path,iteration=0)
# sampled_population = [self.sample_dA([i]) for i in self.get_new_population_rw(all_strings)]
sampled_population = self.sample_dA(self.get_new_population_rw(all_strings))
print "s:",sampled_population
original_fitnesses,sample_fitnesses,differences,distances = self.get_statistics(all_strings,sampled_population)
data = {
"original":original_fitnesses,
"fitnesses_sampled":sample_fitnesses,
"differences_in_fitness":differences,
"distances":distances
}
if pickle_data:
pickle.dump(data,open("results/autoencoder/{0}_0.pkl".format(name),"wb"))
if save_data:
self.save_population(sampled_population,0)
self.save_training_data(good_strings,0)
random_pop = [self.generate_random_string(genome_length) for z in range(1000)]
print random_pop[0]
sampled_r_pop = self.sample_dA(random_pop)
self.save_sampled_random_population([r for r in sampled_r_pop],0)
self.save_random_population(random_pop,0)
self.save_pop_fitnesses(sample_fitnesses,"fitness_pop",0)
self.save_pop_fitnesses(self.fitness_many(good_strings),"fitness_training_data",0)
print "writing..."
fitfile.write("{0},{1},{2},{3}\n".format(np.mean(original_fitnesses),np.min(original_fitnesses),np.max(original_fitnesses),np.std(original_fitnesses)))
fitfile.write("{0},{1},{2},{3}\n".format(np.mean(sample_fitnesses),np.min(sample_fitnesses),np.max(sample_fitnesses),np.std(original_fitnesses)))
print "{0},{1},{2}\n".format(np.mean(original_fitnesses),np.min(original_fitnesses),np.max(original_fitnesses))
print "{0},{1},{2}\n".format(np.mean(sample_fitnesses),np.min(sample_fitnesses),np.max(sample_fitnesses))
print "writing over"
for iteration in range(0,trials):
print "choosing pop:"
population = self.get_new_population_rw([z for z in sampled_population])
print "choosing pop over"
if online_training == False:
print "building model..."
self.dA = dA(n_visible=genome_length,n_hidden=50)
self.dA.build_dA(corruption_level)
self.build_sample_dA()
good_strings,good_strings_fitnesses=self.get_good_strings(population,population_limit)
for f in good_strings_fitnesses:
print "good_strings_fitnesses:",f
self.train_dA(ar(good_strings),corruption_level=corruption_level,num_epochs=num_epochs,lr=lr,output_folder=results_path,iteration=iteration+1)
print "sampling..."
sampled_population = self.sample_dA(population)
print "sampling over"
original_fitnesses,sample_fitnesses,differences,distances = self.get_statistics(population,sampled_population)
data = {
"original":original_fitnesses,
"fitnesses_sampled":sample_fitnesses,
"differences_in_fitness":differences,
"distances":distances
}
if pickle_data:
pickle.dump(data,open("results/autoencoder/{0}_{1}.pkl".format(name,iteration+1),"wb"))
fitfile.write("{0},{1},{2},{3}\n".format(np.mean(sample_fitnesses),np.min(sample_fitnesses),np.max(sample_fitnesses),np.std(original_fitnesses)))
fitfile.flush()
print "{0},{1},{2}\n".format(np.mean(sample_fitnesses),np.min(sample_fitnesses),np.max(sample_fitnesses))
if save_data:
self.save_population(sampled_population,iteration+1)
self.save_training_data(good_strings,iteration+1)
random_pop = [self.generate_random_string(genome_length) for z in range(1000)]
print random_pop[0]
sampled_r_pop = self.sample_dA(random_pop)
self.save_sampled_random_population([r for r in sampled_r_pop],iteration+1)
self.save_random_population(random_pop,iteration+1)
self.save_pop_fitnesses(sample_fitnesses,"fitness_pop",iteration+1)
self.save_pop_fitnesses(good_strings_fitnesses,"fitness_training_data",iteration+1)
fitfile.close()
