def run_rec():
# This is where we write the images, if an output_dir is given
# in command line:
out_dir = None
# Now read in the image data. This must be a valid path!
[X,y] = read_images('images')
# Then set up a handler for logging:
handler = logging.StreamHandler(sys.stdout)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
# Add handler to facerec modules, so we see what's going on inside:
logger = logging.getLogger("facerec")
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
# Define the Fisherfaces as Feature Extraction method:
feature = Fisherfaces()
# Define a 1-NN classifier with Euclidean Distance:
classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1)
# Define the model as the combination
my_model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
my_model.compute(X, y)
# We then save the model, which uses Pythons pickle module:
save_model('model.pkl', my_model)
model = load_model('model.pkl')
# Then turn the first (at most) 16 eigenvectors into grayscale
# images (note: eigenvectors are stored by column!)
#E = []
#for i in xrange(min(model.feature.eigenvectors.shape[1], 16)):
# e = model.feature.eigenvectors[:,i].reshape(X[0].shape)
# E.append(minmax_normalize(e,0,255, dtype=np.uint8))
# Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf"
#subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png")
# Perform a 10-fold cross validation
cv = KFoldCrossValidation(model, k=10)
cv.validate(X, y)
# And print the result:
cv.print_results()
im = Image.open('search.png')
im = im.convert("L")
predicted_label = model.predict(im)[0]
print(predicted_label)
return predicted_label
def run_rec():
# This is where we write the images, if an output_dir is given
# in command line:
out_dir = None
# Now read in the image data. This must be a valid path!
[X, y] = read_images('images')
# Then set up a handler for logging:
handler = logging.StreamHandler(sys.stdout)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
# Add handler to facerec modules, so we see what's going on inside:
logger = logging.getLogger("facerec")
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
# Define the Fisherfaces as Feature Extraction method:
feature = Fisherfaces()
# Define a 1-NN classifier with Euclidean Distance:
classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1)
# Define the model as the combination
my_model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
my_model.compute(X, y)
# We then save the model, which uses Pythons pickle module:
save_model('model.pkl', my_model)
model = load_model('model.pkl')
# Then turn the first (at most) 16 eigenvectors into grayscale
# images (note: eigenvectors are stored by column!)
#E = []
#for i in xrange(min(model.feature.eigenvectors.shape[1], 16)):
# e = model.feature.eigenvectors[:,i].reshape(X[0].shape)
# E.append(minmax_normalize(e,0,255, dtype=np.uint8))
# Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf"
#subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png")
# Perform a 10-fold cross validation
cv = KFoldCrossValidation(model, k=10)
cv.validate(X, y)
# And print the result:
cv.print_results()
im = Image.open('search.png')
im = im.convert("L")
predicted_label = model.predict(im)[0]
print(predicted_label)
return predicted_label
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
# Define the Fisherfaces as Feature Extraction method:
feature = SpatialHistogram()
#feature = Fisherfaces()
# Define a 1-NN classifier with Euclidean Distance:
classifier = NearestNeighbor(dist_metric=NormalizedCorrelation(), k=1)
#classifier = SVM()
# Define the model as the combination
my_model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
my_model.compute(X, y)
# We then save the model, which uses Pythons pickle module:
save_model('modelTry.pkl', my_model)
model = load_model('modelTry.pkl')
# Then turn the first (at most) 16 eigenvectors into grayscale
# images (note: eigenvectors are stored by column!)
E = []
#for i in range(min(model.feature.eigenvectors.shape[1], 16)):
# e = model.feature.eigenvectors[:,i].reshape(X[0].shape)
# E.append(minmax_normalize(e,0,255, dtype=np.uint8))
# Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf"
subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png")
# Perform a 10-fold cross validation
cv = KFoldCrossValidation(model, k=10)
cv.validate(X, y)
# And print the result:
cv.print_results()
import numpy as np
from tools import load_data
from models import FrequencyModel, TfIdfModel
from validation import KFoldCrossValidation, MAPn
# load data
path_to_data = "data/"
training, training_info, test, test_info = load_data(path_to_data)
# create model
nb_recipients_to_predict = 10
model = FrequencyModel(nb_recipients_to_predict=nb_recipients_to_predict)
# validation
n_split = 5
cross_validation = KFoldCrossValidation(n_split)
scores = []
for fold_nb, (training_fold, training_info_fold, test_fold, test_info_fold,
y_test_fold) in enumerate(
cross_validation.split(training, training_info)):
print("\nFold #%d..." % fold_nb)
# fit model
model.fit(training_fold, training_info_fold)
# predict
predictions_per_sender = model.predict(test_fold, test_info_fold)
# compute MAP@n
score = MAPn(predictions_per_sender, y_test_fold, nb_recipients_to_predict)
# Add handler to facerec modules, so we see what's going on inside:
logger = logging.getLogger("facerec")
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
# Define the Fisherfaces as Feature Extraction method:
feature = Fisherfaces()
# Define a 1-NN classifier with Euclidean Distance:
classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1)
# Define the model as the combination
my_model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
my_model.compute(X, y)
# We then save the model, which uses Pythons pickle module:
save_model("model.pkl", my_model)
model = load_model("model.pkl")
# Then turn the first (at most) 16 eigenvectors into grayscale
# images (note: eigenvectors are stored by column!)
E = []
for i in xrange(min(model.feature.eigenvectors.shape[1], 16)):
e = model.feature.eigenvectors[:, i].reshape(X[0].shape)
E.append(minmax_normalize(e, 0, 255, dtype=np.uint8))
# Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf"
subplot(
title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png"
)
# Perform a 10-fold cross validation
cv = KFoldCrossValidation(model, k=10)
cv.validate(X, y)
# And print the result:
cv.print_results()