def build_week_players(self, week, season, games):
"""
This method gets all of the information for each player.
"""
#Dictionary to hold the defense information for the week
defense_week = {}
#Get player stats from nflgame
player_stats = nflgame.combine_play_stats(games)
#Process every player
for player in player_stats:
self.process_player(season, week, player, defense_week)
#Copy final defense values into defense dictionary
for team in defense_week:
if team in self.defense:
if self.teams[team].home:
defense_week[team].df['points_allowed'] = self.game_list[
season][week][team].score_away
else:
defense_week[team].df['points_allowed'] = self.game_list[
season][week][team].score_home
self.defense[team].update(defense_week[team].df, 1, 1)
else:
temp_def = Defense(self.teams[team])
if self.teams[team].home:
defense_week[team].df['points_allowed'] = self.game_list[
season][week][team].score_away
else:
defense_week[team].df['points_allowed'] = self.game_list[
season][week][team].score_home
temp_def.update(defense_week[team].df, 1, 1)
self.defense[team] = temp_def
#Update ranks
for game in games:
self.ranks.add_game(game)
def _step(self):
iniciativas = self._draw_iniciativa()
for grupo in iniciativas:
for personagem in self._get_personagens_grupo(grupo):
if not personagem.is_incapacitated():
acao = personagem.play(self.personagens, self.melee_nodes,
self.team_groups)
acao.execute()
if isinstance(acao, Attack):
defense = Defense()
defense.attack_action = acao
defense.execute()
class Security(Base):
def __init__(self, file_player):
self.dir_data = self.dir_out + '/security'
self.l_t_player_method_cmd = self.read_l_t_player_method_cmd(file_player, 'security')
self.d = Defense(file_player)
self.o = Offense(file_player)
def get_fname(self, defense, shield, offense, spear, judge, metric, ext=''):
## 出力ファイル名の取得
tag = '_'.join([defense, shield, offense, spear, judge, metric])
return '/'.join([self.dir_data, tag + ext])
def security(self):
## 安全性評価
self.mkdir_p(self.dir_data)
for defense, shield, _ in self.d.l_t_player_method_cmd:
for offense, spear, _ in self.o.l_t_player_method_cmd:
prefix = '{ncat} {r_csv} {tr} {a0} {f1} | '.format(
ncat=self.ncat,
r_csv=self.cwd + '/' + self.r_csv,
tr=self.cwd + '/' + self.tr,
a0=self.cwd + '/' + self.d.get_fname(defense, shield, '.A'),
f1=self.cwd + '/' + self.o.get_fname(defense, shield, offense, spear, '.F1'),
)
for judge, metric, cmd in self.l_t_player_method_cmd:
suffix = ' | {nsplit} {sec}'.format(
nsplit=self.nsplit,
sec=self.cwd + '/' + self.get_fname(defense, shield, offense, spear, judge, metric, '.S'))
cmd = prefix + cmd + suffix
twd = '/'.join([self.dir_lib, judge, metric])
fout = self.get_fname(defense, shield, offense, spear, judge, metric, '.out')
ferr = self.get_fname(defense, shield, offense, spear, judge, metric, '.err')
self.print_cmd(cmd, twd)
self.do_shell(cmd, twd, fout, ferr)
class Publish(Base):
def __init__(self, file_player):
self.dir_data = self.dir_out + '/publish'
self.l_t_player_method_cmd = self.read_l_t_player_method_cmd(
file_player, 'publish')
self.d = Defense(file_player)
def get_fname(self, defense, shield, ext=''):
## 出力ファイル名の取得
tag = '_'.join([defense, shield])
return '/'.join([self.dir_data, tag + ext])
def publish(self):
## convert anonymized data to SHUFFLED anonymized data
self.mkdir_p(self.dir_data)
for defense, shield, _ in self.d.l_t_player_method_cmd:
prefix = '{ncat} {a0} | '.format(
ncat=self.ncat,
a0=self.cwd + '/' + self.d.get_fname(defense, shield, '.A'),
)
for publish, pmethod, cmd in self.l_t_player_method_cmd:
suffix = ' | {nsplit} {a1}'.format(
nsplit=self.nsplit,
a1=self.cwd + '/' + self.get_fname(defense, shield, '.A1'))
cmd = prefix + cmd + suffix
twd = '/'.join([self.dir_lib, publish, pmethod])
self.print_cmd(cmd, twd)
self.do_shell(cmd, twd, 'tmp.out', 'tmp.err')
def process_player(self, season, week, player, defense_week):
"""
This method gets all of the information for each player.
"""
#Wrap stats in a dataframe
stats = pd.DataFrame([player.stats])
#Set season and week
stats['season'] = season
stats['week'] = week
#Process based on offense or defense
if ('QB' in player.guess_position or \
'RB' in player.guess_position or \
'WR' in player.guess_position or \
'TE' in player.guess_position):
#Check if player class is set in Player, class is needed for the number of years played
if player.player is None:
stats['years_played'] = 1
else:
stats['years_played'] = player.player.years_pro - (
self.current_year - season) + 1
#If the player exists in the dictionary update their info, else create new player
if player.playerid in self.players:
self.players[player.playerid].setInfo(
player, self.current_year, season,
self.teams[get_id(player.team)])
self.players[player.playerid].update(stats, 1, 1)
else:
temp_player = Player(player, self.teams[get_id(player.team)])
temp_player.setInfo(player, self.current_year, season,
self.teams[get_id(player.team)])
temp_player.update(stats, 1, 1)
self.players[player.playerid] = temp_player
#Process defense player
elif ('LB' in player.guess_position or \
'DE' in player.guess_position or \
'CB' in player.guess_position or \
'FS' in player.guess_position or \
'SS' in player.guess_position or \
'DT' in player.guess_position or \
'NT' in player.guess_position or \
'DEF' in player.guess_position or \
'SAF' in player.guess_position or \
'DB' in player.guess_position):
#Get unique ID of the players team
team = get_id(player.team)
#If the player's team exists update the stats, otherwise create new defense
if team in defense_week:
defense_week[team].build_week(stats)
defense_week[team].setInfo(player.team)
else:
temp_def = Defense(self.teams[get_id(player.team)])
temp_def.setInfo(player.team)
temp_def.build_week(stats)
defense_week[team] = temp_def
def __init__(self, file_player):
self.dir_data = self.dir_out + '/security'
self.l_t_player_method_cmd = self.read_l_t_player_method_cmd(file_player, 'security')
self.d = Defense(file_player)
self.o = Offense(file_player)
def __init__(self, file_player):
self.dir_data = self.dir_out + '/offense'
self.l_t_player_method_cmd = self.read_l_t_player_method_cmd(
file_player, 'offense')
self.d = Defense(file_player)
self.p = Publish(file_player)
def __init__(self, file_player):
self.dir_data = self.dir_out + '/publish'
self.l_t_player_method_cmd = self.read_l_t_player_method_cmd(
file_player, 'publish')
self.d = Defense(file_player)
x_test_adv = adv_crafter.generate(x_test, **params)
print("Before LabelSmoothing\n")
# Evaluate the classifier on the test set
preds = np.argmax(classifier.predict(x_test), axis=1)
acc = np.sum(preds == np.argmax(y_test, axis=1)) / y_test.shape[0]
print("Accuracy on legit samples: %.2f%% \n" % (acc * 100))
# Evaluate the classifier on the adversarial samples
preds = np.argmax(classifier.predict(x_test_adv), axis=1)
acc = np.sum(preds == np.argmax(y_test, axis=1)) / y_test.shape[0]
print('Accuracy on adversarial samples: %.2f%% \n' % (acc * 100))
from defense import Defense
print("Starting defense.")
d = Defense(x_train_adv, x_test_adv)
d.adversarial_training()
## LabelSmoothing
labelsmoother = LabelSmoothing()
x_train, y_train = labelsmoother(x_train, y_train, max_value=.8)
x_test, y_test = labelsmoother(x_test, y_test, max_value=.8)
## Create simple 2 hidden layer 64 nodes neural network
model = Sequential()
model.add(Dense(64, input_dim=784, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))
model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
classifier = KerasClassifier((min_, max_), model=model)
classifier.fit(x_train, y_train, nb_epochs=5, batch_size=50)
def main():
"""Main entry point of the application"""
#
# Call parameter analysis
#
if len(sys.argv) != 3:
print("ERREUR: Pas assez de parametres")
usage()
return
if sys.argv[1][0] != '-':
print(
"""ERREUR: Le premier parametre devrait etre "-1" ou "-2" (sans les guillemets)"""
)
usage()
return
if len(sys.argv[1]) == 1 or sys.argv[1][1] not in "13":
print(
"""ERREUR: Le premier parametre devrait etre "-1" ou "-3" (sans les guillemets)"""
)
usage()
return
#
# We display cos version before starting the processing
#
print()
print("cos version 2.0.2")
print()
#
# Read all configuration data
#
conf = Conf(sys.argv[2])
#
# Read the list of defenses
#
defenses = []
f = openWithErrorManagement(key2inputFileName("defensesFilename", conf),
"r",
encoding=conf.get("encoding"))
nbLinesRead = [0]
name = lookForNonBlankLine(f, nbLinesRead, True, "Nom soutenance")
while name != "":
defenses.append(Defense(name))
name = lookForNonBlankLine(f, nbLinesRead, True, "Nom soutenance")
f.close()
#
# Read the list of students and the title of their defense
#
students = []
f = openWithErrorManagement(key2inputFileName("studentsFilename", conf),
"r",
encoding=conf.get("encoding"))
nbLinesRead = [0]
lookForNonBlankLine(
f, nbLinesRead, True,
"Nom soutenance") # We ignore the line giving the title of the columns
studentLine = lookForNonBlankLine(f, nbLinesRead, True, "Nom soutenance")
while studentLine != "":
info = splitCsvLine(studentLine, conf.get("csvSeparator"))
# We look for info in the list of defense names
found = False
for defense in defenses:
if info[1] == defense.name:
# OK, this defense name is known
students.append(Student(info[0], defense, defenses))
found = True
break
if not found:
sys.exit(
"""ERREUR: Dans le fichier "{}", la ligne {} ("{}") fait référence à une soutenance intitulée "{}" qui n'apparaît pas dans le fichier "{}"."""
.format(conf.get("studentsFilename"), nbLinesRead[0],
studentLine, info[1], conf.get("defensesFilename")))
studentLine = lookForNonBlankLine(f, nbLinesRead, True,
"Nom soutenance")
f.close()
#
# Read the list of criteria types
#
criteriaTypes = []
f = openWithErrorManagement(key2inputFileName("criteriaTypesFilename",
conf),
"r",
encoding=conf.get("encoding"))
nbLinesRead = [0]
criteriaType = lookForNonBlankLine(f, nbLinesRead, True, "Type de critère")
while criteriaType != "":
criteriaTypes.append(criteriaType)
criteriaType = lookForNonBlankLine(f, nbLinesRead, True,
"Type de critère")
f.close()
#
# Read the list of criterias
#
criterias = []
f = openWithErrorManagement(key2inputFileName("criteriasFilename", conf),
"r",
encoding=conf.get("encoding"))
nbLinesRead = [0]
lookForNonBlankLine(
f, nbLinesRead, True,
"Nom critère") # We ignore the line giving the title of the columns
criteriaLine = lookForNonBlankLine(f, nbLinesRead, True, "Nom critère")
while criteriaLine != "":
info = splitCsvLine(criteriaLine, conf.get("csvSeparator"))
# We look for info[0] in the list of criteria types
found = False
for criteriaType in criteriaTypes:
if info[0] == criteriaType:
found = True
break
if not found:
sys.exit(
"""ERREUR: Dans fichier "{}", la ligne {} ("{}") fait référence à un type de critère intitulée "{}" qui n'apparaît pas dans le fichier "{}"."""
.format(f.name, nbLinesRead[0], criteriaLine, info[0],
conf.get("criteriaTypesFilename")))
# OK, this citeriaType is known
try:
floatValue = float(info[2])
except ValueError:
sys.exit(
"""ERREUR: Dans fichier "{}", la ligne {} ("{}") a son 3ème champ ("{}") qui n'est pas un flottant."""
.format(f.name, nbLinesRead[0], criteriaLine, info[2]))
criterias.append(
Criteria(info[0], info[1], floatValue, conf.get("ratioCriteriaKO"),
conf.get("ratioCriteriaOK")))
criteriaLine = lookForNonBlankLine(f, nbLinesRead, True, "Nom critère")
f.close()
#
# Prepare dateTime string which may be used for names of output files
#
date = datetime.datetime.now()
s = str(date)
dateTime = s[:s.find('.')]
#
# Remaining work depends on what the user asks for
#
if sys.argv[1][1] == '1':
generateModels(conf, defenses, students, criteriaTypes, criterias,
dateTime)
else:
analyzeTeacherData(conf, defenses, criteriaTypes, criterias)
analyzeStudentsData(conf, defenses, students, criteriaTypes, criterias)
generateResults(conf, defenses, students, criteriaTypes, criterias,
dateTime)
#
# We display an end of execution message
#
if sys.argv[1][1] == '1':
print(
"""OK, exécution de la phase {} terminée : les fichiers "{}", "{}" et "{}" ont été générés."""
.format(
sys.argv[1][1],
key2ouputFileName("nominativeSheetsFilename", conf, dateTime),
key2ouputFileName("genericSheetFilename", conf, dateTime),
key2ouputFileName("genericTeacherMarksFilename", conf,
dateTime)))
else:
print(
"""OK, exécution de la phase {} terminée : les fichiers "{}", "{}" et "{}" ont été générés."""
.format(
sys.argv[1][1],
key2ouputFileName("synthesisCommentsFilename", conf, dateTime),
key2ouputFileName("evaluationCommentsFilename", conf,
dateTime),
key2ouputFileName("studentsMarksSheetFilename", conf,
dateTime)))
print()
return