15090929758

Committed 19 Oct 2024 05:10AM UTC coverage: 54.553%. First build

Build # 15090929758

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #228 from cosanlab/huggingface

WIP: Huggingface Integration

Run Details

702 of 1620 new or added lines in 46 files covered. (43.33%)

3409 of 6249 relevant lines covered (54.55%)

3.27 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.33

/feat/au_detectors/StatLearning/SL_test.py

# Implements different statistical learning algorithms to classify AUs
# Please see https://www.cl.cam.ac.uk/~mmam3/pub/FG2015.pdf for more details and reasons

import numpy as np


class SVMClassifier:
    def __init__(self) -> None:
        self.weights_loaded = False

    def load_weights(
        self,
        scaler_upper=None,
        pca_model_upper=None,
        scaler_lower=None,
        pca_model_lower=None,
        scaler_full=None,
        pca_model_full=None,
        classifiers=None,
    ):
        self.scaler_upper = scaler_upper
        self.pca_model_upper = pca_model_upper
        self.scaler_lower = scaler_lower
        self.pca_model_lower = pca_model_lower
        self.scaler_full = scaler_full
        self.pca_model_full = pca_model_full
        self.classifiers = classifiers
        self.weights_loaded = True

    def pca_transform(self, frame, scaler, pca_model, landmarks):
        if not self.weights_loaded:
            raise ValueError("Need to load weights before running pca_transform")
        else:
            transformed_frame = pca_model.transform(scaler.transform(frame))
            return np.concatenate((transformed_frame, landmarks), axis=1)

    def detect_au(self, frame, landmarks):
        """
        Note that here frame is represented by hogs
        """
        if not self.weights_loaded:
            raise ValueError("Need to load weights before running detect_au")
        else:
            landmarks = np.concatenate(landmarks)
            landmarks = landmarks.reshape(-1, landmarks.shape[1] * landmarks.shape[2])

            pca_transformed_upper = self.pca_transform(
                frame, self.scaler_upper, self.pca_model_upper, landmarks
            )
            pca_transformed_lower = self.pca_transform(
                frame, self.scaler_lower, self.pca_model_lower, landmarks
            )
            pca_transformed_full = self.pca_transform(
                frame, self.scaler_full, self.pca_model_full, landmarks
            )

            aus_list = sorted(self.classifiers.keys(), key=lambda x: int(x[2::]))

            pred_aus = []
            for keys in aus_list:
                if keys in ["AU1", "AU4", "AU6"]:
                    au_pred = self.classifiers[keys].predict(pca_transformed_upper)
                elif keys in ["AU11", "AU12", "AU17"]:
                    au_pred = self.classifiers[keys].predict(pca_transformed_lower)
                elif keys in [
                    "AU2",
                    "AU5",
                    "AU7",
                    "AU9",
                    "AU10",
                    "AU14",
                    "AU15",
                    "AU20",
                    "AU23",
                    "AU24",
                    "AU25",
                    "AU26",
                    "AU28",
                    "AU43",
                ]:
                    au_pred = self.classifiers[keys].predict(pca_transformed_full)
                else:
                    raise ValueError("unknown AU detected")

                pred_aus.append(au_pred)
            pred_aus = np.array(pred_aus).T
            return pred_aus


