def main():
parser = argparse.ArgumentParser()
parser.add_argument("--out", default=".")
parser.add_argument("--modes", action='append', required=True)
parser.add_argument("--sets", action='append', required=True)
parser.add_argument("--normalize", default=True)
parser.add_argument("model_path", help="Pylearn2 model")
options = parser.parse_args()
from extract_features import get_features
from emotiw.bouthilx.datasets import FeaturesDataset
out = options.out
d_modes = options.modes
sets = options.sets
model_path = options.model_path
normalize = options.normalize
targets = os.path.join(base_path, "afew2_train_targets.npy")
from theano import config
from theano import function
for s in sets:
features = [
os.path.join(base_path, modes[mode], base_name % s)
for mode in d_modes
]
fd = FeaturesDataset(features, targets, "", normalize, shuffle=False)
data = np.cast[config.floatX](fd.get_design_matrix())
preds = get_features(model_path, data, layer_idx=None)
np.save(os.path.join(out, "_".join(d_modes) + "_" + s), preds)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--out",default=".")
parser.add_argument("--modes",action='append',required=True)
parser.add_argument("--sets",action='append',required=True)
parser.add_argument("--normalize",default=True)
parser.add_argument("model_path",help="Pylearn2 model")
options = parser.parse_args()
from extract_features import get_features
from emotiw.bouthilx.datasets import FeaturesDataset
out = options.out
d_modes = options.modes
sets = options.sets
model_path = options.model_path
normalize = options.normalize
targets = os.path.join(base_path,"afew2_train_targets.npy")
from theano import config
from theano import function
for s in sets:
features = [os.path.join(base_path,modes[mode],base_name % s) for mode in d_modes]
fd = FeaturesDataset(features,targets,"",normalize,shuffle=False)
data = np.cast[config.floatX](fd.get_design_matrix())
preds = get_features(model_path,data,layer_idx=None)
np.save(os.path.join(out,"_".join(d_modes)+"_"+s),preds)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--out",required=True)
parser.add_argument("--features",required=True,action='append')
parser.add_argument("--targets")
# parser.add_argument("--base_path",default="")
parser.add_argument("--normalize",default=True)
options = parser.parse_args()
out = options.out
features = options.features
targets = options.targets
# base_path = options.base_path
normalize = "True"==options.normalize
print normalize,type(normalize)
if targets is None:
targets = "/data/afew/ModelPredictionsToCombine/afew2_train_targets.npy"
fd = FeaturesDataset(features,targets,"",
normalize,shuffle=False)
data = fd.get_design_matrix()
print data.shape
np.save(out,data)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--out", required=True)
parser.add_argument("--features", required=True, action='append')
parser.add_argument("--targets")
# parser.add_argument("--base_path",default="")
parser.add_argument("--normalize", default=True)
options = parser.parse_args()
out = options.out
features = options.features
targets = options.targets
# base_path = options.base_path
normalize = "True" == options.normalize
print normalize, type(normalize)
if targets is None:
targets = "/data/afew/ModelPredictionsToCombine/afew2_train_targets.npy"
fd = FeaturesDataset(features, targets, "", normalize, shuffle=False)
data = fd.get_design_matrix()
print data.shape
np.save(out, data)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--out", default=".")
parser.add_argument("--normalize", default=True)
parser.add_argument("--features", action="append")
parser.add_argument("--predictions", action="append")
options = parser.parse_args()
from emotiw.bouthilx.datasets import FeaturesDataset
out = options.out
normalize = "True" == options.normalize
feats = options.features
preds = options.predictions
if feats is None:
feats = []
if preds is None:
preds = []
print normalize
# if feats:
# base_name = "%s_features.npy"
# else:
# base_name = "learned_on_train_predict_on_%s_scores.npy"
if len(feats + preds) > 1:
feats_names = "_".join(feats) + "_features" if len(feats) else ""
preds_names = "_".join(preds) + "_predicts" if len(preds) else ""
name = feats_names + "_" + preds_names
if not normalize:
name = "not_norm_" + name
# name = "weighted"+name
matfile = os.path.join(base_path, name)
csvfile = os.path.join(base_path, name + "_%s.csv")
elif len(feats):
name = os.path.splitext(base_name)[0] + "features.mat"
if not normalize:
name = "not_norm_" + name
matfile = os.path.join(base_path, shortcut.get(feats[0], feats[0]), name).replace("%s", "")
csvfile = os.path.join(base_path, name + "_features_%s.csv")
elif len(preds):
name = os.path.splitext(base_name)[0] + "predictions.mat"
if not normalize:
name = "not_norm_" + name
matfile = os.path.join(base_path, shortcut.get(preds[0], preds[0]), name).replace("%s", "")
csvfile = os.path.join(base_path, name + "_predictions_%s.csv")
print matfile
d = {}
for s in sets:
print s
filelist = open(os.path.join(base_path, "afew2_%s_filelist.txt") % s)
ids = [int(i.strip().split(" ")[-1].split("/")[-1]) for i in filelist.readlines()]
targets = os.path.join(base_path, "afew2_%s_targets.npy") % s
if s == "test":
targets = targets.replace("test", "train")
tmpcsvfile = open(csvfile % s, "w")
features = [os.path.join(base_path, shortcut.get(mode, mode), "%s_features.npy" % s) for mode in feats]
predictions = [
os.path.join(base_path, shortcut.get(mode, mode), "learned_on_train_predict_on_%s_scores.npy" % s)
for mode in preds
]
fd = FeaturesDataset(features + predictions, targets, "", normalize, shuffle=False)
# precisions = class_precision(predictions)
data = fd.get_design_matrix() # *precisions.flatten()
save(ids, data, tmpcsvfile, fd.get_targets() if s != "test" else None)
if s != "_test":
d[s + "_labels"] = fd.get_targets().argmax(1)
d[s + "_ids"] = ids
d[s + "_features"] = data
# np.save(os.path.join(base_path,"take_best_%s.npy" %s), data)
scipy.io.savemat(matfile, mdict=d)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--out",
help="The directory where to extract predictions")
parser.add_argument("--data",
action='append',
required=True,
help="Data path (.npy)")
parser.add_argument("--targets",
action='append',
help="Target path (.npy)")
parser.add_argument("--normalize", default=False)
parser.add_argument("model_paths", nargs='+', help="Pylearn2 models")
options = parser.parse_args()
out = options.out
data_paths = options.data
model_paths = options.model_paths
normalize = "True" == options.normalize
print model_paths
print data_paths
datas = [(data_path, np.load(data_path)) for data_path in data_paths]
from theano import config
from theano import function
from pylearn2.utils import serial
from emotiw.bouthilx.datasets import FeaturesDataset
print np.mean(datas[0][1] == FeaturesDataset(
features_paths=[
"audio/test26_best_audio_mlp_valid_feats_features.npy",
"pascal/afew2_valid_rmananinpic_emmanuel_features.npy"
],
targets_path="pascal/afew2_valid_rmananinpic_emmanuel_targets.npy",
base_path="/data/afew",
normalize=True,
shuffle=False).get_design_matrix())
predictions = []
if len(datas) < len(model_paths) and len(datas) == 1:
l = []
for model_path in model_paths:
l.append((model_path, datas[0]))
iterator = l
else:
iterator = zip(model_paths, datas)
for model_path, (data_path, data) in iterator:
model = serial.load(model_path)
batch_size = model.get_test_batch_size()
X = model.get_input_space().make_batch_theano()
f = function([X], model.fprop(X))
if normalize:
# set 0s to mean
tmp = data[:]
tmp -= tmp.min(0)
tmp /= (tmp == 0) + tmp.max(0)
# range is [-1,1]
tmp = tmp * 2.0 - 1.0
tmp = (data.min(0) !=
data.max(0)) * tmp # set empty dimensions to 0
data = tmp
# print data
y_hat = utils.apply(f, data, batch_size)
# print y_hat.sum(1)
if options.targets is not None:
targets = np.load(options.targets[0])
# print targets
# print y_hat.argmax(1)
# j = 0
# for i, target in enumerate(targets):
# j += classes[int(target)]==classes[y_hat[i].argmax()]
# print classes[int(target)], classes[y_hat[i].argmax()], j, len(targets)
#
# print np.mean(y_hat.argmax(1)==targets)
predictions.append(y_hat)
mean = np.array(predictions).mean(0)
if options.targets is not None:
targets = np.load(options.targets[0])
# print mean.argmax(1)
# print targets
print np.mean(mean.argmax(1) == targets)
j = 0
# for i, target in enumerate(targets):
# j += classes[int(target)]==classes[mean[i].argmax()]
# print classes[int(target)], classes[mean[i].argmax()], j, len(targets)
if options.out is not None:
np.save(options.out, mean)
