def main() -> None:
timer = Timer('Model training')
model_trainer, images = set_up_components('base_model_location')
model_trainer.train_and_save_all_models(images)
model_trainer.charts.finalize()
print('class 1: ' + images.class_labels[0] + ', class 2: ' +
images.class_labels[1])
timer.stop()
timer.print_results()
class Texture(object):
def __init__(self, type, width=0, height=0, name=''):
self.type = type
self.width: int = width
self.height: int = height
self.active: bool = True
self.name = name
# color related
self.overwriteColorTimer = Timer(0.25, active=False)
self.overwriteColor = None
def init(self):
pass
def draw(self, viewport):
pass
def advance(self, deltaTime: float):
# reset overwrite color
if self.overwriteColorTimer.timeIsUp():
self.overwriteColor = None
self.overwriteColorTimer.stop()
self.overwriteColorTimer.advance(deltaTime)
def setOverwriteColorFor(self, time: float, color: Color):
if self.overwriteColorTimer.isActive():
logger.debug("{} Color already active on new set color".format(
self.name))
self.overwriteColor = color
self.overwriteColorTimer.setTimer(time)
self.overwriteColorTimer.reset()
def advanceStep(self):
pass
def setActive(self, active: bool):
self.active = active
def isActive(self) -> bool:
return self.active
def setName(self, name: str):
self.name = name
def __repr__(self):
return self.name
def main():
# Start execution and parse arguments
timer = Timer('Classifying a test set')
image_folders, list_of_models, color_mode, image_size = process_input_arguments()
# Import images
images = LabeledImages(SEED)
images.load_testing_images(image_folders, image_size, color_mode)
print('Images imported.')
combined_results = pd.DataFrame()
combined_results['filename'] = images.test_img_names
combined_results['actual_class'] = images.test_labels
all_predictions = pd.DataFrame()
for model_path in list_of_models:
classify_images_with_a_model(images.class_labels, all_predictions, images, model_path)
all_predictions['voted_probability'] = all_predictions.mean(axis=1)
# calculate_confusion_matrix(combined_results)
combined_results = combined_results.join(all_predictions)
combined_results['tp'] = combined_results.eval('actual_class == 1 and voted_probability >= 0.5')
combined_results['fn'] = combined_results.eval('actual_class == 1 and voted_probability < 0.5')
combined_results['fp'] = combined_results.eval('actual_class == 0 and voted_probability >= 0.5')
combined_results['tn'] = combined_results.eval('actual_class == 0 and voted_probability < 0.5')
combined_results['voted_label'] = combined_results.eval('voted_probability >= 0.5')
combined_results['tp'] = combined_results['tp'].map(lambda v: 1 if v else 0)
combined_results['fn'] = combined_results['fn'].map(lambda v: 1 if v else 0)
combined_results['fp'] = combined_results['fp'].map(lambda v: 1 if v else 0)
combined_results['tn'] = combined_results['tn'].map(lambda v: 1 if v else 0)
combined_results['voted_label'] = combined_results['voted_label'].map(lambda v: 1 if v else 0)
combined_results.columns = ['filename', 'actual_class'] + list_of_models + \
['voted_probability', 'tp', 'fn', 'fp', 'tn', 'voted_label']
if not os.path.exists('predictions'):
os.makedirs('predictions')
write_dataframe_to_csv('predictions', 'model_vote_predict', combined_results)
# Finish execution
timer.stop()
timer.print_results()
def main() -> None:
timer = Timer('Model training')
cnn_arguments = CNNArguments()
new_images = LabeledImages(SEED)
new_images.load_images_from_folders(cnn_arguments.training_image_folder,
cnn_arguments.image_size,
cnn_arguments.color_mode,
shuffle=True,
n_folds=cnn_arguments.n_folds)
architecture = SmithsonianModel(SEED, cnn_arguments.lr,
cnn_arguments.image_size,
cnn_arguments.color_mode)
trainer = ModelTrainer(cnn_arguments.n_epochs, cnn_arguments.batch_size,
cnn_arguments.n_folds, architecture, SEED)
trainer.train_and_save_all_models(new_images)
trainer.charts.finalize()
print('class 1: ' + new_images.class_labels[0] + ', class 2: ' +
new_images.class_labels[1])
timer.stop()
timer.print_results()
class StateAttack(State):
name = "attack"
def __init__(self, brain):
State.__init__(self, brain)
self.attackMoveTimer = Timer() # Timer(0.5, instant=False) # windup and cooldown
def on_enter(self):
meEnemy = self.brain.owner.world.component_for_entity(
self.brain.owner.entity, system.gamelogic.enemy.Enemy)
meGroupId = self.brain.owner.world.component_for_entity(
self.brain.owner.entity, system.groupid.GroupId)
messaging.add(
type=MessageType.EntityAttack,
groupId=meGroupId.getId(),
data=None
)
# self.attackTimer.setTimer(meEnemy.enemyInfo.attackTime)
# self.setTimer(meEnemy.enemyInfo.attackTime)
self.stepsTodo = 30
self.attackMoveTimer.init()
self.attackMoveTimer.setTimer(0.1)
self.setTimer(3.0)
# even though we attack multiple times (each step)
# only send EntityAttack once (change animation)
messaging.add(
type=MessageType.EntityAttack,
groupId=meGroupId.getId(),
data={}
)
def process(self, dt):
self.attackMoveTimer.advance(dt)
# check if we got stunned
meAttackable = self.brain.owner.world.component_for_entity(
self.brain.owner.entity, system.gamelogic.attackable.Attackable)
if meAttackable.isStunned:
self.brain.pop()
self.brain.push("chase")
# check if we should do one attack step
if self.attackMoveTimer.timeIsUp():
logger.info("{}: I'm attacking, step {}".format(self.owner, self.stepsTodo))
if self.stepsTodo > 0:
self.attackMoveTimer.reset()
self.stepsTodo -= 1
meRenderable = self.brain.owner.world.component_for_entity(
self.brain.owner.entity, Renderable)
meGroupId = self.brain.owner.world.component_for_entity(
self.brain.owner.entity, system.groupid.GroupId)
if self.stepsTodo % 2 == 0:
offensiveAttack = self.brain.owner.world.component_for_entity(
self.brain.owner.entity, OffensiveAttack)
offensiveAttack.attack()
if meRenderable.direction is Direction.left:
x = -1
else:
x = 1
directMessaging.add(
groupId = meGroupId.getId(),
type = DirectMessageType.moveEnemy,
data = {
'x': x,
'y': 0,
'dontChangeDirection': False,
'updateTexture': False,
'force': True
},
)
else:
self.attackMoveTimer.stop()
if self.timeIsUp():
# too long attacking. lets switch to chasing
logger.info("{}: Too long attacking, switch to chasing".format(
self.owner))
self.brain.pop()
self.brain.push("chase")
class SceneProcessor(esper.Processor):
def __init__(self, viewport, sceneManager):
super().__init__()
self.viewport = viewport
self.sceneManager = sceneManager
self.xCenter = Config.columns / 2 - 5
self.state = State.start
self.screenMoveTimer = Timer(0.1)
self.lastKnownPlayerPos = None
self.gameoverTimer = Timer(3.0,
active=False) # show gameover for this long
def setState(self, state):
logging.debug("Set to state: {}".format(state))
self.state = state
def process(self, dt):
self.screenMoveTimer.advance(dt)
self.gameoverTimer.advance(dt)
for message in messaging.getByType(MessageType.Gameover):
self.gameoverTimer.reset()
self.gameoverTimer.start()
self.setState(State.gameover)
messaging.add(type=MessageType.EmitPhenomenaTexture,
data={
'phenomenaTextureType': PhenomenaType.gameover,
'location': Coordinates(10, 10),
'staticLocation': True,
'direction': Direction.right,
'physics': False,
})
if self.state is State.gameover:
for message in messaging.getByType(MessageType.PlayerKeypress):
if self.gameoverTimer.timeIsUp():
messaging.add(type=MessageType.ClearRenderables, data={})
self.setState(State.start)
elif self.state is State.start:
self.sceneManager.restartScene()
self.setState(State.brawl)
for message in messaging.getByType(MessageType.EntityDying):
# if no enemies are alive, we want to go to the next akt
if self.numEnemiesAlive() == 0:
self.screenMoveTimer.start()
if self.state is not State.gameover:
self.setState(State.pushToNextScene)
break
for message in messaging.getByType(MessageType.PlayerLocation):
self.lastKnownPlayerPos = message.data
if self.state is State.pushToNextScene:
# if suddenly enemies appear, let the player free
if self.numEnemiesVisible() > 0:
self.setState(State.brawl)
if self.state is State.brawl:
if (self.numEnemiesVisible() == 0 and
not self.enemiesLeftOfChar(self.lastKnownPlayerPos.x)):
self.screenMoveTimer.start()
self.setState(State.pushToEnemies)
if self.state is State.pushToEnemies:
if self.numEnemiesVisible() > 0:
self.setState(State.brawl)
playerScreenCoords = self.viewport.getScreenCoords(message.data)
# adjust viewport on move
if self.state is State.pushToNextScene:
# screen follows player
# player is left side of screen (screen pushes player right)
if playerScreenCoords.x != 10:
distance = int(playerScreenCoords.x - 10)
if distance < 0:
self.adjustViewport(-1)
self.screenMoveTimer.reset()
elif distance > 0:
self.adjustViewport(1)
self.screenMoveTimer.reset()
elif self.state is State.pushToEnemies:
# screen follows player
# player is middle of the screen
if playerScreenCoords.x != self.xCenter:
distance = int(playerScreenCoords.x - self.xCenter)
if distance < 0:
self.adjustViewport(-1)
self.screenMoveTimer.reset()
elif distance > 0:
self.adjustViewport(1)
self.screenMoveTimer.reset()
elif self.state is State.brawl:
if not self.enemiesLeftOfChar(self.lastKnownPlayerPos.x):
# player can move freely
# coming close to left/right of the screen will move it
if playerScreenCoords.x >= Config.moveBorderRight:
distance = playerScreenCoords.x - Config.moveBorderRight
self.adjustViewport(distance)
if playerScreenCoords.x <= Config.moveBorderLeft:
distance = playerScreenCoords.x - Config.moveBorderLeft
self.adjustViewport(distance)
# /adjust viewport on move
# let the scene decide if we need more enemies
self.sceneManager.currentScene.handlePosition(
message.data, self.viewport.getx(), self.numEnemiesAlive())
for message in messaging.getByType(MessageType.PlayerKeypress):
key = message.data['key']
self.sceneManager.handlePlayerKeyPress(key)
if key == ord('k'):
logger.info("Scene: Kill All Enemies")
self.killAllEnemies()
if key == ord('n'):
logger.info("Scene: Go to next part")
self.killAllEnemies()
enemyCell = self.sceneManager.currentScene.getNextEnemy()
playerEntity = EntityFinder.findPlayer(self.world)
meGroupId = self.world.component_for_entity(
playerEntity, system.groupid.GroupId)
renderable = self.world.component_for_entity(
playerEntity, system.graphics.renderable.Renderable)
distX = enemyCell.spawnX - renderable.coordinates.x
directMessaging.add(
groupId=meGroupId.getId(),
type=DirectMessageType.movePlayer,
data={
'x': distX,
'y': 0,
'dontChangeDirection': False,
'whenMoved': None,
},
)
# move screen animation
if self.screenMoveTimer.timeIsUp(
) and self.lastKnownPlayerPos is not None:
playerScreenCoords = self.viewport.getScreenCoords(
self.lastKnownPlayerPos)
if self.state is State.pushToNextScene:
# screen follows player
# player is left side of screen (screen pushes player right)
if playerScreenCoords.x != 10:
distance = int(playerScreenCoords.x - 10)
if distance < 0:
self.adjustViewport(-1)
self.screenMoveTimer.reset()
elif distance > 0:
self.adjustViewport(1)
self.screenMoveTimer.reset()
else:
self.screenMoveTimer.stop()
elif self.state is State.pushToEnemies:
# screen follows player
# player is middle of the screen
if playerScreenCoords.x != self.xCenter:
distance = int(playerScreenCoords.x - self.xCenter)
if distance < 0:
self.adjustViewport(-1)
self.screenMoveTimer.reset()
elif distance > 0:
self.adjustViewport(1)
self.screenMoveTimer.reset()
else:
self.screenMoveTimer.stop()
self.sceneManager.advance(dt)
def adjustViewport(self, xoff):
viewportChanged = self.viewport.adjustViewport(xoff)
if viewportChanged:
messaging.add(
type=MessageType.ScreenMove,
data={
'x': xoff,
},
)
def killAllEnemies(self):
for _, ai in self.world.get_component(system.gamelogic.ai.Ai):
ai.brain.pop()
ai.brain.push('dead')
def numEnemiesAlive(self) -> int:
count = 0
for _, ai in self.world.get_component(system.gamelogic.ai.Ai):
if ai.brain.state.name != 'dead' and ai.brain.state.name != 'dying':
count += 1
return count
def numEnemiesVisible(self) -> int:
count = 0
for _, (ai, renderable) in self.world.get_components(
system.gamelogic.ai.Ai, system.graphics.renderable.Renderable):
if (ai.brain.state.name != 'dead'
and ai.brain.state.name != 'dying'
and renderable.coordinates.x > self.viewport.getx()
and renderable.coordinates.x < self.viewport.getRightX()):
count += 1
return count
def enemiesLeftOfChar(self, playerX):
for _, (ai, renderable) in self.world.get_components(
system.gamelogic.ai.Ai, system.graphics.renderable.Renderable):
if (ai.brain.state.name != 'dead'
and ai.brain.state.name != 'dying'
and renderable.coordinates.x < playerX):
return True
return False