class XGBClassifier:
    def __init__(self) -> None:
        self.au_keys = [
            "AU1",
            "AU2",
            "AU4",
            "AU5",
            "AU6",
            "AU7",
            "AU9",
            "AU10",
            "AU11",
            "AU12",
            "AU14",
            "AU15",
            "AU17",
            "AU20",
            "AU23",
            "AU24",
            "AU25",
            "AU26",
            "AU28",
            "AU43",
        ]
        self.weights_loaded = False

    def load_weights(
        self,
        scaler_upper=None,
        pca_model_upper=None,
        scaler_lower=None,
        pca_model_lower=None,
        scaler_full=None,
        pca_model_full=None,
        classifiers=None,
    ):
        self.scaler_upper = scaler_upper
        self.pca_model_upper = pca_model_upper
        self.scaler_lower = scaler_lower
        self.pca_model_lower = pca_model_lower
        self.scaler_full = scaler_full
        self.pca_model_full = pca_model_full
        self.classifiers = classifiers
        self.weights_loaded = True

    def pca_transform(self, frame, scaler, pca_model, landmarks):
        if not self.weights_loaded:
            raise ValueError("Need to load weights before running pca_transform")
        else:
            # NOTES: can directly do math to avoid sklearn overhead
            transformed_frame = pca_model.transform(scaler.transform(frame))
            return np.concatenate((transformed_frame, landmarks), axis=1)

    def detect_au(self, frame, landmarks):
        if not self.weights_loaded:
            raise ValueError("Need to load weights before running detect_au")
        else:
            landmarks = np.concatenate(landmarks)
            landmarks = landmarks.reshape(-1, landmarks.shape[1] * landmarks.shape[2])

            pca_transformed_upper = self.pca_transform(
                frame, self.scaler_upper, self.pca_model_upper, landmarks
            )
            pca_transformed_lower = self.pca_transform(
                frame, self.scaler_lower, self.pca_model_lower, landmarks
            )
            pca_transformed_full = self.pca_transform(
                frame, self.scaler_full, self.pca_model_full, landmarks
            )

            pred_aus = []
            for key in self.au_keys:
                classifier = self.classifiers[key]

                if key in ["AU1", "AU2", "AU7"]:
                    au_pred = classifier.predict_proba(pca_transformed_upper)[:, 1]
                elif key in ["AU11", "AU14", "AU17", "AU23", "AU24", "AU26"]:
                    au_pred = classifier.predict_proba(pca_transformed_lower)[:, 1]
                else:
                    au_pred = classifier.predict_proba(pca_transformed_full)[:, 1]

                pred_aus.append(au_pred)

            return np.array(pred_aus).T

