def test_create_complete(self):
feature = Feature(self.minimum_data)
feature.add_custom_data(self.additional_data)
eq_('alias/project', feature.project)
eq_('status_200', feature.name)
eq_(0.0, feature.min30)
eq_(0.0453, feature.mean30)
eq_(1119.0, feature.max30)
eq_(28.5136, feature.var30)
eq_(5.3398, feature.std30)
eq_(0.0, feature.median30)
def execute(self, *args, **kwargs):
""" Computes simple statistics over all examples of project and interval.
All operations are calculated over entire matrix across columns
(features) except percentile and histogram. After all calculations
data is saved in feature set in one record per feature/project and one
bin per stat/interval.
"""
project_interval = "{0}_{1}".format(self.project.full_name,
self.interval)
labels, X = self.create_ndarray(
self.session.query(Example).filter_by(p_interval=project_interval))
tmp_stats = {
'max': np.amax(X[:, 3:], 0),
'min': np.amin(X[:, 3:], 0),
'mean': np.mean(X[:, 3:], 0),
'std': np.std(X[:, 3:], 0),
'var': np.var(X[:, 3:], 0),
'median': np.median(X[:, 3:], 0),
}
# reshape by feature
for feature_index, feature_name in enumerate(labels[3:]):
if feature_name == 'grouptime':
continue
custom_data = {}
xkey = feature_index + 3
feature = Feature({
'project': self.project.full_name,
'name': feature_name
})
hist, bin_hedges = np.histogram(X[:, xkey], bins=10)
# cast to list are needed by persistence layer (array not supported)
custom_data['histogram{0}'.format(
self.interval)] = [list(hist), list(bin_hedges)]
custom_data['percentile{0}'.format(self.interval)] = list(
np.percentile(X[:, xkey], [25, 50, 75]))
for stat_name, stat_value in tmp_stats.items():
name = '{0}{1}'.format(stat_name, self.interval)
value = float(stat_value[feature_index]) # cast needed
custom_data[name] = value
feature.add_custom_data(custom_data)
self.session.add(feature)
import os, joblib, cv2, dlib
import socket
import uuid
from model.feature import Feature
saved_img_path = 'server/static/result/'
ip = socket.gethostbyname(socket.gethostname())
url = 'http://'+ip+':'+str(os.getenv('PORT'))+'/static/result/'
model = joblib.load('model/tools/model.sav')
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor("model/tools/shape_predictor_68_face_landmarks.dat")
ft = Feature(detector, predictor)
def draw_face_landmarks(img_path):
img = cv2.imread(img_path)
image = cv2.imread(img_path, 0)
detections = detector(image, 1)
best_face = 0
if len(detections) > 1:
# On s'interisse au visage de grande dimension qui est le plus proche dans l'image
max_surface = 0
xm, ym, wm, hm = 0, 0, 0, 0
for i, face in enumerate(detections) :
# Finding points for rectangle to draw on face
xi, yi, wi,hi = face.left(), face.top(), face.width(), face.height()
if wi*hi > max_surface:
xm, ym, wm,hm = xi, yi, wi,hi
def get_feature(self, feat_name, feature_index):
var_datatype = self.get_data_type(feat_name)
var_vartype = self.get_vartype_formatted(feat_name)
var_count = self.get_count(feat_name)
var_missing = self.get_missing_formatted(feat_name)
var_unique = self.get_count_unique(feat_name)
# Numeric only
var_avg = self.format_rounded_string(self.get_average(feat_name))
var_median = self.get_median(feat_name)
var_mode = self.get_mode(feat_name)
var_max = self.get_max(feat_name)
var_min = self.get_min(feat_name)
var_stddev = self.format_rounded_string(self.get_stddev(feat_name))
var_variance = self.format_rounded_string(self.get_variance(feat_name))
var_quantile25 = self.format_rounded_string(self.get_quantile25(feat_name))
var_quantile75 = self.format_rounded_string(self.get_quantile75(feat_name))
var_iqr = self.format_rounded_string(self.get_iqr(feat_name))
var_skew = self.format_rounded_string(self.get_skew(feat_name))
var_kurtosis = self.format_rounded_string(self.get_kurtosis(feat_name))
# Non-numeric only
var_mostcommon = self.get_mostcommon(feat_name)
var_leastcommon = self.get_leastcommon(feat_name)
# Graphs
graph_histogram = self.get_histogram(feat_name)
graph_countplot = self.get_countplot(feat_name)
# Errors, warnings, and info
feat_errors = self.get_errors(feat_name)
feat_warnings = self.get_warnings(feat_name)
feat_notes = self.get_notes(feat_name)
# Save the feature stats
feature = Feature(feat_name=feat_name,
feat_index=feature_index,
feat_datatype=var_datatype,
feat_vartype=var_vartype,
feat_count=var_count,
feat_missing=var_missing,
feat_unique=var_unique,
feat_average=var_avg,
feat_median=var_median,
feat_mode=var_mode,
feat_max=var_max,
feat_min=var_min,
feat_stddev=var_stddev,
feat_variance=var_variance,
feat_quantile25=var_quantile25,
feat_quantile75=var_quantile75,
feat_iqr=var_iqr,
feat_skew=var_skew,
feat_kurtosis=var_kurtosis,
feat_mostcommon=var_mostcommon,
feat_leastcommon=var_leastcommon,
graph_histogram=graph_histogram,
graph_countplot=graph_countplot,
feat_errors=feat_errors,
feat_warnings=feat_warnings,
feat_notes=feat_notes)
return feature
def test_to_primitive(self):
feature = Feature(self.minimum_data)
feature.add_custom_data(self.additional_data)
primitive = feature.to_primitive()
def test_validate_complete_data(self):
feature = Feature(self.minimum_data)
feature.add_custom_data(self.additional_data)
feature.validate()
def test_validate_minimum_data(self):
feature = Feature(self.minimum_data)
feature.validate()
def test_tablename(self):
eq_('feature', Feature.__tablename__)
feature = Feature(self.minimum_data)
eq_('feature', feature.__tablename__)
def test_key(self):
feature = Feature(self.minimum_data)
eq_('alias/project-status_200', feature.__key__)
def test_create_minimum_data(self):
feature = Feature(self.minimum_data)
eq_('alias/project', feature.project)
eq_('status_200', feature.name)
def get_base_feature(self, base_feat, feature_index):
feat_datatype = self.get_data_type(base_feat)
feat_vartype = self.get_variable_type(base_feat)
base_feature = Feature(feat_name=base_feat, feat_index=feature_index, feat_datatype=feat_datatype,
feat_vartype=feat_vartype)
return base_feature
