def main():
dataset_train = read_dataset(
"https://raw.githubusercontent.com/dataminerdbm/test_data_scientist/main/treino.csv"
)
dataset_test = read_dataset(
"https://raw.githubusercontent.com/dataminerdbm/test_data_scientist/main/teste.csv"
)
dataset_train.replace(to_replace=[None], value=np.nan, inplace=True)
dataset_test.replace(to_replace=[None], value=np.nan, inplace=True)
raw_dataset_values_train = dataset_train.drop(columns=['inadimplente'])
transformed_values_train = input_data(raw_dataset_values_train)
transformed_values_test = input_data(dataset_test)
# Deve-se utilizar a mesma escala de dados para o treinamento e teste
# https://datascience.stackexchange.com/questions/27615/should-we-apply-normalization-to-test-data-as-well
scaler = StandardScaler()
standardized_values_train = scaler.fit_transform(transformed_values_train)
standardized_values_test = scaler.transform(transformed_values_test)
standardized_values_train = pd.DataFrame(
standardized_values_train, columns=raw_dataset_values_train.keys())
standardized_values_test = pd.DataFrame(standardized_values_test,
columns=dataset_test.keys())
train_x = standardized_values_train
train_y = dataset_train.inadimplente
test_x = standardized_values_test
undersample = RandomUnderSampler(sampling_strategy='majority')
model = RandomForestClassifier()
X_under, y_under = undersample.fit_resample(train_x, train_y)
model.fit(X_under, y_under)
filename = 'test_data_scientist_dataminer/modelo-adaboost.joblib'
dump(model, filename)
loaded_model = load(filename)
predictions = model.predict(test_x)
dataset_test_raw_df = read_dataset(
"https://raw.githubusercontent.com/dataminerdbm/test_data_scientist/main/teste.csv"
)
dataset_test_raw_df['inadimplente'] = predictions
dataset_test_raw_df.to_csv("test_data_scientist_dataminer/teste.csv",
index=False)
def retrieve_images(self):
images,labels,_ = util.read_dataset(self.root)
img_ph_list,img_bg_list = util.crop_out(images,labels)
ph_dict = [{'mat': np.rollaxis(x, 2, 0) , 'val': 1} for x in img_ph_list]
bg_dict = [{'mat': np.rollaxis(x, 2, 0) , 'val': 0} for x in img_bg_list]
mix_dict = ph_dict + bg_dict
shuffle(mix_dict)
return mix_dict
parser.add_argument('--dims', type=int, help="dims", default=5)
parser.add_argument('--epochs', type=int, help="epochs", default=10)
args, unparsed = parser.parse_known_args()
# ##################################################
EPOCHES = args.epochs
DIM_NUM = args.dims
learning_rate = 0.0002
BATCH_SIZE = 5
DIS_STEP = 5
# real data
# ######################################## difference from mpc
prefix = '../playground/datasets/'
file_name_prefix = prefix + str(DIM_NUM) + "D/" + str(DIM_NUM) + "d"
real_X = read_dataset(file_name_prefix + "_attr_plain.csv")
real_Y = read_dataset(file_name_prefix + "_label_plain.csv")
# ######################################## difference from mpc
real_X = np.array(real_X)
real_Y = np.array(real_Y)
X = tf.placeholder(tf.float32, real_X.shape)
Y = tf.placeholder(tf.float32, real_Y.shape)
print(X)
print(Y)
# initialize W & b
W = tf.Variable(tf.zeros([DIM_NUM, 1]))
b = tf.Variable(tf.zeros([1]))
print(W)
print(b)
learning_rate = 0.0002
BATCH_SIZE = 5
DIS_STEP = 5
# real data (for test, use an option to distinguish)
# ######################################## difference from tf
my_party_id = args.party_id
if my_party_id == 2:
my_party_id = 0
prefix = '../playground/datasets/'
file_name_prefix = prefix + str(DIM_NUM) + "D/" + str(DIM_NUM) + "d"
file_name_suffix = "share_" + str(my_party_id) + ".csv"
real_X = read_dataset(file_name_prefix + "_attr_" + file_name_suffix)
real_Y = read_dataset(file_name_prefix + "_label_" + file_name_suffix)
# ######################################## difference from tf
X = tf.Variable(real_X)
Y = tf.Variable(real_Y)
print(X)
print(Y)
# initialize W & b
W = tf.Variable(tf.zeros([DIM_NUM, 1], dtype=tf.float64))
b = tf.Variable(tf.zeros([1], dtype=tf.float64))
print(W)
print(b)
# predict
def main():
global args, best_er1
args = parser.parse_args()
# Check if CUDA is enabled
args.cuda = not args.no_cuda and torch.cuda.is_available()
for tgt_idx, tgt in enumerate(dataset_targets[args.dataset]):
print("Training a model for {}".format(tgt))
# Load data
root = args.dataset_path if args.dataset_path else dataset_paths[
args.dataset]
task_type = args.dataset_type if args.dataset_type else dataset_types[
args.dataset]
if args.resume:
resume_dir = args.resume.format(dataset=args.dataset,
model=args.model,
layers=args.layers,
feature=tgt)
#end if
Model_Class = model_dict[args.model]
print("Preparing dataset")
node_features, edge_features, target_features, task_type, train_loader, valid_loader, test_loader = read_dataset(
args.dataset, root, args.batch_size, args.prefetch)
# Define model and optimizer
print('\tCreate model')
hidden_state_size = args.hidden
model = Model_Class(node_features=node_features,
edge_features=edge_features,
target_features=1,
hidden_features=hidden_state_size,
num_layers=args.layers,
dropout=0.5,
type=task_type,
s2s_processing_steps=args.s2s)
print("#Parameters: {param_count}".format(
param_count=count_params(model)))
print('Optimizer')
optimizer = optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
criterion, evaluation, metric_name, metric_compare, metric_best = get_metric_by_task_type(
task_type, target_features)
print('Logger')
logger = Logger(
args.log_path.format(dataset=args.dataset,
model=args.model,
layers=args.layers,
feature=tgt))
lr_step = (args.lr - args.lr * args.lr_decay) / (
args.epochs * args.schedule[1] - args.epochs * args.schedule[0])
# get the best checkpoint if available without training
if args.resume:
checkpoint_dir = resume_dir
best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
if not os.path.isdir(checkpoint_dir):
os.makedirs(checkpoint_dir)
if os.path.isfile(best_model_file):
print("=> loading best model '{}'".format(best_model_file))
checkpoint = torch.load(best_model_file)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_er1']
model.load_state_dict(checkpoint['state_dict'])
if args.cuda:
model.cuda()
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded best model '{}' (epoch {})".format(
best_model_file, checkpoint['epoch']))
else:
print("=> no best model found at '{}'".format(best_model_file))
print('Check cuda')
if args.cuda:
print('\t* Cuda')
model = model.cuda()
criterion = criterion.cuda()
# Epoch for loop
for epoch in range(0, args.epochs):
try:
if epoch > args.epochs * args.schedule[
0] and epoch < args.epochs * args.schedule[1]:
args.lr -= lr_step
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
#end if
# train for one epoch
train(train_loader,
model,
criterion,
optimizer,
epoch,
evaluation,
logger,
target_range=(tgt_idx, ),
tgt_name=tgt,
metric_name=metric_name,
cuda=args.cuda,
log_interval=args.log_interval)
# evaluate on test set
er1 = validate(valid_loader,
model,
criterion,
evaluation,
logger,
target_range=(tgt_idx, ),
tgt_name=tgt,
metric_name=metric_name,
cuda=args.cuda,
log_interval=args.log_interval)
is_best = metric_compare(er1, best_er1)
best_er1 = metric_best(er1, best_er1)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_er1': best_er1,
'optimizer': optimizer.state_dict(),
},
is_best=is_best,
directory=resume_dir)
# Logger step
logger.log_value('learning_rate', args.lr).step()
except KeyboardInterrupt:
break
#end try
#end for
# get the best checkpoint and test it with test set
if args.resume:
checkpoint_dir = resume_dir
best_model_file = os.path.join(checkpoint_dir, 'model_best.pth')
if not os.path.isdir(checkpoint_dir):
os.makedirs(checkpoint_dir)
if os.path.isfile(best_model_file):
print("=> loading best model '{}'".format(best_model_file))
checkpoint = torch.load(best_model_file)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_er1']
model.load_state_dict(checkpoint['state_dict'])
if args.cuda:
model.cuda()
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded best model '{}' (epoch {})".format(
best_model_file, checkpoint['epoch']))
else:
print("=> no best model found at '{}'".format(best_model_file))
#end if
#end if
# (For testing)
validate(test_loader,
model,
criterion,
evaluation,
target_range=(tgt_idx, ),
tgt_name=tgt,
metric_name=metric_name,
cuda=args.cuda,
log_interval=args.log_interval)
import initializer
import os.path
import os
import sys
import cv2
from matplotlib import pyplot as plt
import numpy as np
import util
import math
import csv
# Training set
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
dataset_path = BASE_DIR + '/dataset/' + 'Video Data-03-08-2015/extended_dataset.csv'
dataset = util.read_dataset(dataset_path,
244,
split_teain_test=True,
split_ratio=0.7)
train_set = dataset['train_set']
test_set = dataset['test_set']
blurry_set = dataset['blury_set']
cropped_set = dataset['cropped_set']
number_of_samples = len(train_set['X'])
log_file = BASE_DIR + '/logs/classifier_7.0.csv'
f = open(log_file, 'wt')
writer = csv.writer(f)
writer.writerow(('Epoch', 'Iteration', 'Phase', 'Accuracy', 'Loss'))
# For test purpose
# print train_set['X'][0].shape
# plt.imshow(train_set['X'][0], interpolation = 'bicubic')
init = tf.global_variables_initializer()
# def read_dataset(file_name = None):
# if file_name is None:
# print("Error! No file name!")
# return
# res_data = []
# with open(file_name, 'r') as f:
# cr = csv.reader(f)
# for each_r in cr:
# curr_r = [np.array([v], dtype=np.float_)[0] for v in each_r]
# res_data.append(curr_r)
# #print(each_r)
# return res_data
file_name_prefix = str("../datasets/") + str(DIM_NUM) + "D/" + str(DIM_NUM) + "d"
plain_attr_ds = read_dataset(file_name_prefix + "_attr_plain.csv")
plain_label_ds = read_dataset(file_name_prefix + "_label_plain.csv")
save_file_prefix = "./comp_log/native"
with tf.Session() as native_sess:
native_sess.run(init)
xW, xb = native_sess.run([W, b])
print("init weight:{} \nbias:{}".format(xW, xb))
total_batch = int(len(plain_attr_ds) / BATCH_SIZE)
start_t = time.time()
for epoch in range(EPOCHES):
avg_loss = 0.0
#print("batch:", total_batch)
curr_loss = None
def main():
dataset = read_dataset(
"https://raw.githubusercontent.com/dataminerdbm/test_data_scientist/main/treino.csv"
)
dataset.replace(to_replace=[None], value=np.nan, inplace=True)
raw_dataset_values = dataset.drop(columns=['inadimplente'])
transformed_values = input_data(raw_dataset_values)
standardized_values = rescale_data(transformed_values, raw_dataset_values)
# calc_corr_fig(standardized_values)
x = standardized_values
# Remove-se as demais características correlacionadas, mantendo-se apenas uma
x_without_corr_feat = standardized_values.drop(columns=[
'vezes_passou_de_30_59_dias', 'numero_de_vezes_que_passou_60_89_dias'
])
y = dataset.inadimplente
SEED = 7707
np.random.seed(SEED)
# Realiza-se a estratificação dos dados tendo em vista o desbalanceamento da base
train_x, test_x, train_y, test_y = train_test_split(x,
y,
test_size=0.3,
stratify=y)
train_x_without_corr_feat, test_x_without_corr_feat, train_y_without_corr_feat, test_y_without_corr_feat = train_test_split(
x_without_corr_feat, y, test_size=0.3, stratify=y)
undersample = RandomUnderSampler(sampling_strategy='majority')
X_without_corr_feat_under, y_without_corr_feat_under = undersample.fit_resample(
x_without_corr_feat, y)
x_under, y_under = undersample.fit_resample(x, y)
train_x_under, train_y_under = undersample.fit_resample(train_x, train_y)
train_x_without_corr_feat_under, train_y_without_corr_feat_under = undersample.fit_resample(
train_x_without_corr_feat, train_y_without_corr_feat)
#tsne_scatterplot(x_without_corr_feat, y)
# Os classificadores validados foram escolhidos de acordo com o aspecto da base de dados:
# características numéricas, multidimensional com alto número de instâncias e problema não linearmente separável
models = [
DummyClassifier(),
KNeighborsClassifier(),
DecisionTreeClassifier(),
GaussianNB(),
AdaBoostClassifier(n_estimators=100),
RandomForestClassifier(),
BaggingClassifier(base_estimator=GaussianNB(), n_estimators=100)
]
k_size = 5
# Criando aleatoridade nos grupos de folds (para evitar repetição). Abordagem mais adequada para bases desbalanceadas
# https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GroupKFold.html#sklearn.model_selection.GroupKFold
x_under['idade_r'] = x_under.idade + np.random.randint(-2, 3, size=14662)
x_under.idade_r = x_under.idade + abs(x_under.idade.min()) + 1
print("Validando modelos com todas as características")
validate_models_cv(x_under, y_under, x_under.idade_r, models, k_size)
validate_models_holdout(train_x_under, train_y_under, test_x, test_y,
models, k_size)
print("Validando modelos sem as características correlacionadas")
validate_models_cv(X_without_corr_feat_under, y_without_corr_feat_under,
x_under.idade_r, models, k_size)
validate_models_holdout(train_x_without_corr_feat_under,
train_y_without_corr_feat_under,
test_x_without_corr_feat, test_y_without_corr_feat,
models, k_size)
def train():
print("Start training.")
mkdir(args.output_result_path)
writer_process = open(os.path.join(args.output_result_path,
'process.txt'),
mode='w')
writer_process.writelines("Start training.")
trainset = read_dataset(args, args.train_path, label_columns, vocab)
random.shuffle(trainset)
best_josn['train_num'] = len(trainset)
input_ids = torch.LongTensor([example[0] for example in trainset])
label_ids = torch.LongTensor([example[1] for example in trainset])
length_ids = torch.LongTensor([example[2] for example in trainset])
print("Batch size: ", args.batch_size)
print("The number of training instances:", best_josn['train_num'])
start_time = time.time()
best_josn['Time'] = get_time_dif(start_time)
print("Time usage:", best_josn['Time'])
param_optimizer = list(model.named_parameters())
nll_criterion = nn.NLLLoss()
if args.attention_layer == 'm_pol_untrain_a':
optimizer_grouped_parameters = [{
'params': [
p for n, p in param_optimizer
if ('query_embedding.weight' not in n)
],
'weight_decay_rate':
0.01
}]
else:
optimizer_grouped_parameters = [{
'params': [p for n, p in param_optimizer],
'weight_decay_rate':
0.01
}]
optimizer = optim.SGD(optimizer_grouped_parameters,
lr=args.learning_rate,
momentum=args.momentum)
for epoch in range(1, args.epochs_num + 1):
model.train()
for i, (input_ids_batch, label_ids_batch,
length_ids_batch) in enumerate(
batch_loader(args.batch_size, input_ids, label_ids,
length_ids)):
model.zero_grad()
input_ids_batch = input_ids_batch.cuda()
label_ids_batch = label_ids_batch.cuda()
length_ids_batch = length_ids_batch.cuda()
if args.attention_layer == 'att':
predicted_ids_batch, _ = model(input_ids_batch,
length_ids_batch,
elmo_embedding)
else:
predicted_ids_batch, _, orthogonal_loss = model(
input_ids_batch, length_ids_batch, elmo_embedding)
best_josn['Total_orthogonal_loss'] += orthogonal_loss
batch_loss = nll_criterion(predicted_ids_batch,
label_ids_batch)
best_josn['Total_batch_loss'] += batch_loss
if args.attention_layer != 'm_pre_orl_pun_a' and args.attention_layer != 'mpoa':
optimizer.zero_grad()
batch_loss.backward()
optimizer.step()
else:
optimizer.zero_grad()
(0.1 * orthogonal_loss).backward(retain_graph=True)
(0.9 * batch_loss).backward()
optimizer.step()
best_josn['Time'] = get_time_dif(start_time)
if (i + 1) % args.report_steps == 0:
if args.attention_layer == 'att':
print(
"Epoch id: {}, Training steps: {}, Avg batch loss: {:.4f}, Time: {}"
.format(
epoch, i + 1, best_josn['Total_batch_loss'] /
args.report_steps, best_josn['Time']))
writer_process.writelines(
"Epoch id: {}, Training steps: {}, Avg batch loss: {:.4f}, Time: {}"
.format(
epoch, i + 1, best_josn['Total_batch_loss'] /
args.report_steps, best_josn['Time']))
else:
print(
"Epoch id: {}, Training steps: {}, Avg batch loss: {:.4f}, Avg orthogonal loss: {:.4f}, Time: {}"
.format(
epoch, i + 1, best_josn['Total_batch_loss'] /
args.report_steps,
best_josn['Total_orthogonal_loss'] /
args.report_steps, best_josn['Time']))
writer_process.writelines(
"Epoch id: {}, Training steps: {}, Avg batch loss: {:.4f}, Avg orthogonal loss: {:.4f}, Time: {}"
.format(
epoch, i + 1, best_josn['Total_batch_loss'] /
args.report_steps,
best_josn['Total_orthogonal_loss'] /
args.report_steps, best_josn['Time']))
best_josn['Total_batch_loss'] = 0
best_josn['Total_orthogonal_loss'] = 0
# 读取验证集
evaluate(args, False)
best_josn['Time'] = get_time_dif(start_time)
if best_josn['F_macro'] > best_josn['Best_F_macro'] + 0.001:
best_josn['Best_F_macro'] = best_josn['F_macro']
best_josn['Last_up_epoch'] = epoch
torch.save(model,
os.path.join(args.output_result_path, 'result.pkl'))
print("Deving Acc: {:.4f}, F_macro: {:.4f}, Time: {} *".format(
best_josn['ACC'], best_josn['F_macro'], best_josn['Time']))
writer_process.writelines(
"Deving Acc: {:.4f}, F_macro: {:.4f}, Time: {} *".format(
best_josn['ACC'], best_josn['F_macro'],
best_josn['Time']))
elif epoch - best_josn['Last_up_epoch'] == args.require_improvement:
print("No optimization for a long time, auto-stopping...")
writer_process.writelines(
"No optimization for a long time, auto-stopping...")
break
else:
print("Deving Acc: {:.4f}, F_macro: {:.4f}, Time: {} ".format(
best_josn['ACC'], best_josn['F_macro'], best_josn['Time']))
writer_process.writelines(
"Deving Acc: {:.4f}, F_macro: {:.4f}, Time: {} ".format(
best_josn['ACC'], best_josn['F_macro'],
best_josn['Time']))
def evaluate(args, is_test):
model.eval()
if is_test:
print("Start testing.")
dataset = read_dataset(args, args.test_path, label_columns, vocab)
best_josn['test_num'] = len(dataset)
writer_result = open(os.path.join(args.output_result_path,
'result.txt'),
encoding='utf-8',
mode='w')
writer_summary_result = open(os.path.join(args.summary_result_path,
'summary_result.txt'),
mode='a')
else:
dataset = read_dataset(args, args.dev_path, label_columns, vocab)
best_josn['dev_num'] = len(dataset)
random.shuffle(dataset)
input_ids = torch.LongTensor([example[0] for example in dataset])
label_ids = torch.LongTensor([example[1] for example in dataset])
length_ids = torch.LongTensor([example[2] for example in dataset])
input = [example[3] for example in dataset]
if is_test:
batch_size = 1
else:
batch_size = args.batch_size
for i, (input_ids_batch, label_ids_batch,
length_ids_batch) in enumerate(
batch_loader(batch_size, input_ids, label_ids,
length_ids)):
model.zero_grad()
input_ids_batch = input_ids_batch.cuda()
label_ids_batch = label_ids_batch.cuda()
length_ids_batch = length_ids_batch.cuda()
if args.attention_layer == 'att':
predicted, weight = model(input_ids_batch, length_ids_batch,
elmo_embedding)
else:
predicted, weight, _ = model(input_ids_batch, length_ids_batch,
elmo_embedding)
best_josn['Weights'] += weight.squeeze(
dim=1).cpu().detach().numpy().tolist()
_, predicted_labels = torch.max(predicted.data, 1)
best_josn['Predict'] += predicted_labels.cpu().numpy().tolist()
best_josn['Label'] += label_ids_batch.data.cpu().numpy().tolist()
if is_test:
details_result = metrics.classification_report(
best_josn['Label'], best_josn['Predict'])
best_josn['P_macro'], best_josn['R_macro'], best_josn[
'F_macro'], _ = metrics.precision_recall_fscore_support(
best_josn['Label'], best_josn['Predict'], average="macro")
best_josn['ACC'] = metrics.classification.accuracy_score(
best_josn['Label'], best_josn['Predict'])
saveSenResult(input, best_josn['Label'], best_josn['Predict'],
args, best_josn['Weights'])
writer_result.writelines(details_result)
print(
"Testing Acc: {:.4f}, F_macro: {:.4f}, P_macro: {:.4f}, R_macro: {:.4f}"
.format(best_josn['ACC'], best_josn['F_macro'],
best_josn['P_macro'], best_josn['R_macro']))
writer_result.writelines(
"Testing Acc: {:.4f}, F_macro: {:.4f}, P_macro: {:.4f}, R_macro: {:.4f}"
.format(best_josn['ACC'], best_josn['F_macro'],
best_josn['P_macro'], best_josn['R_macro']))
writer_summary_result.writelines('保存路径' + args.output_result_path +
'\n')
writer_summary_result.writelines(
"Testing Acc: {:.4f}, F_macro: {:.4f}, P_macro: {:.4f}, R_macro: {:.4f}\n\n"
.format(best_josn['ACC'], best_josn['F_macro'],
best_josn['P_macro'], best_josn['R_macro']))
writer_summary_result.writelines(details_result)
else:
best_josn['P_macro'], best_josn['R_macro'], best_josn[
'F_macro'], _ = metrics.precision_recall_fscore_support(
best_josn['Label'], best_josn['Predict'], average="macro")
best_josn['ACC'] = metrics.classification.accuracy_score(
best_josn['Label'], best_josn['Predict'])
stride = 25
device = torch.device("cpu")
# load model
from cnn_simple import Net
# only load param
# model = Net()
# model.load_state_dict(torch.load('trained.pth'))
# or load the entire model
path = sys.argv[1]
model = torch.load('trained.pth')
model.eval()
acc = 0
# load the image
images,labels,names = util.read_dataset(path)
for k,mat in enumerate(images):
# mat = cv2.imread(img)
img_wid = mat.shape[1]
img_hgt = mat.shape[0]
# run a window through the image to find highest score region
# can improve using YOLO with muliti scale/coarse level window,
# and evaluate IOT
windows = []
for j in range(0,img_hgt-2*l,stride):
for i in range(0,img_wid-2*l,stride):
window = mat[j:j+2*l,i:i+2*l]
window = np.rollaxis(window, 2, 0)
windows.append(window)
def main():
params = load_params()
m = get_model(conv_units=params['model']['conv_units'])
m.summary()
training_images, training_labels, testing_images, testing_labels = read_dataset(
DATASET_FILE)
assert training_images.shape[0] + testing_images.shape[0] == 70000
assert training_labels.shape[0] + testing_labels.shape[0] == 70000
training_images = normalize(training_images)
testing_images = normalize(testing_images)
training_labels = tf.keras.utils.to_categorical(training_labels,
num_classes=10,
dtype="float32")
testing_labels = tf.keras.utils.to_categorical(testing_labels,
num_classes=10,
dtype="float32")
# We use the test set as validation for simplicity
x_train = training_images
x_valid = testing_images
y_train = training_labels
y_valid = testing_labels
history = m.fit(
x_train,
y_train,
batch_size=BATCH_SIZE,
epochs=params["train"]["epochs"],
verbose=1,
validation_data=(x_valid, y_valid),
callbacks=[DvcLiveCallback(model_file=f"{OUTPUT_DIR}/model.h5")],
)
metrics_dict = m.evaluate(
testing_images,
testing_labels,
batch_size=BATCH_SIZE,
return_dict=True,
)
with open(METRICS_FILE, "w") as f:
f.write(json.dumps(metrics_dict))
misclassified = {}
# predictions for the confusion matrix
y_prob = m.predict(x_valid)
y_pred = y_prob.argmax(axis=-1)
os.makedirs("plots")
with open("plots/confusion.csv", "w") as f:
f.write("actual,predicted\n")
sx = y_valid.shape[0]
for i in range(sx):
actual = y_valid[i].argmax()
predicted = y_pred[i]
f.write(f"{actual},{predicted}\n")
misclassified[(actual, predicted)] = x_valid[i]
# find misclassified examples and generate a confusion table image
confusion_out = create_image_matrix(misclassified)
imageio.imwrite("plots/confusion.png", confusion_out)
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
init = tf.global_variables_initializer()
file_name_prefix = str("../datasets/") + str(DIM_NUM) + "D/" + str(DIM_NUM) + "d"
#parser = argparse.ArgumentParser(description="MPC Logistic Regression with SCE loss demo")
#parser.add_argument('--party_id', type=int, help="Party ID")
#args = parser.parse_args()
my_party_id = args.party_id
if my_party_id == 2:
my_party_id = 0
file_name_suffix = "share_" + str(my_party_id) + ".csv"
shared_attr_ds = read_dataset(file_name_prefix + "_attr_" + file_name_suffix)
shared_label_ds = read_dataset(file_name_prefix + "_label_" + file_name_suffix)
# print(shared_attr_ds)
# print(shared_label_ds)
if args.party_id == 0:
csvprefix = "./comp_log/mpc"
with tf.Session() as mpc_sess:
mpc_sess.run(init)
total_batch = int(len(shared_attr_ds) / BATCH_SIZE)
start_t = time.time()
for epoch in range(EPOCHES):
avg_loss = 0.0
#print("batch:", total_batch)