1	# Implements different statistical learning algorithms to classify AUs
2	# Please see https://www.cl.cam.ac.uk/~mmam3/pub/FG2015.pdf for more details and reasons
3
4	import numpy as np	6✔
5
6
7	class SVMClassifier:	6✔
8	def __init__(self) -> None:	6✔
NEW 9	self.weights_loaded = False	×
10
11	def load_weights(	6✔
12	self,
13	scaler_upper=None,
14	pca_model_upper=None,
15	scaler_lower=None,
16	pca_model_lower=None,
17	scaler_full=None,
18	pca_model_full=None,
19	classifiers=None,
20	):
NEW 21	self.scaler_upper = scaler_upper	×
NEW 22	self.pca_model_upper = pca_model_upper	×
NEW 23	self.scaler_lower = scaler_lower	×
NEW 24	self.pca_model_lower = pca_model_lower	×
NEW 25	self.scaler_full = scaler_full	×
NEW 26	self.pca_model_full = pca_model_full	×
NEW 27	self.classifiers = classifiers	×
NEW 28	self.weights_loaded = True	×
29
30	def pca_transform(self, frame, scaler, pca_model, landmarks):	6✔
NEW 31	if not self.weights_loaded:	×
NEW 32	raise ValueError("Need to load weights before running pca_transform")	×
33	else:
NEW 34	transformed_frame = pca_model.transform(scaler.transform(frame))	×
NEW 35	return np.concatenate((transformed_frame, landmarks), axis=1)	×
36
37	def detect_au(self, frame, landmarks):	6✔
38	"""
39	Note that here frame is represented by hogs
40	"""
NEW 41	if not self.weights_loaded:	×
NEW 42	raise ValueError("Need to load weights before running detect_au")	×
43	else:
NEW 44	landmarks = np.concatenate(landmarks)	×
NEW 45	landmarks = landmarks.reshape(-1, landmarks.shape[1] * landmarks.shape[2])	×
46
NEW 47	pca_transformed_upper = self.pca_transform(	×
48	frame, self.scaler_upper, self.pca_model_upper, landmarks
49	)
NEW 50	pca_transformed_lower = self.pca_transform(	×
51	frame, self.scaler_lower, self.pca_model_lower, landmarks
52	)
NEW 53	pca_transformed_full = self.pca_transform(	×
54	frame, self.scaler_full, self.pca_model_full, landmarks
55	)
56
NEW 57	aus_list = sorted(self.classifiers.keys(), key=lambda x: int(x[2::]))	×
58
NEW 59	pred_aus = []	×
NEW 60	for keys in aus_list:	×
NEW 61	if keys in ["AU1", "AU4", "AU6"]:	×
NEW 62	au_pred = self.classifiers[keys].predict(pca_transformed_upper)	×
NEW 63	elif keys in ["AU11", "AU12", "AU17"]:	×
NEW 64	au_pred = self.classifiers[keys].predict(pca_transformed_lower)	×
NEW 65	elif keys in [	×
66	"AU2",
67	"AU5",
68	"AU7",
69	"AU9",
70	"AU10",
71	"AU14",
72	"AU15",
73	"AU20",
74	"AU23",
75	"AU24",
76	"AU25",
77	"AU26",
78	"AU28",
79	"AU43",
80	]:
NEW 81	au_pred = self.classifiers[keys].predict(pca_transformed_full)	×
82	else:
NEW 83	raise ValueError("unknown AU detected")	×
84
NEW 85	pred_aus.append(au_pred)	×
NEW 86	pred_aus = np.array(pred_aus).T	×
NEW 87	return pred_aus	×
88
89
90	class XGBClassifier:	6✔
91	def __init__(self) -> None:	6✔
92	self.au_keys = [	6✔
93	"AU1",
94	"AU2",
95	"AU4",
96	"AU5",
97	"AU6",
98	"AU7",
99	"AU9",
100	"AU10",
101	"AU11",
102	"AU12",
103	"AU14",
104	"AU15",
105	"AU17",
106	"AU20",
107	"AU23",
108	"AU24",
109	"AU25",
110	"AU26",
111	"AU28",
112	"AU43",
113	]
114	self.weights_loaded = False	6✔
115
116	def load_weights(	6✔
117	self,
118	scaler_upper=None,
119	pca_model_upper=None,
120	scaler_lower=None,
121	pca_model_lower=None,
122	scaler_full=None,
123	pca_model_full=None,
124	classifiers=None,
125	):
126	self.scaler_upper = scaler_upper	6✔
127	self.pca_model_upper = pca_model_upper	6✔
128	self.scaler_lower = scaler_lower	6✔
129	self.pca_model_lower = pca_model_lower	6✔
130	self.scaler_full = scaler_full	6✔
131	self.pca_model_full = pca_model_full	6✔
132	self.classifiers = classifiers	6✔
133	self.weights_loaded = True	6✔
134
135	def pca_transform(self, frame, scaler, pca_model, landmarks):	6✔
136	if not self.weights_loaded:	6✔
NEW 137	raise ValueError("Need to load weights before running pca_transform")	×
138	else:
139	# NOTES: can directly do math to avoid sklearn overhead
140	transformed_frame = pca_model.transform(scaler.transform(frame))	6✔
141	return np.concatenate((transformed_frame, landmarks), axis=1)	6✔
142
143	def detect_au(self, frame, landmarks):	6✔
144	if not self.weights_loaded:	6✔
NEW 145	raise ValueError("Need to load weights before running detect_au")	×
146	else:
147	landmarks = np.concatenate(landmarks)	6✔
148	landmarks = landmarks.reshape(-1, landmarks.shape[1] * landmarks.shape[2])	6✔
149
150	pca_transformed_upper = self.pca_transform(	6✔
151	frame, self.scaler_upper, self.pca_model_upper, landmarks
152	)
153	pca_transformed_lower = self.pca_transform(	6✔
154	frame, self.scaler_lower, self.pca_model_lower, landmarks
155	)
156	pca_transformed_full = self.pca_transform(	6✔
157	frame, self.scaler_full, self.pca_model_full, landmarks
158	)
159
160	pred_aus = []	6✔
161	for key in self.au_keys:	6✔
162	classifier = self.classifiers[key]	6✔
163
164	if key in ["AU1", "AU2", "AU7"]:	6✔
165	au_pred = classifier.predict_proba(pca_transformed_upper)[:, 1]	6✔
166	elif key in ["AU11", "AU14", "AU17", "AU23", "AU24", "AU26"]:	6✔
167	au_pred = classifier.predict_proba(pca_transformed_lower)[:, 1]	6✔
168	else:
169	au_pred = classifier.predict_proba(pca_transformed_full)[:, 1]	6✔
170
171	pred_aus.append(au_pred)	6✔
172
173	return np.array(pred_aus).T	6✔

cosanlab / py-feat / 15090929758

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous