def main(config, process, modeltype='cnsi', model2test=None):
print('model name..')
print(modeltype)
if process == 'pretrain':
print('pretraining config..:')
print(json.dumps(config['pretrain'], indent=2))
pretrain(config, 'coco')
print('loading data..')
starttime = time.time()
num_words, embedding_matrix, train_data, valid_data, test_data = loadData(
config)
print('data loaded in {} seconds'.format(time.time() - starttime))
if process == 'trainstage1':
print('stage 1 model parameters..:')
print(json.dumps(config['stage1'], indent=2))
trainstage1(config, train_data, valid_data, num_words,
embedding_matrix)
if process == 'trainstage2':
print('stage 2 model parameters..:')
print(json.dumps(config['stage2'], indent=2))
trainstage2(config, train_data, valid_data, num_words,
embedding_matrix, modeltype)
if process == 'test':
test(config, model2test, test_data, num_words, embedding_matrix,
modeltype)
return True
def main():
directory = 'common'
windowSize = 256
windowSlide = 32
removePart = 0.15
testing = False # if True use a smaller set of data and don't save features to csv files
classify = True # make classification and store results using ALL features if True
#classWeight = None # balanced or None (for decision tree classifier)
classWeight = 'balanced'
parameters = str(windowSize) + '_' + str(windowSlide)
activities, data, totalDataPoints, labels = loadData(
"data\ADL_Dataset", windowSize, windowSlide, removePart)
print("\nActivities:\n", activities)
print("\nNumber of activities read: ", len(activities))
print("Number of data points read: ", totalDataPoints)
print("Number of readings read: ", len(data))
print("Number of window labels read: ", len(labels), "\n")
if testing:
N = 30
else:
N = len(labels)
# convert data into a Pandas dataframe with the specified column names
# the id column contains one number for each different window and is used to group datapoints for each window
df_data = pd.DataFrame(data, columns=['x', 'y', 'z', 'id'])
print("\ndf_data shape:")
print(df_data.shape)
# we extract the smaller set of data or if not specified the entire data set is used
df_test = df_data.iloc[:windowSize * (N), :]
print("\ndf_test shape:")
print(df_test.shape)
print("\ndf_test first 5 rows:")
print(df_test.head())
# convert label data to Pandas series
y = pd.Series(labels[:N])
print("\nShape of Y: ")
print(y.shape)
print(y.head())
# Extract features on the windows
X = extractFeatures(df_test)
#X = loadCsv('common', '288_32_features_all_190409_1511.csv')
# save all features to csv file
if not testing:
writeCsv(directory, parameters, 'features_all', X)
writeCsv(directory, parameters, 'labels_all', y)
##### train classifier on all features #####
if classify:
classification(parameters, classWeight, X, y, directory)
def baseLineError(datasetName, baseLineRefDict, baselineName):
''' Compute baselines method and evaluate them by comparing them to some reference
Args:
datasetName (str): the name of the dataset to compute baselines on
baseLineRefDict (dict): a dictionnary containing one reference vector for each type of baseline
baselineName (str): the type of baseline desired (can be 'mos','sr_mos' or 'zs_sr_mos'.)
Returns:
the error made by the chosen baseline method on the chosen dataset relative to the reference
'''
dataset, _ = load_data.loadData(datasetName)
baseline, _ = computeBaselines(dataset, baselineName)
error = np.sqrt(
np.power(baseline - baseLineRefDict[baselineName], 2).sum() /
len(baseLineRefDict[baselineName]))
return error
def main(config, process):
# load all data
print('Loading data')
num_words, embedding_matrix, train_data, valid_data, test_data = loadData(
config)
assert config['model'] == 'baseline'
print('config:')
print(json.dumps(config, indent=2))
init(config['stage1'])
if process == 'train':
train(config, num_words, embedding_matrix, train_data, valid_data)
if process == 'test':
test(config, num_words, embedding_matrix, test_data)
if process == 'eval':
evaluate(config)
return True
def main():
directory = 'common'
windowSize = 256
windowSlide = 32
removePart = 0.15
dataInfo = 'windows_all'
parameters = str(windowSize) + '_' + str(windowSlide)
activities, data, totalDataPoints, labels = loadData(
"data\ADL_Dataset", windowSize, windowSlide, removePart)
print("\nActivities:\n", activities)
print("\nNumber of activities read: ", len(activities))
print("Number of data points read: ", totalDataPoints)
print("Number of readings read: ", len(data))
print("Number of window labels read: ", len(labels), "\n")
df_data = pd.DataFrame(data, columns=['x', 'y', 'z', 'id'])
print("\ndf_data shape:")
print(df_data.shape)
writeCsv(directory, parameters, dataInfo, df_data)
#get temperatures and filenames
Tlist = list(np.genfromtxt('temperatures'))
rep1 = 0 #don't use the first rep1 replicas. There is a better way to do this.
Tlist = Tlist[(rep1):]
nrep = len(Tlist)
filenames = [inprefix + '.' + str(n + rep1 + 1) for n in range(nrep)]
#OK, now we have a list of temperatures and filenames for each replicas
print "replica list:"
for n in range(nrep):
print Tlist[n], filenames[n]
print "USING nfree = ", nfree
#load data
datalist = load_data.loadData(filenames, [ecolumn], fskip=rskip)
#determine bin edges
binenergy1 = load_data.determineBinEdge(nebins,
datalist,
column=0,
exponential_bins=True)
#histogram the data
visits1d = load_data.binData1d(binenergy1, datalist)
#visits1d = np.transpose(visits1d)
wham = WHAM.Wham1d(Tlist, binenergy1[:-1], visits1d)
wham.minimize()
#wham.globalMinimization()
rep1=0 #don't use the first rep1 replicas. There is a better way to do this.
Tlist=Tlist[(rep1):]
nrep = len(Tlist)
filenames=[inprefix+'.'+str(n+rep1+1) for n in range(nrep)]
#OK, now we have a list of temperatures and filenames for each replicas
print "replica list:"
for n in range(nrep):
print Tlist[n], filenames[n]
print "USING nfree = ", nfree
#load data
datalist = load_data.loadData(filenames, [ecolumn], fskip=rskip )
#determine bin edges
binenergy1 = load_data.determineBinEdge(nebins, datalist, column=0, exponential_bins=True)
#histogram the data
visits1d = load_data.binData1d(binenergy1, datalist)
#visits1d = np.transpose(visits1d)
wham = WHAM.wham1d(Tlist, binenergy1[:-1], visits1d)
wham.minimize()
#wham.globalMinimization()
print "dumping WHAM1d to pickle file: ", pklname
pickle.dump(wham,open(pklname,"wb"))
import sys
from load_data import loadData
from nightowl.app import app
if __name__ == '__main__':
if len(sys.argv) == 2:
if sys.argv[1] == 'insert_test_data':
loadData('instance')
else:
app.run()
def main(argv=None):
#Getting arguments from config file and command line
#Building the arg reader
argreader = ArgReader(argv)
argreader.parser.add_argument(
'--only_init',
action='store_true',
help='To initialise a model without training it.\
This still computes the confidence intervals'
)
argreader.parser.add_argument(
'--init_id',
type=str,
metavar="N",
help='The index of the model to use as initialisation. \
The weight of the last epoch will be used.'
)
#Reading the comand line arg
argreader.getRemainingArgs()
args = argreader.args
torch.manual_seed(args.seed)
random.seed(args.seed)
np.random.seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
#The folders where the experience file will be written
if not (os.path.exists("../vis/{}".format(args.exp_id))):
os.makedirs("../vis/{}".format(args.exp_id))
if not (os.path.exists("../results/{}".format(args.exp_id))):
os.makedirs("../results/{}".format(args.exp_id))
if not (os.path.exists("../models/{}".format(args.exp_id))):
os.makedirs("../models/{}".format(args.exp_id))
#Loading data
trainSet, distorNbList = load_data.loadData(args.dataset)
#Write the arguments in a config file so the experiment can be re-run
argreader.writeConfigFile("../models/{}/model{}.ini".format(
args.exp_id, args.ind_id))
if args.cuda:
trainSet = trainSet.cuda()
#Building the model
model = modelBuilder.modelMaker(trainSet.size(1), len(trainSet),
distorNbList, args)
if args.cuda:
model = model.cuda()
#Inititialise the model
if args.start_mode == "base_init":
model.init(trainSet,args.dataset,args.score_dis,args.param_not_gt,\
args.true_scores_init,args.bias_init,args.diffs_init,args.incons_init,truescores_tanh=args.truescores_tanh,bias_tanh=args.bias_tanh,bias_ampl=args.bias_ampl)
startEpoch = 1
elif args.start_mode == "iter_init":
model.init(trainSet,args.dataset,args.score_dis,args.param_not_gt,\
args.true_scores_init,args.bias_init,args.diffs_init,args.incons_init,truescores_tanh=args.truescores_tanh,bias_tanh=args.bias_tanh,bias_ampl=args.bias_ampl,iterInit=True)
startEpoch = 1
elif args.start_mode == "fine_tune":
init_path = sorted(glob.glob("../models/{}/model{}_epoch*".format(
args.exp_id, args.init_id)),
key=processResults.findNumbers)[-1]
model.load_state_dict(torch.load(init_path))
startEpoch = processResults.findNumbers(
os.path.basename(init_path).replace("model{}".format(args.init_id),
""))
else:
raise ValueError("Unknown init method : {}".format(args.start_mode))
#Adding normal noise to the gradients
gradNoise = GradNoise(ampl=args.noise)
for p in model.parameters():
p.register_hook(gradNoise)
torch.save(model.state_dict(),
"../models/{}/model{}_epoch0".format(args.exp_id, args.ind_id))
#Write the parameters of the model and its confidence interval in a csv file
loss = model(trainSet)
paramsToCsv(loss,
model,
args.exp_id,
args.ind_id,
epoch=0,
scoresDis=args.score_dis,
score_min=args.score_min,
score_max=args.score_max,
truescores_tanh=args.truescores_tanh,
bias_tanh=args.bias_tanh,
bias_ampl=args.bias_ampl)
if not args.only_init:
#Getting the contructor and the kwargs for the choosen optimizer
optimConst, kwargs = get_OptimConstructor(args.optim, args.momentum)
#If no learning rate is schedule is indicated (i.e. there's only one learning rate),
#the args.lr argument will be a float and not a float list.
#Converting it to a list with one element makes the rest of processing easier
if type(args.lr) is float:
args.lr = [args.lr]
model.setPrior(args.prior, args.dataset)
loss, epoch = train(model,
optimConst,
kwargs,
trainSet,
args,
startEpoch=startEpoch,
truescores_tanh=args.truescores_tanh,
bias_tanh=args.bias_tanh,
bias_ampl=args.bias_ampl)
torch.save(
model.state_dict(),
"../models/{}/model{}_epoch{}".format(args.exp_id, args.ind_id,
epoch))
paramsToCsv(loss,
model,
args.exp_id,
args.ind_id,
epoch,
args.score_dis,
args.score_min,
args.score_max,
truescores_tanh=args.truescores_tanh,
bias_tanh=args.bias_tanh,
bias_ampl=args.bias_ampl)
# -*- coding: utf-8 -*-
from sklearn.neural_network import MLPClassifier
import numpy as np
# Load the cats and dogs
import load_data
X_train, y_train = load_data.loadData(_set='train',
batch_iter=0,
batch_size=100)
clf = MLPClassifier(solver='lbfgs',
activation='logistic',
alpha=1e-2,
hidden_layer_sizes=(1000, 1000),
random_state=1)
clf.fit(X_train.T, np.ravel(y_train.T))
out = clf.predict(X_train.T)
print(np.mean(out == np.ravel(y_train.T)) * 100)
X_test, y_test = load_data.loadData(32, _set='test')
out2 = clf.predict(X_test.T)
print(np.mean(out2 == np.ravel(y_train.T)) * 100)
def handle_request():
import keras.backend.tensorflow_backend as tb
tb._SYMBOLIC_SCOPE.value = True
imagefile = flask.request.files['image']
filename = werkzeug.utils.secure_filename(imagefile.filename)
print("\nReceived image File name : " + imagefile.filename)
imagefile.save("result" + filename)
print('\n')
parser = argparse.ArgumentParser()
parser.add_argument("-f",
"--fname",
type=str,
required=False,
default='models/trained_model.hdf5',
help="full path to model")
# parser.add_argument( "-i", "--integer", type=int, default=50)
parser.add_argument(
'-d',
'--disp_test_images',
type=str2bool,
default=False,
help="whether to disp test image names. default: False")
parser.add_argument('-s',
'--save_out_images',
type=str2bool,
default=True,
help="whether to ave out images. default: True")
args = parser.parse_args()
# Path to csv-file. File should contain X-ray filenames as first column,
# mask filenames as second column.
csv_path = dataset_bow_legs_dir + '/' + 'idx_test.csv'
# Path to the folder with images. Images will be read from path + path_from_csv
path = csv_path[:csv_path.rfind('/')] + '/'
df = pd.read_csv(csv_path)
if args.disp_test_images == True:
print('\n')
print(df)
print('\n')
# Load test data
im_shape = (512, 256)
X, y = loadData(df, path, im_shape, imagefile)
print('\n[*]loadData() finished\n')
n_test = X.shape[0]
inp_shape = X[0].shape
# Load model
if ".hdf5" not in args.fname:
list_of_files = glob.glob(args.fname + '/' + '*.hdf5') #
# print(list_of_files)
model_weights = list_of_files[0]
else:
model_weights = args.fname
# load json and create model
json_file = open('models/model_bk.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
print("model_from_json() finished ...")
# load weights into new model
loaded_model.load_weights(model_weights)
print("Loaded model from disk")
# evaluate loaded model on test data
UNet = loaded_model
model = loaded_model
model.compile(optimizer=RMSprop(lr=0.0001),
loss=bce_dice_loss,
metrics=[dice_coeff])
print("model compiled ")
# For inference standard keras ImageGenerator is used.
test_gen = ImageDataGenerator(rescale=1.)
ious = np.zeros(n_test)
dices = np.zeros(n_test)
mean_IoU = np.zeros(n_test)
i = 0
'''
for xx, yy in test_gen.flow(X, y, batch_size=1):
'''
num_imgs = X.shape[0]
for ii in range(num_imgs):
xx_ = X[ii, :, :, :]
yy_ = y[ii, :, :, :]
xx = xx_[None, ...]
yy = yy_[None, ...]
img = exposure.rescale_intensity(np.squeeze(xx), out_range=(0, 1))
pred = UNet.predict(xx)[..., 0].reshape(inp_shape[:2])
mask = yy[..., 0].reshape(inp_shape[:2])
# Binarize masks
gt = mask > 0.5
pr = pred > 0.5
pr_bin = img_as_ubyte(pr)
pr_openned = morphology.opening(pr_bin)
# Remove regions smaller than 2% of the image
pr = remove_small_regions(
pr, 0.005 * np.prod(im_shape)
) # pr = remove_small_regions(pr, 0.02 * np.prod(im_shape))
pr_out = img_as_ubyte(pr)
sub_dir_file_name = df.iloc[i][0]
file_name = sub_dir_file_name[9:]
sub_dir_name = sub_dir_file_name[:8]
if args.disp_test_images == True:
print('\n')
print('sub_dir_name={} file_name={}\n\n'.format(
sub_dir_name, file_name))
if args.save_out_images == True:
dir_img_mask = 'results/bow-legs_test/{}'.format(sub_dir_name)
if not os.path.exists(dir_img_mask):
os.makedirs(dir_img_mask)
img_name = '{}/{}'.format(dir_img_mask, file_name)
if args.disp_test_images == True:
print('img_name={}\n'.format(img_name))
cv2.imwrite(img_name, pr_openned)
file_name_no_ext = os.path.splitext(
file_name
)[0] # ('file', '.ext') --> os.path.splitext(file_name_no_ext)[0] ('file')
file_name_in = dataset_bow_legs_dir + '/' + sub_dir_name + '/' + file_name_no_ext + '_mask' + '.png' # dataset_bow-legs/mask_001/img_0001_mask.png
if args.disp_test_images == True:
print('file_name_in={}\n'.format(file_name_in))
if args.save_out_images == True:
file_name_out = 'results/bow-legs_test' + '/' + sub_dir_name + '/' + file_name_no_ext + '_mask_manual' + '.png' # results/bow-legs_test/mask_006/img_0006_mask_manual.png
img_exists = os.path.isfile(file_name_in)
if img_exists == False:
print('{} does not exists\n'.format(file_name_in))
sys.exit("exiting ...")
shutil.copy2(file_name_in, file_name_out)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
im_name_x_ray_original_size = data_bow_legs_dir + '/' + 'x-ray/' + file_name # data_bow-legs/x-ray/img_0001.png
im_name_x_ray_original_size_test = data_bow_legs_dir + '/' + 'x-ray_test/' + file_name # data_bow-legs/x-ray/img_0001.png
if args.disp_test_images == True:
print('im_name_x_ray_original_size = {}\n'.format(
im_name_x_ray_original_size_test))
im_x_ray_original_size = cv2.imread(im_name_x_ray_original_size_test,
cv2.IMREAD_GRAYSCALE)
if im_x_ray_original_size is None: ## Check for invalid input
print("Could not open or find the image: {}. ".format(
im_name_x_ray_original_size_test))
shutil.copy2(im_name_x_ray_original_size,
im_name_x_ray_original_size_test)
print('Made a copy from {}\n'.format(im_name_x_ray_original_size))
im_x_ray_original_size = cv2.imread(
im_name_x_ray_original_size_test, cv2.IMREAD_GRAYSCALE)
height, width = im_x_ray_original_size.shape[:
2] # height, width -- original image size
ratio = float(height) / width
new_shape = (4 * 256, int(4 * 256 * ratio))
im_x_ray_4x = cv2.resize(im_x_ray_original_size, new_shape)
dir_img_x_ray_4x = 'results/bow-legs_test_4x/{}'.format(sub_dir_name)
if not os.path.exists(dir_img_x_ray_4x):
os.makedirs(dir_img_x_ray_4x)
im_name_x_ray_4x = '{}/{}'.format(dir_img_x_ray_4x, file_name)
cv2.imwrite(im_name_x_ray_4x, im_x_ray_4x)
# mask
im_mask_original_size = cv2.imread(file_name_in, cv2.IMREAD_GRAYSCALE)
im_mask_4x = cv2.resize(im_mask_original_size, new_shape)
im_name_mask_4x = '{}/{}'.format(
dir_img_x_ray_4x, '/' + file_name_no_ext + '_mask_manual' + '.png')
cv2.imwrite(im_name_mask_4x, im_mask_4x)
# Unet output
pr_openned_4x = cv2.resize(pr_openned, new_shape)
im_name_pr_openned_4x = '{}/{}'.format(
dir_img_x_ray_4x, file_name_no_ext + '_mask_Unet' + '.png')
if args.disp_test_images == True:
print('im_name_pr_openned_4x={}\n'.format(im_name_pr_openned_4x))
cv2.imwrite(im_name_pr_openned_4x, pr_openned_4x)
gt_4x = cv2.resize(img_as_ubyte(gt), new_shape)
gt_4x = gt_4x > 0.5
pr_openned_4x = pr_openned_4x > 0.5
im_x_ray_4x_ = im_x_ray_4x / 255.0
if args.disp_test_images == True:
print('img.max()={} gt.max()={} pr.max()={}\n'.format(
im_x_ray_4x_.max(), gt_4x.max(), pr_openned_4x.max()))
im_masked_4x = masked(im_x_ray_4x, gt_4x, pr_openned_4x,
0.5) # img.max()=1.0 gt.max()=True pr.max()=True
if args.save_out_images == True:
dir_im_masked_4x = 'results/bow-legs_masked_4x'
if not os.path.exists(dir_im_masked_4x):
os.makedirs(dir_im_masked_4x)
im_name_masked_4x = '{}/{}'.format(dir_im_masked_4x, file_name)
im_masked_4x = img_as_ubyte(im_masked_4x)
io.imsave(im_name_masked_4x, im_masked_4x)
# convert numpy array to PIL Image
img = Image.fromarray(im_masked_4x.astype('uint8'))
# create file-object in memory
file_object = in_out.BytesIO()
# write PNG in file-object
img.save(file_object, 'PNG')
# move to beginning of file so `send_file()` it will read from start
file_object.seek(0)
return send_file(file_object, mimetype='image/PNG')
ious[i] = IoU(gt, pr)
dices[i] = Dice(gt, pr)
print('{} {:.4f} {:.4f}'.format(df.iloc[i][0], ious[i], dices[i]))
with open("results/bow-legs_results.txt", "a", newline="\r\n") as f:
print('{} {:.4f} {:.4f}'.format(df.iloc[i][0], ious[i], dices[i]),
file=f)
i += 1
if i == n_test:
break
print('Mean IoU:{:.4f} Mean Dice:{:.4f}'.format(ious.mean(), dices.mean()))
with open("results/bow-legs_results.txt", "a", newline="\r\n") as f:
print('Mean IoU:{:.4f} Mean Dice:{:.4f}'.format(
ious.mean(), dices.mean()),
file=f)
print('\n', file=f)
with open("results/bow-legs_IoU_Dice.txt", "a", newline="\r\n") as f:
print('Mean IoU:{:.4f} Mean Dice:{:.4f}'.format(
ious.mean(), dices.mean()),
file=f)
return "DONE"
rep1 = 0 # don't use the first 8 replicas. There is a better way to do this.
Tlist = Tlist[(rep1):]
nrep = len(Tlist)
filenames = [inprefix + "." + str(n + rep1 + 1) for n in range(nrep)]
# OK, now we have a list of temperatures and filenames for each replicas
print "replica list:"
for n in range(nrep):
print Tlist[n], filenames[n]
# data = load_data.loadData2dExp(filenames, ecolumn, qcolumn, nqbins, fskip=rskip, qcombine=qcombine, nebins=nebins, dEmin=dEmin)
# load data
columns = [ecolumn]
if len(qcombine) != 3:
columns.append(qcolumn)
datalist = load_data.loadData(filenames, columns, fskip=rskip, qcombine=qcombine)
# determine bin edges
binenergy1 = load_data.determineBinEdge(nebins, datalist, column=0, exponential_bins=use_exponential_bins)
binq1 = load_data.determineBinEdge(nqbins, datalist, column=1, exponential_bins=False)
# create histogram
visits2d = load_data.binData2d(binenergy1, binq1, datalist)
# visits2dnew = np.zeros( [nebins, nqbins, nrep] )
# for k in range(nrep): visits2dnew[:,:,k] = visits2d[k,:,:]
# visits2d = visits2dnew
wham = WHAM.wham2d(Tlist, binenergy1[:-1], binq1[:-1], visits2d)
wham.minimize()
def __init__(self):
self.sejongUnitDic = loadData("sejongUnitDic")
def convSpeed(exp_id, refModelIdList, refModelSeedList, varParamList):
''' Plot the distance between the vector found by models on subdatasets and the vector found by those same models on the full datasets
The distance is plot as a function of the annotator number.
Some parameters can be varying among models (e.g. the score distribution, the learning rate). One curve is draws for each combination of those parameters.
Args:
exp_id (str): the experience name
refModelIdList (list): the list of ids of models which are trained on a full dataset
refModelSeedList (list): the list of seeds of models which are trained on a full dataset
varParamList (list): the list of parameters which are varying among all the models in the experiment
'''
modelConfigPaths = sorted(glob.glob(
"../models/{}/model*.ini".format(exp_id)),
key=findNumbers)
modelIds = list(
map(lambda x: findNumbers(os.path.basename(x)), modelConfigPaths))
#Collect the scores of each reference model
refTrueScoresDict = {}
allBaseDict = {}
for j, refModelId in enumerate(refModelIdList):
refTrueScoresPath = sorted(glob.glob(
"../results/{}/model{}_epoch*_trueScores.csv".format(
exp_id, refModelId)),
key=findNumbers)[-1]
refTrueScores = np.genfromtxt(refTrueScoresPath, delimiter="\t")[:, 0]
datasetName = readConfFile(
"../models/{}/model{}.ini".format(exp_id, refModelId),
["dataset"])[0]
paramValue = ''
for varParam in varParamList:
paramValue += " " + lookInModelAndData(
"../models/{}/model{}.ini".format(exp_id, refModelId),
varParam,
typeVal=str)
#print(paramValue)
dataset, _ = load_data.loadData(datasetName)
#print(datasetName,paramValue)
baseLineRefDict = {}
for baselineType in baselinesTypes:
baseLineRefDict[baselineType], _ = computeBaselines(
dataset, baselineType)
#Get the color for each baseline
baseColMaps = cm.Blues(
np.linspace(0, 1, int(1.5 * len(baseLineRefDict.keys()))))
baseColMapsDict = {}
for i, key in enumerate(baseLineRefDict):
baseColMapsDict[key] = baseColMaps[-i - 1]
#Collect the true scores of this reference model
if not paramValue in refTrueScoresDict.keys():
refTrueScoresDict[paramValue] = {}
refTrueScoresDict[paramValue][refModelSeedList[j]] = refTrueScores
if not refModelSeedList[j] in allBaseDict.keys():
allBaseDict[refModelSeedList[j]] = baseLineRefDict
errorArray = np.zeros(len(modelConfigPaths))
nbAnnotArray = np.zeros(len(modelConfigPaths))
#Store the error of each baseline method
allErrorBaseDict = {}
#for key in baseLineRefDict:
# errorArrayDict[key] = np.zeros(len(modelConfigPaths))
paramValueList = []
colorInds = []
#Will contain a list of error for each value of the varying parameters
valuesDict = {}
baseDict = {}
for i, modelPath in enumerate(modelConfigPaths):
datasetName, modelId = readConfFile(modelPath, ["dataset", "ind_id"])
paramValue = ''
for varParam in varParamList:
paramValue += " " + lookInModelAndData(
modelPath, varParam, typeVal=str)
if not paramValue in paramValueList:
paramValueList.append(paramValue)
colorInds.append(paramValueList.index(paramValue))
nbAnnot, seed = readConfFile("../data/{}.ini".format(datasetName),
["nb_annot", "seed"])
trueScoresPath = sorted(glob.glob(
"../results/{}/model{}_epoch*_trueScores.csv".format(
exp_id, modelId)),
key=findNumbers)[-1]
trueScores = np.genfromtxt(trueScoresPath, delimiter="\t")[:, 0]
error = np.sqrt(
np.power(trueScores - refTrueScoresDict[paramValue][int(seed)],
2).sum() / len(refTrueScoresDict[paramValue][int(seed)]))
if not paramValue in valuesDict.keys():
valuesDict[paramValue] = [(error, nbAnnot)]
else:
valuesDict[paramValue].append((error, nbAnnot))
for baselineType in baselinesTypes:
if not baselineType in allErrorBaseDict.keys():
allErrorBaseDict[baselineType] = {}
if not nbAnnot in allErrorBaseDict[baselineType].keys():
allErrorBaseDict[baselineType][nbAnnot] = {}
if not int(seed) in allErrorBaseDict[baselineType][nbAnnot].keys():
#Computing the baseline error relative to the right baseline
error = baseLineError(datasetName, allBaseDict[int(seed)],
baselineType)
#print(baselineType,nbAnnot,int(seed))
allErrorBaseDict[baselineType][nbAnnot][int(seed)] = error
colors = cm.autumn(np.linspace(0, 1, len(paramValueList)))
markers = [
m for m, func in Line2D.markers.items()
if func != 'nothing' and m not in Line2D.filled_markers
]
paramValueList = list(map(lambda x: paramValueList[x], colorInds))
fig = plt.figure(figsize=(7, 5))
ax = fig.add_subplot(111)
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
plt.xlabel("Nb of annotators")
plt.ylabel("RMSE")
#Plot the models
for i, paramValue in enumerate(valuesDict.keys()):
nbAnnotAgreg, ymeans, yerr = agregate(valuesDict[paramValue])
plt.errorbar(np.array(nbAnnotAgreg, dtype=str).astype(int) + 0.1 * i,
ymeans,
yerr=yerr,
label=paramValue,
marker=markers[i])
#Plot the baselines
for baseline in allErrorBaseDict.keys():
means = np.zeros(len(allErrorBaseDict[baseline].keys()))
stds = np.zeros(len(allErrorBaseDict[baseline].keys()))
annotNbs = np.zeros(len(allErrorBaseDict[baseline].keys()))
for i, annotNb in enumerate(allErrorBaseDict[baseline].keys()):
valToAgr = np.array([
allErrorBaseDict[baseline][annotNb][seed]
for seed in allErrorBaseDict[baseline][annotNb].keys()
])
means[i], stds[i] = valToAgr.mean(), valToAgr.std()
annotNbs[i] = annotNb
#annotNbs = annotNbs.astype(int).astype(str)
means, stds, annotNbs = zip(
*sorted(zip(means, stds, annotNbs), key=lambda x: x[2]))
plt.errorbar(annotNbs,
means,
yerr=stds,
color=baseColMapsDict[baseline],
label=baseline)
fig.legend(loc='right')
plt.savefig("../vis/{}/convSpeed_{}.png".format(exp_id, exp_id))
def main(argv=None):
#Getting arguments from config file and command line
#Building the arg reader
argreader = ArgReader(argv)
argreader.parser.add_argument(
'--comp_gt',
type=str,
nargs="*",
metavar='PARAM',
help=
'To compare the parameters found with the ground truth parameters. Require a fake dataset. The argument should\
be the list of parameters varying across the different models in the experiment.'
)
argreader.parser.add_argument(
'--comp_gt_agr',
type=str,
nargs="*",
metavar='PARAM',
help=
'To compare the parameters found with the ground truth parameters. Require a fake dataset. The argument should\
be the list of parameters varying across the different models in the experiment. The accuracies of models having the same value for those parameters will be agregated.'
)
argreader.parser.add_argument(
'--comp_gt_evol',
type=str,
nargs="*",
metavar='PARAM',
help=
'To plot the evolution of the error across epochs. The argument should\
be the list of parameters varying across the different models in the experiment.'
)
argreader.parser.add_argument(
'--error_metric',
type=str,
metavar='ERROR',
default="rmse",
help=
'The error metric used in \'--comp_gt\' and \'--comp_gt_agr\'. Can be \'rmse\' or \'relative\'. Default is \'RMSE\'.'
)
argreader.parser.add_argument(
'--artif_data',
action='store_true',
help=
'To plot the real and empirical distribution of the parameters of a fake dataset. \
The fake dataset to plot is set by the --dataset argument'
)
argreader.parser.add_argument(
'--plot_param',
type=str,
nargs="*",
help=
'To plot the error of every parameters at each epoch for each model. The argument values are the index of the models to plot.'
)
argreader.parser.add_argument(
'--plot_dist',
type=int,
nargs="*",
help=
'To plot the distance travelled by each parameters and the negative log-likelihood at each epoch. \
The argument values are the index of the models to plot. The two last arguments are the epochs at which to start and finish the plot.'
)
argreader.parser.add_argument(
'--two_dim_repr',
type=str,
nargs="*",
help=
'To plot the t-sne visualisation of the values taken by the parameters during training. \
The first argument value is the id of the model to plot and the second is the start epoch. The following argument are the parameters to plot.'
)
argreader.parser.add_argument(
'--conv_speed',
type=str,
nargs='*',
metavar='ID',
help=
'To plot the error as a function of the number of annotator. The value is a list of parameters varying between \
the reference models.')
argreader.parser.add_argument(
'--plot_video_raw_scores',
type=str,
nargs='*',
metavar='ID',
help=
'To plot histograms of scores for some videos of a dataset. The value of this argument is the list of videos \
line index to plot. The dataset should also be indicated with the dataset argument'
)
argreader.parser.add_argument(
'--plot_range_pca',
type=float,
nargs=4,
metavar="RANGE",
help=
'The range to use when ploting the PCA. The values should be indicated in this order : xmin,xmax,ymin,ymax.'
)
argreader.parser.add_argument(
'--plot_range_dist',
type=float,
nargs=2,
metavar="RANGE",
help=
'The range to use when ploting the distance. The values should be indicated in this order : ymin,ymax.'
)
argreader.parser.add_argument(
'--labels',
type=str,
nargs='*',
metavar="RANGE",
help=
'The label names for the model, in the order where they will be appear in the plot.'
)
#Reading the comand line arg
argreader.getRemainingArgs()
#Getting the args from command line and config file
args = argreader.args
torch.manual_seed(args.seed)
random.seed(args.seed)
np.random.seed(args.seed)
#The folders where the experience file will be written
if not (os.path.exists("../vis/{}".format(args.exp_id))):
os.makedirs("../vis/{}".format(args.exp_id))
if not (os.path.exists("../results/{}".format(args.exp_id))):
os.makedirs("../results/{}".format(args.exp_id))
if not (os.path.exists("../models/{}".format(args.exp_id))):
os.makedirs("../models/{}".format(args.exp_id))
scoreMat, distorNbList = load_data.loadData(args.dataset)
if args.comp_gt:
compareWithGroundTruth(args.exp_id, args.comp_gt, args.error_metric)
if args.comp_gt_agr:
compareWithGroundTruth(args.exp_id, args.comp_gt_agr,
args.error_metric)
agregateCpWGroundTruth(
args.exp_id, "../results/{}/err_epoch-1.csv".format(args.exp_id))
agregateCpWGroundTruth(
args.exp_id,
"../results/{}/inclPerc_epoch-1.csv".format(args.exp_id))
if args.comp_gt_evol:
#Find an id of one model in the experiment
modelInd = findNumbers(
os.path.basename(
sorted(glob.glob("../models/{}/model*.ini".format(
args.exp_id)))[0]))
#The list of epoch number that have been logged
epochs = sorted(
list(
map(
lambda x: findNumbers(os.path.basename(x).split("_")[1]),
glob.glob("../results/{}/model{}_epoch*_{}.csv".format(
args.exp_id, modelInd, paramKeys[0])))))
epochs = np.array(epochs)
csvDict = {}
for epoch in epochs:
if not os.path.exists("../results/{}/err_epoch{}_agreg.csv".format(
args.exp_id, epoch)):
compareWithGroundTruth(args.exp_id,
args.comp_gt_evol,
args.error_metric,
epoch=epoch)
agregateCpWGroundTruth(
args.exp_id,
"../results/{}/err_epoch{}.csv".format(args.exp_id, epoch))
csvDict[epoch] = csvToDict(
"../results/{}/err_epoch{}_agreg.csv".format(
args.exp_id, epoch))
#Collect the values of the varying hyper parameters:
#These values identifie the models from each other
varHyperParamValues = csvDict[list(csvDict.keys())[0]].keys()
for param in paramKeys:
print("Ploting ", param)
plt.figure()
for i, hyperParam in enumerate(varHyperParamValues):
points = list(
map(lambda x: csvDict[x][hyperParam][param]['mean'],
epochs))
stds = list(
map(lambda x: csvDict[x][hyperParam][param]['std'],
epochs))
plt.errorbar(epochs + 100 * i,
points,
yerr=stds,
label="{}={}".format(args.comp_gt_evol,
hyperParam))
plt.legend()
plt.savefig("../vis/{}/err_evol_{}.png".format(args.exp_id, param))
if args.artif_data:
fakeDataDIstr(args)
if args.plot_param:
plotParam(args.dataset, args.exp_id, args.plot_param, args.labels)
if args.plot_dist:
plotDist(args.exp_id, args.plot_dist[0], args.plot_dist[1],
args.plot_dist[2], args.plot_range_dist)
if args.two_dim_repr:
twoDimRepr(args.exp_id, int(args.two_dim_repr[0]),
int(args.two_dim_repr[1]), args.two_dim_repr[2:],
args.plot_range_pca)
if args.conv_speed:
#Collect the configuration files
configFiles = glob.glob("../models/{}/model*.ini".format(args.exp_id))
def get_Seed_NbAnnot(x):
datasetName = readConfFile(x, ["dataset"])[0]
seed, nb_annot = readConfFile("../data/{}.ini".format(datasetName),
["seed", "nb_annot"])
return int(seed), int(nb_annot)
#Gets the ids, the seeds and the nb of annotators for every models in the experience
ids = list(map(lambda x: findNumbers(os.path.basename(x)),
configFiles))
seeds, nb_annots = zip(*list(map(get_Seed_NbAnnot, configFiles)))
ids_seeds_nbAnnots = zip(ids, seeds, nb_annots)
#Find the ids and seeds of models which are trained on the full dataset
argmaxs = np.argwhere(nb_annots == np.amax(nb_annots)).flatten()
ids = np.array(ids)[argmaxs]
seeds = np.array(seeds)[argmaxs]
#Sort with the ids value to make debut easier
ids, seeds = zip(*sorted(zip(ids, seeds), key=lambda x: x[0]))
convSpeed(args.exp_id, ids, seeds, args.conv_speed)
if args.plot_video_raw_scores:
plotVideoRawScores(args.dataset, args.plot_video_raw_scores,
args.score_min, args.score_max)
def __init__(self):
self.junction_info = loadData("junction_info")
def predicateImage(image, image_path, mask, mask_path, filename_result,
dir_result):
# Load test data
im_shape = (512, 256)
csv_path = dataset_bow_legs_dir + '/' + 'idx_test.csv'
df = pd.read_csv(csv_path)
# Images sent by client
X, y = loadData(image, mask, im_shape)
# Images saved on the server
# X, y = loadDataOrig(df, path, im_shape)
print('\n[*]loadData() finished\n')
n_test = X.shape[0]
inp_shape = X[0].shape
# Load model
model_weights = "models/trained_model.hdf5"
print('model_weights ' + model_weights)
# load json and create model
json_file = open('models/model_bk.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
print("model_from_json() finished ...")
# load weights into new model
loaded_model.load_weights(model_weights)
print("Loaded model from disk")
# evaluate loaded model on test data
UNet = loaded_model
model = loaded_model
model.compile(optimizer=RMSprop(lr=0.0001),
loss=bce_dice_loss,
metrics=[dice_coeff])
print("model compiled ")
ious = np.zeros(n_test)
dices = np.zeros(n_test)
i = 0
'''
for xx, yy in test_gen.flow(X, y, batch_size=1):
'''
num_imgs = X.shape[0]
for ii in range(num_imgs):
xx_ = X[ii, :, :, :]
yy_ = y[ii, :, :, :]
xx = xx_[None, ...]
yy = yy_[None, ...]
pred = UNet.predict(xx)[..., 0].reshape(inp_shape[:2])
mask = yy[..., 0].reshape(inp_shape[:2])
# Binarize masks
gt = mask > 0.5
pr = pred > 0.5
pr_bin = img_as_ubyte(pr)
pr_openned = morphology.opening(pr_bin)
# Remove regions smaller than 2% of the image
pr = remove_small_regions(pr, 0.005 * np.prod(im_shape))
sub_dir_file_name = df.iloc[i][0]
file_name = sub_dir_file_name[9:]
sub_dir_name = sub_dir_file_name[:8]
file_name_no_ext = os.path.splitext(file_name)[0]
file_name_in = mask_path
im_name_x_ray_original_size = image_path
im_name_x_ray_original_size_test = image_path
im_x_ray_original_size = cv2.imread(im_name_x_ray_original_size_test,
cv2.IMREAD_GRAYSCALE)
if im_x_ray_original_size is None: ## Check for invalid input
print("Could not open or find the image: {}. ".format(
im_name_x_ray_original_size_test))
shutil.copy2(im_name_x_ray_original_size,
im_name_x_ray_original_size_test)
print('Made a copy from {}\n'.format(im_name_x_ray_original_size))
im_x_ray_original_size = cv2.imread(
im_name_x_ray_original_size_test, cv2.IMREAD_GRAYSCALE)
height, width = im_x_ray_original_size.shape[:
2] # height, width -- original image size
ratio = float(height) / width
new_shape = (4 * 256, int(4 * 256 * ratio))
im_x_ray_4x = cv2.resize(im_x_ray_original_size, new_shape)
dir_img_x_ray_4x = 'results/bow-legs_test_4x/{}'.format(sub_dir_name)
if not os.path.exists(dir_img_x_ray_4x):
os.makedirs(dir_img_x_ray_4x)
im_name_x_ray_4x = '{}/{}'.format(dir_img_x_ray_4x, file_name)
cv2.imwrite(im_name_x_ray_4x, im_x_ray_4x)
# mask
im_mask_original_size = cv2.imread(file_name_in, cv2.IMREAD_GRAYSCALE)
im_mask_4x = cv2.resize(im_mask_original_size, new_shape)
im_name_mask_4x = '{}/{}'.format(
dir_img_x_ray_4x, '/' + file_name_no_ext + '_mask_manual' + '.png')
cv2.imwrite(im_name_mask_4x, im_mask_4x)
# Unet output
pr_openned_4x = cv2.resize(pr_openned, new_shape)
cv2.imwrite(filename_result, pr_openned_4x)
ious[i] = IoU(gt, pr)
dices[i] = Dice(gt, pr)
print('{} {:.4f} {:.4f}'.format(df.iloc[i][0], ious[i], dices[i]))
with open("results/bow-legs_results.txt", "a", newline="\r\n") as f:
print('{} {:.4f} {:.4f}'.format(df.iloc[i][0], ious[i], dices[i]),
file=f)
i += 1
if i == n_test:
break
print('Mean IoU:{:.4f} Mean Dice:{:.4f}'.format(ious.mean(), dices.mean()))
with open("results/bow-legs_results.txt", "a", newline="\r\n") as f:
print('Mean IoU:{:.4f} Mean Dice:{:.4f}'.format(
ious.mean(), dices.mean()),
file=f)
print('\n', file=f)
with open("results/bow-legs_IoU_Dice.txt", "a", newline="\r\n") as f:
print('Mean IoU:{:.4f} Mean Dice:{:.4f}'.format(
ious.mean(), dices.mean()),
file=f)
sortTime = self.dataset[self.timeFeature].sort_values()
timesatmp = sortTime.unique() # 时间戳去重，防止多个序列交织在一起
minTime = str(timesatmp[0])
maxTime = str(timesatmp[-1])
interval = int(timesatmp[1] - timesatmp[0]) / 1e9
basicInfo = {
"row_num": rowNum,
"col_num": colNum,
"time_feature": self.timeFeature,
"digital_feature_num": len(self.digitalFeatures),
"category_feature_num": len(self.categroyFeatures),
"max_datetime": maxTime,
"min_datetime": minTime,
"interval": interval
}
return basicInfo
if __name__ == '__main__':
dataset = loadData('data/deepAD_data_summary_test_data1.csv')
summary = TableSummary(dataset)
basicInfo = summary.getBasicInformation()
print(basicInfo)
recommend = summary.getColumnRecommend()
print(recommend)
nrep = len(Tlist)
filenames=[inprefix+'.'+str(n+rep1+1) for n in range(nrep)]
#OK, now we have a list of temperatures and filenames for each replicas
print "replica list:"
for n in range(nrep):
print Tlist[n], filenames[n]
#data = load_data.loadData2dExp(filenames, ecolumn, qcolumn, nqbins, fskip=rskip, qcombine=qcombine, nebins=nebins, dEmin=dEmin)
#load data
columns = [ecolumn]
if len(qcombine) != 3: columns.append(qcolumn)
datalist = load_data.loadData(filenames, columns, fskip=rskip, qcombine=qcombine )
#determine bin edges
binenergy1 = load_data.determineBinEdge(nebins, datalist, column=0, exponential_bins=use_exponential_bins)
binq1 = load_data.determineBinEdge(nqbins, datalist, column=1, exponential_bins=False)
#create histogram
visits2d = load_data.binData2d(binenergy1, binq1, datalist)
#visits2dnew = np.zeros( [nebins, nqbins, nrep] )
#for k in range(nrep): visits2dnew[:,:,k] = visits2d[k,:,:]
#visits2d = visits2dnew
wham = WHAM.wham2d(Tlist, binenergy1[:-1], binq1[:-1], visits2d)
wham.minimize()
from __future__ import absolute_import, division, print_function, unicode_literals
import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
import load_data
train_labels, train_images = load_data.loadData("bin/labels.csv", "bin/images")
print("DATA")
# Ustawienie layerów modelu
model = keras.Sequential([
keras.layers.Flatten(input_shape=(64, 64)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
# Ustawienie przed kompilowaniem
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
print("GO COMPILE!")
# Kompilacja modelu
train_labels = np.argmax(train_labels, axis=1)
model.fit(
