def __init__(self):
self.root= Tkinter.Tk()
self.vis= Visual(self.root)
self.relief= Relief()
self.figure= None
self.stand_latter= False
self.root.after_idle(self.tick)
self.root.bind('<KeyPress>', self.press_key)
self.root.mainloop()
def main():
#Initialize
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption(WINDOW_TITLE)
icon = utils.load_image(ICON, (0,0,0))
pygame.display.set_icon(icon)
#Introduction
images = [utils.load_image(image) for image in INTRO_IMAGES]
visual = Visual(screen, images, INTRO_TIMES)
music.play_music(INTROMUSIC, 1)
visual.loop()
music.stop_music()
#Shooter opcion
opcion = menu
while opcion is not exit:
change = opcion(screen).loop()
if change:
opcion = change
opcion() #Exit
class Game:
def __init__(self):
self.root= Tkinter.Tk()
self.vis= Visual(self.root)
self.relief= Relief()
self.figure= None
self.stand_latter= False
self.root.after_idle(self.tick)
self.root.bind('<KeyPress>', self.press_key)
self.root.mainloop()
def tick(self):
self.root.after(300, self.tick)
if not self.figure:
self.figure= Figure()
if self.relief.have_collision(self.figure.get_all()):
print 'generate collision with relief'
self.root.quit()
self.figure.down_move()
if self.try_stand_figure():
self.figure= None
if self.relief.overload():
print 'You Fail'
self.root.quit()
self.redraw()
def redraw(self):
self.vis.reset()
self.vis.draw(self.relief.get_all(), 'navajo white')
if self.figure:
self.vis.draw(self.figure.get_all(), 'alice blue')
def move_figure(self, method):
method()
if self.relief.have_collision(self.figure.get_all()):
self.figure.rollback()
else:
self.redraw()
self.stand_latter= True
def press_key(self, event):
if not self.figure:
return
inp= event.char.upper()
if inp == 'D':
self.move_figure(self.figure.right_move)
elif inp == 'A':
self.move_figure(self.figure.left_move)
elif inp == 'S':
self.move_figure(self.figure.down_move)
elif inp == 'E' or inp == ' ':
self.move_figure(self.figure.right_turn)
elif inp == 'Q':
self.move_figure(self.figure.left_turn)
elif inp == 'W':
while not self.relief.have_collision(self.figure.get_all()):
self.figure.down_move()
self.figure.rollback()
self.redraw()
def try_stand_figure(self):
result= False
if self.relief.have_collision(self.figure.get_all()):
self.figure.rollback()
if self.stand_latter:
pass
else:
self.relief.extend(self.figure.get_all())
self.relief.remove_filled_lines()
result= True
self.stand_latter= False
return result
def main():
config = RunnerConfig({'local_store_directory':''})
config.read('config.ini')
if len(sys.argv) >= 2:
project = None
iterations = iterations_from_file(config, sys.argv[1])
else:
project, iterations = iterations_from_server(config)
vis = Visual()
vis.start()
vis.draw_project_info(project)
vis.draw_iteration_boxes(len(iterations))
for i, it in enumerate(iterations):
#pprint(it['stories'])
#pprint(it['number'])
vis.draw_iteration_number(it['number'], i)
vis.draw_iteration_dates(it['start'], it['finish'], i)
vis.draw_stories_for_iteration(it['stories'], i)
raw_input()
time.sleep(0.001)
q = th.Thread(target=learn, args=(lr_steps, learning_rate))
# q=Process(target=learn, args=(lr_steps,learning_rate))
# q=ThreadWithReturnValue(target=learn, args=(lr_steps,learning_rate))
q.daemon = True
q.start()
processes.append(q)
coord.join(processes)
RL.store()
if args.test:
RL.test_set() # no exploration noise
cross = crossroads_map()
visual = Visual()
obs = []
Q1_set = []
Q2_set = []
Q3_set = []
Q4_set = []
for xx in x:
for yy in y:
lab = str(xx) + str(yy)
obs = np.concatenate(
(obs, cross[lab].car_nums, cross[lab].light_state), axis=None)
RL.restore()
for steps in range(1000):
for xx in x:
for yy in y:
lab = str(xx) + str(yy)
# on_hit = False
# next_step=0
# def hit_me():
# global on_hit
# global next_step
# if on_hit == False:
# on_hit = True
# next_step=0
# else:
# on_hit = False
# next_step=1
# b = tk.Button(window, text='Next Step', width=15,
# height=2, command=hit_me)
# b.pack()
visual=Visual()
cross1=crossing(light_state=0,q_states=[0,0,0,1])
cross2=crossing(light_state=0,q_states=[0,0,1,0])
obs=np.concatenate((cross1.car_nums, cross1.light_state, cross2.car_nums, cross2.light_state),axis=None)
for steps in range(20000):
visual.visual_before(cross1, cross2)
action=RL.choose_action(obs)
if action == 0:
action1 =0
action2 =0
elif action ==1:
action1 =1
action2 =0
def __init__(self, screen, father, level, total_points):
self.screen = screen
self.father = father
self.level = level
self.background = utils.load_image(levels[level]['background'])
#parameters
self.energy_leap = levels[level]['energy_leap']
self.mold_density = levels[level]['mold_density']
self.mold_velocity = levels[level]['mold_velocity']
self.max_time = levels[level]['max_time']
#menu control
self.options = [("Yes", self.father), ("No", None)]
self.exit = False
#Create the game clock
self.clock = pygame.time.Clock()
self.mm = MoldsManager(self.mold_density, self.mold_velocity)
self.bm = BottleManager(*levels[self.level]['bottle_density'])
self.bm.mm = self.mm
self.total_points = total_points
self.pointsCounter = Points(self.total_points)
self.levelIndicator = LevelIndicator(self.level)
self.mm.level = self
self.tics = 0
self.snow_slim = pygame.sprite.Group()
self.snow_fat = pygame.sprite.Group()
for x in range(75):
sprite = Wheather(1, 2)
self.snow_slim.add(sprite)
for x in range(75):
sprite = Wheather(3, 5)
self.snow_fat.add(sprite)
self.energy_bar = EnergyBar(self.energy_leap)
self.bm.energy_bar = self.energy_bar
self.mm.energy_bar = self.energy_bar
self.level_time = LevelTime(self.max_time)
self.gadgets = pygame.sprite.RenderUpdates()
self.gadgets.add(self.pointsCounter)
self.gadgets.add(self.energy_bar)
self.gadgets.add(self.level_time)
self.gadgets.add(self.levelIndicator)
self.hero = Hero()
self.bm.hero = self.hero
self.mm.hero = self.hero
self.explotion = Explotion()
self.control_down = -1
self.control_up = -1
self.control_left = -1
self.control_right = -1
self.control_tiempo = 5
self.next_scream = random.randrange(400, 500)
#Show level image
Visual(self.screen, [utils.load_image(levels[self.level]['img'])], [2],
None).loop()
def main():
svm_params = dict(svm_type=cv2.SVM_C_SVC,
kernel_type=cv2.SVM_LINEAR,
degree=None,
gamma=5.383,
C=1)
# Creates visual platrorm
vis = Visual()
# User input ################################################################
ans = '1' # raw_input("Would like to create model (1) or to view outputs (2) : ")
if ans == '1':
print "Reading data set : "
raw_img, raw_lbl = MyMnist.read()
print "Done \n"
lbl_img = zip(raw_lbl, raw_img)
lbl_img = shuffle(lbl_img)
raw_lbl = np.asarray([t[0] for t in lbl_img])
raw_img = np.asarray([t[1] for t in lbl_img]).reshape(
(raw_lbl.size, config.height * config.width))
print "Now lets start training : \n"
# User input ################################################################
is_hog = 'y' # raw_input("Would you like to use Hog (y/n) : ")
if (is_hog == 'y'):
hog_scale_w = int(raw_input("What width would you like to use : "))
hog_scale_h = int(
raw_input("What height would you like to use : "))
hog_degrees = int(
raw_input("What amount of degrees would you like to use : "))
hog_data = np.zeros([
raw_lbl.size, config.height * config.width / hog_scale_h /
hog_scale_w * hog_degrees
], 'float32')
for i in range(0, raw_lbl.size):
hog_data[i] = Hog.getimghog(
raw_img[i].reshape((config.height, config.width)),
[[1, 0, -1], [2, 0, -1], [1, 0, -1]],
[[1, 2, 1], [0, 0, 0], [-1, -2, -1]], hog_scale_h,
hog_scale_w, hog_degrees)
raw_img = hog_data
# User input ################################################################
out = 2 # int(raw_input("Would you like to use Linear (1) or Kernel (2) :"))
svm_params['C'] = float(raw_input("Please enter C parameter : "))
if out == 1:
svm_params['kernel_type'] = cv2.SVM_LINEAR
else:
svm_params['kernel_type'] = cv2.SVM_POLY
svm_params['degree'] = int(
2) # float(raw_input("Please enter SVM degree parameter : "))
svm_params['gamma'] = float(raw_input("Please enter gamma : "))
name = "HOG " + str(hog_scale_h) + "x" + str(hog_scale_w) + " d" + str(
hog_degrees) + " C" + str(svm_params['C']) + " G" + str(
svm_params['gamma']
) #raw_input("How would you like to name your model : ")
step = int(round(raw_lbl.size * 0.1)) - 1
test_lbls = list()
pred_lbls = list()
for i in range(0, 10):
print "Start " + str(i) + " training ",
train_img = np.concatenate((raw_img[:i, :], raw_img[i + step:, :]))
train_lbl = np.append(raw_lbl[:i], raw_lbl[i + step:])
test_img = raw_img[i:i + step, :]
test_lbl = raw_lbl[i:i + step]
test_lbls.append(test_lbl)
svm = cv2.SVM()
svm.train(train_img, train_lbl, params=svm_params)
print "=> Predicting",
pred_lbls.append(svm.predict_all(test_img))
print "=> Done"
s = SvmOutput(name, svm_params, svm,
np.array(test_lbls).ravel(),
np.array(pred_lbls).ravel())
s.save()
s.showdata()
else:
ans = raw_input(
"Would you like to view a specific model (1) \nor the roc curve of a few models (2) :"
)
models_dir = os.walk(config.default_path).next()[1]
if ans == '1':
print "Available models : "
for i in range(1, len(models_dir) + 1):
print "\t(" + str(i) + ") " + models_dir[i - 1]
ans = int(raw_input("Which model would you like to view : "))
model = SvmOutput(name=models_dir[ans - 1], readfile=True)
model.showdata()
else:
roc_models = list()
ans = 'y'
while (ans == 'y') & (len(models_dir) > 0):
print "Available models : "
for i in range(1, len(models_dir) + 1):
print "\t(" + str(i) + ") " + models_dir[i - 1]
model_add = int(
raw_input("Which model would you like to view : "))
roc_models.append(
SvmOutput(name=models_dir[model_add - 1], readfile=True))
ans = raw_input(
"Would you like to choose another model (y/n) : ")
models_dir.pop(model_add - 1)
vis.showROC(roc_models)
