def haar_feature_fit(pos_dir, neg_dir):
para = [[]]
y = []
classi = ensemble.AdaBoostClassifier(
tree.DecisionTreeClassifier(max_depth=2),
algorithm="SAMME.R",
n_estimators=50,
learning_rate=1.2)
for root, director, files in os.walk(pos_dir):
print(files)
i = 0
for file in files:
i += 1
if (i > 50):
break
print(file)
image = io.imread(pos_dir + file)
img_gray = color.rgb2gray(image)
img_union = transform.resize(img_gray, (190, 100))
coord, ft = haar_like_feature_coord(100, 60, feature_types[0])
feature = haar_like_feature(img_union, 0, 0, 100, 60, ft, coord)
para = np.array([feature])
#y = np.array(1)
classi.fit(para, [0])
for root, director, files in os.walk(neg_dir):
print(files)
i = 0
for file in files:
i += 1
if (i > 50):
break
print(file)
image = io.imread(neg_dir + file)
img_gray = color.rgb2gray(image)
coord, ft = haar_like_feature_coord(100, 60, feature_types[0])
feature = haar_like_feature(img_gray, 0, 0, 100, 60, ft, coord)
para = np.array([feature])
#y = np.array(0)
classi.fit(para, [0])
joblib.dump(classi, "D:/dataset/haarmodel.m")
image = io.imread(
"D:/dataset/ccpd_select1/242&422_86&414_80&364_235&372-0_0_16_32_11_32_26.jpg"
)
img_gray = color.rgb2gray(image)
coord, ft = haar_like_feature_coord(100, 60, feature_types[0])
feature = haar_like_feature(img_gray, 0, 0, 100, 60, ft, coord)
test = np.array([feature])
res = classi.predict(test)
print(res)
def find_best_haar_features(self, sample_patches, labels):
feature_types = ['type-2-x', 'type-2-y']
feature_coord, feature_type = haar_like_feature_coord(self.resized,
self.resized,
feature_types)
data = []
for i in range(sample_patches.shape[0]):
features = extract_feature_image(sample_patches[i], feature_types,
feature_coord=None)
data.append(features)
data = np.array(data)
max_feat = min(100, data.shape[1])
clf = RandomForestClassifier(n_estimators=1000, max_depth=None,
max_features=max_feat, n_jobs=-1,
random_state=13)
clf.fit(data, labels)
idx_sorted = np.argsort(clf.feature_importances_)[::-1]
cdf_feature_importances = np.cumsum(
clf.feature_importances_[idx_sorted[::-1]])
cdf_feature_importances /= np.max(cdf_feature_importances)
significant_feature = np.count_nonzero(
cdf_feature_importances > self.threshold_haar)
selected_feature_coord = feature_coord[idx_sorted[:significant_feature]]
selected_feature_type = feature_type[idx_sorted[:significant_feature]]
return selected_feature_coord, selected_feature_type
def compute_haar_features(feature_types, images):
# code based on https://scikit-image.org/docs/dev/auto_examples/
# applications/plot_haar_extraction_selection_classification.html
# random seed for repeatability
np.random.seed(4)
# Build a computation graph using Dask. This allows the use of multiple
# CPU cores later during the actual computation
print("\n building computational graph\n")
X = delayed(extract_feature_image(img, feature_types) for img in images)
# Compute the result
t_start = time()
print("\ncomputing features\n")
X = np.array(X.compute(scheduler='threads'))
time_full_feature_comp = time() - t_start
print("\ncomputation took: ", time_full_feature_comp, "\n")
# Extract all possible feature coords and feature types
feature_coord, feature_type = haar_like_feature_coord(width=images.shape[2], height=images.shape[1],
feature_type=feature_types)
return X, feature_coord, feature_type
def test_haar_like_feature_coord(feature_type, height, width, expected_coord):
feat_coord, feat_type = haar_like_feature_coord(width, height,
feature_type)
# convert the output to a full numpy array just for comparison
feat_coord = np.array([hf for hf in feat_coord])
assert_array_equal(feat_coord, expected_coord)
assert np.all(feat_type == feature_type)
def sample():
images = [
np.zeros((2, 2)),
np.zeros((2, 2)),
np.zeros((3, 3)),
np.zeros((3, 3)),
np.zeros((2, 2))
]
feature_types = ['type-2-x', 'type-2-y', 'type-3-x', 'type-3-y', 'type-4']
fig, axs = plt.subplots(3, 2)
for ax, img, feat_t in zip(np.ravel(axs), images, feature_types):
coord, _ = haar_like_feature_coord(img.shape[0], img.shape[1], feat_t)
haar_feature = draw_haar_like_feature(img,
0,
0,
img.shape[0],
img.shape[1],
coord,
max_n_features=1,
random_state=0)
ax.imshow(haar_feature)
ax.set_title(feat_t)
ax.set_xticks([])
ax.set_yticks([])
fig.suptitle('The different Haar-like feature descriptors')
plt.axis('off')
plt.show()
def get_haar_coord():
feature_types = ['type-2-x', 'type-2-y', 'type-3-x', 'type-3-y', 'type-4']
# Extract all possible features
list_feature_coords, list_feature_types = \
haar_like_feature_coord(width=INPUT_WIDTH, height=INPUT_HEIGHT,
feature_type=feature_types)
return list_feature_coords, list_feature_types
def test_haar_like_feature_error():
img = np.ones((5, 5), dtype=np.float32)
img_ii = integral_image(img)
feature_type = 'unknown_type'
with pytest.raises(ValueError):
haar_like_feature(img_ii, 0, 0, 5, 5, feature_type=feature_type)
haar_like_feature_coord(5, 5, feature_type=feature_type)
draw_haar_like_feature(img, 0, 0, 5, 5, feature_type=feature_type)
feat_coord, feat_type = haar_like_feature_coord(5, 5, 'type-2-x')
with pytest.raises(ValueError):
haar_like_feature(img_ii,
0,
0,
5,
5,
feature_type=feat_type[:3],
feature_coord=feat_coord)
def test_draw_haar_like_feature(max_n_features, nnz_values):
img = np.zeros((5, 5), dtype=np.float32)
coord, _ = haar_like_feature_coord(5, 5, 'type-4')
image = draw_haar_like_feature(img,
0,
0,
5,
5,
coord,
max_n_features=max_n_features,
random_state=0)
assert image.shape == (5, 5, 3)
assert np.count_nonzero(image) == nnz_values
def test_haar_like_feature_precomputed(feature_type):
img = np.ones((5, 5), dtype=np.int8)
img_ii = integral_image(img)
if isinstance(feature_type, list):
# shuffle the index of the feature to be sure that we are output
# the features in the same order
shuffle(feature_type)
feat_coord, feat_type = zip(
*
[haar_like_feature_coord(5, 5, feat_t) for feat_t in feature_type])
feat_coord = np.concatenate(feat_coord)
feat_type = np.concatenate(feat_type)
else:
feat_coord, feat_type = haar_like_feature_coord(5, 5, feature_type)
haar_feature_precomputed = haar_like_feature(img_ii,
0,
0,
5,
5,
feature_type=feat_type,
feature_coord=feat_coord)
haar_feature = haar_like_feature(img_ii, 0, 0, 5, 5, feature_type)
assert_array_equal(haar_feature_precomputed, haar_feature)
def visualize_haar_f_kernel(img,f_type):
coord,_ = haar_like_feature_coord(img.shape[0], img.shape[1],f_type)
coord_array = np.asarray(coord)
# pt(x,y) image(y,x)
point_coord = [[(c2[1],c2[0]) for c1 in c for c2 in c1] for c in coord_array]
for p in point_coord:
img_v = np.ones((img.shape[0],img.shape[1])).astype('uint8')
img_v = img_v* 127
img_v = cv2.rectangle(img_v,p[0],p[1],255,-1)
img_v = cv2.rectangle(img_v,p[2],p[3],0,-1)
cv2.namedWindow('Image',cv2.WINDOW_NORMAL)
cv2.imshow('Image',img_v)
cv2.waitKey(500)
cv2.destroyAllWindows()
def display(self, significant_features, image):
""" Plot the most significant haar-like features on top of an image """
feature_coord, _ = haar_like_feature_coord(width=32, height=64)
fig, axes = plt.subplots(3, 2)
for idx, ax in enumerate(axes.ravel()):
image = draw_haar_like_feature(
image, 0, 0, 32, 64,
[feature_coord[significant_features[idx]]])
ax.imshow(image)
ax.set_xticks([])
ax.set_yticks([])
fig.suptitle('The most important features')
plt.show()
def haar_without_ada(train_harr,labels,feature_maps):
coord=[]
for feature in feature_maps:
feat_coord,_=haar_like_feature_coord(20, 20, feature)
coord.append(feat_coord)
error=[]
indicator=np.ones((np.size(train_harr,0)))
for j in range(np.size(train_harr,1)):
threshold=np.mean(train_harr[:,j])
predictions=np.ones(np.size(train_harr,0))
for k,feats in enumerate(train_harr[:,j]):
if(feats< threshold):
predictions[k]=-1
error_thresh=sum(indicator[predictions!=labels])
error.append((error_thresh))
error=np.array(error)
# Get 10 most minimum values of error along with their coords
indices=np.argsort(error)
return coord, indices
def identify_selected_features(self, images, labels, size=(32, 64)):
""" """
# Compute the haar-like features for all of the different feature types
X = delayed(self.compute(img) for img in images)
X = np.array(X.compute(scheduler='processes'))
X_train, X_test, y_train, y_test = train_test_split(X,
labels,
test_size=0.25)
# Train a random forest classifier to find out which features are important for training
clf = RandomForestClassifier(n_estimators=1000,
max_depth=None,
max_features=100,
n_jobs=-1,
random_state=0)
clf.fit(X_train, y_train)
significant_features = np.argsort(clf.feature_importances_)[::-1]
cdf_feature_importances = np.cumsum(
clf.feature_importances_[significant_features])
cdf_feature_importances /= np.max(cdf_feature_importances)
sig_feature_count = np.count_nonzero(cdf_feature_importances < 0.7)
sig_feature_percent = round(
sig_feature_count / len(cdf_feature_importances) * 100, 1)
print((
'{} features, or {}%, account for {}% of branch points in the random '
'forest.').format(sig_feature_count, sig_feature_percent, 0.7))
# Extract all possible features to be able to select the most salient
feature_coord, feature_type = haar_like_feature_coord(width=size[0],
height=size[1])
# Store the most informative features
self.selected_feature_coord = feature_coord[
significant_features[:sig_feature_count]]
self.selected_feature_type = feature_type[
significant_features[:sig_feature_count]]
def detection(img):
width = img.shape[0]
height = img.shape[1]
print(height)
ptr_w = 0
ptr_h = 0
classi = joblib.load("D:/dataset/haarmodel.m")
while ptr_h < height:
while ptr_w < width:
part_img = img[ptr_w:ptr_w + 60, ptr_h:ptr_h + 100]
img_gray = color.rgb2gray(part_img)
io.imshow(img_gray)
io.show()
coord, ft = haar_like_feature_coord(100, 60, feature_types[0])
feature = haar_like_feature(img_gray, 0, 0, 100, 60, ft, coord)
test = np.array([feature])
res = classi.predict(test)
if res == 1:
print("PL detected")
else:
print("NOT detected" + str(ptr_w) + "_" + str(ptr_h))
if (ptr_w + 90) == width:
ptr_w = width + 1
else:
ptr_w += 70
if (ptr_w + 70) > width:
ptr_w = width - 90
ptr_w = 0
if (ptr_h + 100) == height:
ptr_h = height + 1
else:
ptr_h += 100
if (ptr_h + 100) > height:
print("end")
ptr_h = height - 100
def get_adaboost_haar_f(index,dataset,feature_type):
f_coord,f_type = haar_like_feature_coord(dataset[0].shape[0],dataset[0].shape[1],feature_type)
H_list = [np.asarray([get_adaboost_haar(data,ind,f_type,f_coord)[0] for data in dataset])\
for ind in tqdm(index)]
return np.asarray(H_list)
def adaboost_haar_vis(face_data,hfs,f_type):
coord,_ = haar_like_feature_coord(face_data[0].shape[0], face_data[0].shape[1],f_type)
for i in range(10):
visualize_haar_f(face_data[i],coord[hfs[i]])
extract_feature_image(gray, feature_coord=cset)
image = draw_haar_like_feature(gray, 0, 0,
600,
600,
'type-2-x')
### experimenting with the HAAR like features
feature_types = ['type-2-x', 'type-2-y']
image = images[0]
image=(images[0])
feature_coord, _ = haar_like_feature_coord(12, 24, 'type-2-y')
image = draw_haar_like_feature(image, 0, 0,
images.shape[2],
images.shape[1],
feature_coord,
alpha=0.1)
plt.imshow(image)
?draw_haar_like_feature
?haar_like_feature_coord
import numpy as np
from skimage.feature import haar_like_feature_coord
from skimage.feature import draw_haar_like_feature
feature_coord, _ = haar_like_feature_coord(2, 2, 'type-3')
def featureCreate(img, fType):
coord, _ = haar_like_feature_coord(img.shape[1], img.shape[0], fType)
return coord
"""Extract the haar feature for the current image"""
ii = integral_image(img)
return haar_like_feature(ii,
0,
0,
ii.shape[0],
ii.shape[1],
feature_type=feature_type,
feature_coord=feature_coord)
TOTAL = path + path2
print(path)
img = cv2.imread(path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
feat_coord, feat_type = haar_like_feature_coord(2, 2, feature_types)
features = draw_haar_like_feature(img, 2, 3, 39, 39, feat_coord)
#X = delayed(extract_feature_image(img, feature_types)
#for imgs in img)
#print(X)
#x= extract_feature_image(img,'type-4', feature_coord=None)
img2 = integral_image(img)
feature = haar_like_feature(img, 0, 0, 7, 7, feature_types)
print(len(feature))
print(feature)
#img = cv2.imread('D:\Documents\OPENCV\DB_PLATES\carro (1).jpg')
from skimage.feature import haar_like_feature
from skimage.feature import haar_like_feature_coord
from skimage.feature import draw_haar_like_feature
img = np.ones((6, 6), dtype=np.uint8)
print('IMAGE:')
print(img)
print('IMAGE DIMENSIONS')
print('{} * {}'.format(img.shape[0], img.shape[1]))
img_ii = integral_image(img)
print(img_ii)
coord = (np.array([[(0, 0), (0, 0)], [(0, 1), (0, 1)], [(0, 2), (0, 2)]]))
feature_coord, feature_type = haar_like_feature_coord(width=img.shape[1],
height=img.shape[0],
feature_type="type-3-x")
print('COORDINATES OF EACH FEATURE')
print(type(feature_coord))
print(feature_type)
print(len(feature_type))
print('VALUE OF IMAGE AFTER APPLYING THE FEATURES')
feature = haar_like_feature(img_ii,
0,
0,
img.shape[1],
img.shape[0],
feature_type[0],
feature_coord=feature_coord[0])
print(feature)
print(len(feature))
# the computation step
X = delayed(extract_feature_image(img, feature_types) for img in images)
# Compute the result using the "processes" dask backend
t_start = time()
X = np.array(X.compute(scheduler='processes'))
time_full_feature_comp = time() - t_start
y = np.array([1] * 100 + [0] * 100)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
train_size=150,
random_state=0,
stratify=y)
# Extract all possible features to be able to select the most salient.
feature_coord, feature_type = \
haar_like_feature_coord(width=images.shape[2], height=images.shape[1],
feature_type=feature_types)
###############################################################################
# A random forest classifier can be trained in order to select the most salient
# features, specifically for face classification. The idea is to check which
# features are the most often used by the ensemble of trees. By using only
# the most salient features in subsequent steps, we can dramatically speed up
# computation, while retaining accuracy.
# Train a random forest classifier and check performance
clf = RandomForestClassifier(n_estimators=1000,
max_depth=None,
max_features=100,
n_jobs=-1,
random_state=0)
t_start = time()
###############################################################################
# The Haar-like feature descriptors come into 5 different types as illustrated
# in the figure below. The value of the descriptor is equal to the difference
# between the sum of intensity values in the green and the red one.
images = [np.zeros((2, 2)), np.zeros((2, 2)),
np.zeros((3, 3)), np.zeros((3, 3)),
np.zeros((2, 2))]
feature_types = ['type-2-x', 'type-2-y',
'type-3-x', 'type-3-y',
'type-4']
fig, axs = plt.subplots(3, 2)
for ax, img, feat_t in zip(np.ravel(axs), images, feature_types):
coord, _ = haar_like_feature_coord(img.shape[0], img.shape[1], feat_t)
haar_feature = draw_haar_like_feature(img, 0, 0,
img.shape[0],
img.shape[1],
coord,
max_n_features=1,
random_state=0)
ax.imshow(haar_feature)
ax.set_title(feat_t)
ax.set_xticks([])
ax.set_yticks([])
fig.suptitle('The different Haar-like feature descriptors')
plt.axis('off')
plt.show()
from skimage.transform import integral_image
from skimage.feature import haar_like_feature
from skimage.feature import haar_like_feature_coord
from skimage.feature import draw_haar_like_feature
#### get the images from example dataset face recognition
images = lfw_subset()
### experimenting with the HAAR like features
feature_types = ['type-2-x', 'type-2-y']
face2rec = images[0]
plt.imshow(face2rec)
ii = integral_image(face2rec)
plt.imshow(ii)
feature_coord, _ = haar_like_feature_coord(3, 3)#, 'type-3-y')
haar_feat = draw_haar_like_feature(ii, 0, 0,
images.shape[2],
images.shape[1],
feature_coord,
alpha=0.1)
plt.imshow(face2rec)
plt.imshow(haar_feat)
plt.show()
?draw_haar_like_feature
images.shape
#?haar_like_feature_coord
#rgb2gray(img)
?haar_like_feature_coord
feature_coord
"""Extract the haar feature for the current image"""
ii = integral_image(img)
return haar_like_feature(ii,
0,
0,
ii.shape[0],
ii.shape[1],
feature_type=feature_type,
feature_coord=feature_coord)
with open('glasses_model.pkl', 'rb') as file:
glasses_haar, idx = pickle.load(file)
feature_types = ['type-2-x', 'type-2-y']
feature_coord, feature_type = \
haar_like_feature_coord(width=32, height=32,
feature_type=feature_types)
selected_feature_coord = feature_coord[idx]
selected_feature_type = feature_type[idx]
# Import matchlab icon
image = cv2.imread('match_lab_logo.png', cv2.IMREAD_UNCHANGED)
mask = cv2.cvtColor(image[:, :, -1], cv2.COLOR_GRAY2BGR)
overlay = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR) * (mask / 255)
# Turn on camera
videoCapture = cv2.VideoCapture(0)
frameHeight = int(videoCapture.get(cv2.CAP_PROP_FRAME_HEIGHT))
frameWidth = int(videoCapture.get(cv2.CAP_PROP_FRAME_WIDTH))
minSize = min(frameHeight, frameWidth)
# Preallocate video frame and ethnicity/gender queues
def get_haar_coordinates(img):
coord, feature_type = haar_like_feature_coord(img.shape[1], img.shape[0],
feature_types)
return coord, feature_type
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 8 15:32:47 2019
@author: marijnhazelbag
"""
images = lfw_subset()
### experimenting with the HAAR like features
feature_types = ['type-2-x', 'type-2-y']
image = images[0]
image=(images[0])
feature_coord, _ = haar_like_feature_coord(12, 24, 'type-2-y')
image = draw_haar_like_feature(image, 0, 0,
images.shape[2],
images.shape[1],
feature_coord,
alpha=0.1)
plt.imshow(image)
?draw_haar_like_feature
?haar_like_feature_coord
list([[(13, 13), (13, 27)], [(27, 13), (27, 27)]]),
list([[(13, 27), (13, 27)], [(27, 27), (27, 27)]])
],
dtype=object)
feat_type = np.array([
'type-2-x', 'type-2-x', 'type-2-x', 'type-2-x', 'type-2-x', 'type-2-x',
'type-2-x', 'type-2-x', 'type-2-x', 'type-2-x', 'type-2-y', 'type-2-y',
'type-2-y', 'type-2-y', 'type-2-y', 'type-2-y', 'type-2-y', 'type-2-y',
'type-2-y', 'type-2-y'
],
dtype=object)
# HAAR FILTER : version 2
radius = 30
feat_coord, feat_type = feature.haar_like_feature_coord(
28, 28, ['type-2-x', 'type-2-y'])
#reducing the number of filters
i = 0
while i < len(feat_coord):
if (feat_coord[i][0][1][0] - feat_coord[i][0][0][0])**2 + (
feat_coord[i][0][1][1] - feat_coord[i][0][0][1])**2 < radius:
feat_coord = np.delete(feat_coord, i)
feat_type = np.delete(feat_type, i)
else:
i += 1
# one over 4
feat_coord = feat_coord[::4]
feat_type = feat_type[::4]
print('features', feat_coord.shape)
first = True
import numpy as np
from skimage import feature
from skimage.color import rgb2gray
from skimage.transform import integral_image
from .utils import compress_image
# Transform a [[n_images, h, l, 3]] shaped array with h, l constant
# into a [[n_images, k]] shaped array where k is a constant
DEFAULT_SAMPLE_SIZE = (40, 25)
DEFAULT_HAAR_FEATURE = 'type-3-x'
ft_set = feature.haar_like_feature_coord(*DEFAULT_SAMPLE_SIZE[::-1],
feature_type=DEFAULT_HAAR_FEATURE)
BEST_HAAR_INDEXES_PATH = 'haar_best_indexes.txt'
haar_indexes = np.loadtxt(BEST_HAAR_INDEXES_PATH, dtype=int)
DEFAULT_HAAR_FEATURE_SET = ft_set[0][haar_indexes], ft_set[1][haar_indexes]
def hog(images, **kwargs):
"""Downsample and compute hog for each image"""
# Get params
kwargs = kwargs.copy()
block_norm = kwargs.pop('block_norm', 'L2')
sample_size = kwargs.pop('sample_size', DEFAULT_SAMPLE_SIZE)
first = feature.hog(compress_image(images[0], sample_size),
block_norm=block_norm,
**kwargs)
vectors = np.empty((len(images), *first.shape))
# in the figure below. The value of the descriptor is equal to the difference
# between the sum of intensity values in the green and the red one.
images = [
np.zeros((2, 2)),
np.zeros((2, 2)),
np.zeros((3, 3)),
np.zeros((3, 3)),
np.zeros((2, 2))
]
feature_types = ['type-2-x', 'type-2-y', 'type-3-x', 'type-3-y', 'type-4']
fig, axs = plt.subplots(3, 2)
for ax, img, feat_t in zip(np.ravel(axs), images, feature_types):
coord, _ = haar_like_feature_coord(img.shape[0], img.shape[1], feat_t)
haar_feature = draw_haar_like_feature(img,
0,
0,
img.shape[0],
img.shape[1],
coord,
max_n_features=1,
random_state=0)
ax.imshow(haar_feature)
ax.set_title(feat_t)
ax.set_xticks([])
ax.set_yticks([])
fig.suptitle('The different Haar-like feature descriptors')
plt.axis('off')
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score
from skimage.data import lfw_subset
from skimage.transform import integral_image
from skimage.feature import haar_like_feature
from skimage.feature import haar_like_feature_coord
from skimage.feature import draw_haar_like_feature
#### get the images from example dataset face recognition
images = lfw_subset()
### experimenting with the HAAR like features
feature_types = ['type-2-x', 'type-2-y']
image = images[0]
image = (images[0])
feature_coord, _ = haar_like_feature_coord(12, 24, 'type-2-y')
image = draw_haar_like_feature(image,
0,
0,
images.shape[2],
images.shape[1],
feature_coord,
alpha=0.1)
plt.imshow(image)
#?draw_haar_like_feature
#?haar_like_feature_coord
y_train = np.array([+1] * len(tr_face_data) + [-1] * len(tr_non_face_data))
# In[ ]:
X_test = np.array([
haar_like_feature(integral_image(te_data[i]),
width=face_dim[0],
height=face_dim[1],
r=0,
c=0) for i in range(len(te_data))
])
y_test = np.array([+1] * len(te_face_data) + [-1] * len(te_non_face_data))
# In[ ]:
feature_coord, feature_type = haar_like_feature_coord(width=face_dim[0],
height=face_dim[1])
# In[ ]:
feature_coord.shape, X_train.shape, y_train.shape, X_test.shape, y_test.shape
# # Plotting HAAR Features
# In[ ]:
def plot_haar_feature(best_feature_coordinates, name='ada_boost'):
for idx, feature_coordinate in enumerate(best_feature_coordinates):
image = cv2.normalize(tr_data[0],
None,
alpha=0,
# Build a computation graph using dask. This allows using multiple CPUs for
# the computation step
X = delayed(extract_feature_image(img, feature_types)
for img in images)
# Compute the result using the "processes" dask backend
t_start = time()
X = np.array(X.compute(scheduler='processes'))
time_full_feature_comp = time() - t_start
y = np.array([1] * 100 + [0] * 100)
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=150,
random_state=0,
stratify=y)
# Extract all possible features to be able to select the most salient.
feature_coord, feature_type = \
haar_like_feature_coord(width=images.shape[2], height=images.shape[1],
feature_type=feature_types)
###############################################################################
# A random forest classifier can be trained in order to select the most salient
# features, specifically for face classification. The idea is to check which
# features are the most often used by the ensemble of trees. By using only
# the most salient features in subsequent steps, we can dramatically speed up
# computation, while retaining accuracy.
# Train a random forest classifier and check performance
clf = RandomForestClassifier(n_estimators=1000, max_depth=None,
max_features=100, n_jobs=-1, random_state=0)
t_start = time()
clf.fit(X_train, y_train)
time_full_train = time() - t_start
auc_full_features = roc_auc_score(y_test, clf.predict_proba(X_test)[:, 1])
