def issues(self):
utils.clear()
print('{}{}%s{}'.format(utils.Color.BOLD, utils.Color.BLUE,
utils.Color.END) % self.title)
count_score = 0
for key in self.question:
if key[0] == MultidimensionalEvaluationTest.HAVE_CHOICE:
answer_aux = ScrollBar(prompt=key[1],
choices=key[2],
indent=0,
margin=2,
pointer="★",
pad_right=5)
answer = answer_aux.launch()
else:
answer = input(key[1])
utils.line_break()
key.append(answer)
if key[0] == MultidimensionalEvaluationTest.HAVE_CHOICE:
try:
count_score += int(str(answer[1]))
except ValueError:
pass
return count_score
def title_header():
utils.clear()
print('{}{}- - - - - - - - - - - - - - - -'.format(
utils.Color.CYAN, utils.Color.BOLD))
print('Plano de Atenção Gerontológica')
print('- - - - - - - - - - - - - - - -')
print('v.0.1{}'.format(utils.Color.END))
utils.line_break()
def menuInicial():
if verificarListaDePotencias():
calcularVidaPotencias()
logoJuego()
print("Presione enter para ingresar!!!")
input("")
clear()
menuCargarMapa()
else:
print("Hay un error en la lista de potencias del juego...")
input("")
def get_info_from_main_page_by_num_as_string(self, num):
tds = self.wd.find_elements_by_xpath("//tr[@name='entry'][%s]/td" %
str(num + 1))
last_name = tds[1].text
first_name = tds[2].text
address = tds[3].text
emails = tds[4].text.replace("\n", "")
phones = clear(tds[5].text.replace("\n", ""))
return last_name + first_name + address + emails + phones
def input_patient():
clear()
print('{}{}## Dados de identificação do paciente: {} \n'.format(Color.BOLD, Color.CYAN, Color.END))
inpt_first_name = input('Primeiro nome: ').capitalize()
inpt_last_name = input('Segundo nome: ').capitalize()
inpt_adress = input('Endereço: ').capitalize()
inpt_telephone = input('Telefone: ')
inpt_date_birth = input('Data de nascimento (DD/MM/AAAA): ')
inpt_age = input('Idade: ').capitalize()
inpt_genre_aux = ScrollBar(prompt='Gênero: ', choices=['Feminino', 'Masculino', 'Prefiro não dizer'],
indent=0, margin=2, pointer="★", pad_right=5)
inpt_genre = inpt_genre_aux.launch()
inpt_marital_status = input('Estado civíl: ').capitalize()
inpt_scholarity = input('Escolaridade: ').capitalize()
inpt_years_scholarity = input('De acordo com sua escolaridade, o(a) senhor(a) estudou,'
' formalmente durante quantos anos? ')
inpt_retired = input('O(a) Sr(a) é aposentado? Se não, qual é a sua profissão atual? ')
inpt_retired_pensioner = input('Caso seja aposentado ou pensionista,'
' qual a profissão que exerceu por mais tempo? ')
inpt_paid_work = input('Exerce atualmente algum tipo de trabalho remunerado? Se sim, qual? ')
inpt_individual_income = input('Renda individual: ')
inpt_family_income = input('Renda familiar (se houver): ')
inpt_live_with = input('Com quem mora: ').capitalize()
inpt_have_relegion = input('Possui religião - Sim (S) | Não (N): ')
inpt_have_relegion = (1 if (inpt_have_relegion.upper() == 'S') else 0)
patient = Patient(inpt_first_name, inpt_last_name, inpt_adress, inpt_telephone,
inpt_date_birth, inpt_age, inpt_genre, inpt_marital_status,
inpt_scholarity, inpt_years_scholarity, inpt_retired,
inpt_retired_pensioner, inpt_paid_work, inpt_individual_income,
inpt_family_income, inpt_live_with, inpt_have_relegion)
print('Iniciando a avaliação de %s... \n' % patient.full_name)
return patient
def get_info_from_edit_page(self):
fields = self.wd.find_elements_by_xpath("//input")
def getval(elm):
return elm.get_attribute("value")
last_name = getval(fields[5])
first_name = getval(fields[3])
address = self.wd.find_element_by_xpath("//textarea[1]").text
emails = getval(fields[15]) + getval(fields[16]) + getval(fields[17])
phones = clear(
getval(fields[11]) + getval(fields[12]) + getval(fields[13]) +
getval(fields[21]))
return last_name, first_name, address, emails, phones
def set_categories(self):
utils.clear()
print('{}{} ## Avaliação multidimensional do idoso: {} \n'.format(
utils.Color.BOLD, utils.Color.CYAN, utils.Color.END))
time.sleep(0.5)
ReadJSONFile()
MultidimensionalEvaluation.load_questions()
self._attitudes_aging_score.append(
self.call_tests_score(
questions.QuestionsAttitudesAging.TITLE,
questions.QuestionsAttitudesAging.questions_answers))
self._quality_life_score.append(
self.call_tests_score(
questions.QuestionsQualityLife.TITLE,
questions.QuestionsQualityLife.questions_answers))
self._directions_score.append(
self.call_tests_score(
questions.QuestionsDirections.TITLE,
questions.QuestionsDirections.questions_answers))
self._malnutrition_score.append(
self.call_tests_score(
questions.QuestionsMalnutrition.TITLE,
questions.QuestionsMalnutrition.questions_answers))
self._functional_capacity_score.append(
self.call_tests_score(
questions.QuestionsFunctionalCapacity.TITLE,
questions.QuestionsFunctionalCapacity.questions_answers))
self._depression_score.append(
self.call_tests_score(
questions.QuestionsDepression.TITLE,
questions.QuestionsDepression.questions_answers))
self._cardiovascular_factors_score.append(
self.call_tests_score(
questions.QuestionsCardiovascularFactors.TITLE,
questions.QuestionsCardiovascularFactors.questions_answers))
self._medication_administration_score.append(
self.call_tests_score(
questions.QuesntionsMedicationAdministration.TITLE, questions.
QuesntionsMedicationAdministration.questions_answers))
self._environment_score.append(
self.call_tests_score(
questions.QuestionsEnvironment.TITLE,
questions.QuestionsEnvironment.questions_answers))
self._falls_score.append(
self.call_tests_score(questions.QuestionsFalls.TITLE,
questions.QuestionsFalls.questions_answers))
self._violence_score.append(
self.call_tests_score(
questions.QuestionsViolence.TITLE,
questions.QuestionsViolence.questions_answers))
self._social_vulnerability_score.append(
self.call_tests_score(
questions.QuestionsSocialVulnerability.TITLE,
questions.QuestionsSocialVulnerability.questions_answers))
self._fragility_score.append(
self.call_tests_score(
questions.QuestionsFragility.TITLE,
questions.QuestionsFragility.questions_answers))
self._gerontologist_evaluation_score.append(
self.call_tests_score(
questions.QuestionsGerontologistEvaluation.TITLE,
questions.QuestionsGerontologistEvaluation.questions_answers))
self._planning_actions_score.append(
self.call_tests_score(
questions.QuestionsPlanningActions.TITLE,
questions.QuestionsPlanningActions.questions_answers))
def train_model(model,
criterion,
optimizer,
scheduler,
dataloaders,
dataset_sizes,
model_path,
device,
fold_name,
use_gpu=True,
num_epochs=25,
plot_res=True,
predict_test=True,
save_val=True,
best='loss'):
since = time.time()
torch.save(model.state_dict(), os.path.join(model_path, '_temp'))
best_f1 = 0.0
best_loss = np.inf
best_epoch = 0
train_metrics = []
val_metrics = []
print('=' * 10)
print('VAL data {}'.format(fold_name))
print('=' * 10)
for epoch in range(num_epochs):
model.train(True)
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
running_loss = 0.0
pred = np.array([])
true = np.array([])
phase = 'train'
for data in tqdm(dataloaders[phase]):
optimizer.zero_grad()
inputs, labels = data
if use_gpu:
inputs = Variable(inputs).to(device)
labels = Variable(labels).to(device)
else:
inputs, labels = Variable(inputs), Variable(labels)
outputs = model(inputs)
loss = criterion(
outputs.type(torch.cuda.FloatTensor)[:, 1],
labels.type(torch.cuda.FloatTensor))
#loss = nn.BCEWithLogitsLoss(reduction='sum',
# weight=torch.ones(outputs.shape[0]).to(device) / 5)(outputs.type(torch.cuda.FloatTensor)[:, 1],
# labels.type(torch.cuda.FloatTensor))
loss.backward()
optimizer.step()
running_loss += loss.item()
true = np.append(true, to_numpy(labels, use_gpu))
pred = np.append(pred, sigmoid(to_numpy(outputs[:, 1], use_gpu)))
epoch_loss = running_loss / dataset_sizes[phase]
pr_rec_auc, roc_auc, f1_05, f1_max, f1_auc, metr = calc_metrics(
true, pred)
val_true, val_pred, val_loss = validation(model,
dataloaders,
criterion,
device=device,
use_gpu=use_gpu,
phase='val')
pr_rec_auc_val, roc_auc_val, f1_05_val, f1_max_val, f1_auc_val, metr_val = calc_metrics(
val_true, val_pred)
if scheduler is not None:
scheduler.step((val_loss) / dataset_sizes['val'])
clear()
clear_output()
print('=' * 10)
print('VAL data {}'.format(fold_name))
print('=' * 10)
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
print_results(phase=phase,
loss=epoch_loss,
roc_auc=roc_auc,
pr_rec_auc=pr_rec_auc,
f1_max=f1_max,
f1_05=f1_05,
f1_auc=f1_auc)
print('\n')
print_results(phase='val',
loss=(val_loss) / dataset_sizes['val'],
roc_auc=roc_auc_val,
pr_rec_auc=pr_rec_auc_val,
f1_max=f1_max_val,
f1_05=f1_05_val,
f1_auc=f1_auc_val)
train_metrics.append(metr + [epoch_loss])
val_metrics.append(metr_val + [(val_loss) / dataset_sizes['val']])
if f1_05_val > best_f1:
best_f1 = f1_05_val
if best == 'metric':
best_epoch = epoch
torch.save(model.state_dict(),
os.path.join(model_path, '_temp'))
if (val_loss) / dataset_sizes['val'] < best_loss:
best_loss = (val_loss) / dataset_sizes['val']
if best == 'loss':
best_epoch = epoch
torch.save(model.state_dict(),
os.path.join(model_path, '_temp'))
time_elapsed = time.time() - since
print('Elapsed {:.0f}m {:.0f}s\n'.format(time_elapsed // 60,
time_elapsed % 60))
np.save(os.path.join(model_path, 'val_metrics_' + fold_name),
val_metrics)
np.save(os.path.join(model_path, 'train_metrics_' + fold_name),
train_metrics)
print('Current best: {:4f}, epoch {}'.format(best_f1, best_epoch))
if plot_res:
vizualize(model_path,
fold_name,
show=False,
save=True,
save_format='.png')
time_elapsed = time.time() - since
print('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
print('Best val f1_05: {:4f}'.format(best_f1))
print('Best val loss: {:4f}'.format(best_loss))
if best is not None:
model.load_state_dict(torch.load(os.path.join(model_path, '_temp')))
vizualize(model_path, fold_name, show=False, save=True, save_format='.pdf')
if predict_test:
results = pd.DataFrame()
test_true, test_pred, _ = validation(model,
dataloaders,
criterion,
device=device,
use_gpu=use_gpu,
phase='test')
results['pred'] = test_pred
results['pseudo_true'] = test_true
results['file'] = [
sample[0] for sample in dataloaders['test'].dataset.samples
]
results.to_csv(os.path.join(model_path,
'test_results_' + fold_name + '.csv'),
index=False)
if save_val:
results = pd.DataFrame()
val_true, val_pred, _ = validation(model,
dataloaders,
criterion,
device=device,
use_gpu=use_gpu,
phase='val')
results['true'] = val_true
results['pred'] = val_pred
results['file'] = [
sample[0] for sample in dataloaders['val'].dataset.samples
]
results.to_csv(os.path.join(model_path,
'val_results_' + fold_name + '.csv'),
index=False)
del inputs, labels, loss
return model, best_f1