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)
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)
def _load_feature_with_background(self): feature_and_background = self._parsed_data[1] feature = feature_and_background[0] feature_name = ' '.join(feature[1]) self._feature = feature_name # Used to create scenarios db_feature = None try: Feature.get(Feature.name == feature_name) # This statement will throw an exception if feature is not in the db db_feature = Feature(name=feature_name + " - (Duplicated)") db_feature.save() except Feature.DoesNotExist: print "Adding new feature to database..." db_feature = Feature.create(name=feature_name) if len(feature_and_background) > 1: # Has background background = feature_and_background[1] scenario = self._create_scenario(parser_constants.BACKGROUND, True, [], db_feature) for step in background[1]: self._create_step(' '.join(step[1]), scenario, step[0]) return db_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
def find_features(self, expression): return Feature.select().where(Feature.name ** (self._ANY_STRING + expression + self._ANY_STRING))
def find_features_per_step(self, step_id): return Feature.select().join(Scenario).join(Step).where(Step.id == step_id)