def reconstructFaceFromModel(path_to_input_image, model, save_path = None):
im = Image.open(path_to_input_image)
im = im.convert("L")
im = im.resize(getDimensionsOfModel(model), Image.ANTIALIAS)
img = np.asarray(im, dtype=np.uint8)
ex = model.feature.extract(img)
re = model.feature.reconstruct(ex)
re = re.reshape(getDimensionsOfModel(model))
e = minmax_normalize(re,0,255, dtype=np.uint8)
img = Image.fromarray(e)
if save_path == None:
img.show()
else:
img.save(save_path)
def showModel(model, colormap=None):
"""
Opens Fisherfaces of a given model.
"""
print "\n[+] Creating Fisherfaces for model:", model
dimensions = getDimensionsOfModel(model)
E = []
print ""
for i in xrange(min(model.feature.eigenvectors.shape[1], 20)):
print model.feature.eigenvectors[:,i]
e = model.feature.eigenvectors[:,i].reshape((dimensions))
e = minmax_normalize(e,0,255, dtype=np.uint8)
if colormap is None:
img = Image.fromarray(e)
else:
img = Image.fromarray(np.uint8(colormap(e)*255))
print "\t[o] Opening Fisherfaces [" + str(i) + "]"
img.show()
def train(train_path):
# Now read in the image data. This must be a valid path!
[X, y, class_names] = read_images(train_path)
print X, y, class_names
# 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
model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
model.compute(X, y)
# 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()
save_model('model.pkl', model, class_names)
return [model, class_names]
def model_viz(model, output_path = None,colormap=None):
"""
Opens vis of a given model.
"""
print "\n[+] Creating viz for model:", model
dimensions = getDimensionsOfModel(model)
E = []
print ""
for i in xrange(min(model.feature.eigenvectors.shape[1], 20)):
print model.feature.eigenvectors[:,i]
e = model.feature.eigenvectors[:,i].reshape((dimensions))
e = minmax_normalize(e,0,255, dtype=np.uint8)
if colormap is None:
img = Image.fromarray(e)
else:
img = Image.fromarray(np.uint8(colormap(e)*255))
print "\t[o] Opening viz [" + str(i) + "]"
if output_path is None:
img.show()
else:
img.save(os.path.join(output_path, "frame_" + str(i) + ".tif"))
def train(train_path):
# Now read in the image data. This must be a valid path!
[X,y,class_names] = read_images(train_path)
print X,y,class_names
# 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
model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
model.compute(X, y)
# 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()
save_model('model.pkl', model, class_names)
return [model,class_names]
[X,y] = read_images(sys.argv[1])
# 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
model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
model.compute(X, y)
# 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:
print cv
logger = logging.getLogger("facerec")
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
# Define the Fisherfaces as Feature Extraction method:
feature = PCA()
# Define a 1-NN classifier with Euclidean Distance:
classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1)
# Define the model as the combination
model = PredictableModel(feature=feature, classifier=classifier)
# Compute the Fisherfaces on the given data (in X) and labels (in y):
model.compute(X, y)
# 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()
