Create README.md

README.md

@@ -0,0 +1,131 @@
+---
+license: mit
+library_name: sklearn
+---
+
+# svm_au
+
+## Model Description
+svm_au combines histogram of oriented gradient feature extraction with a linear support vector machine to predict facial action units from single frame images. 
+
+## Model Details
+- **Model Type**: Support Vector Machine (SVM)
+- **Framework**: sklearn
+
+## Model Sources
+- **Repository**: [GitHub Repository](https://github.com/cosanlab/py-feat)
+- **Paper**: [Py-feat: Python facial expression analysis toolbox](https://link.springer.com/article/10.1007/s42761-023-00191-4)
+
+## Citation
+If you use the svm_au model in your research or application, please cite the following paper:
+
+Cheong, J.H., Jolly, E., Xie, T. et al. Py-Feat: Python Facial Expression Analysis Toolbox. Affec Sci 4, 781–796 (2023). https://doi.org/10.1007/s42761-023-00191-4
+
+```
+@article{cheong2023py,
+  title={Py-feat: Python facial expression analysis toolbox},
+  author={Cheong, Jin Hyun and Jolly, Eshin and Xie, Tiankang and Byrne, Sophie and Kenney, Matthew and Chang, Luke J},
+  journal={Affective Science},
+  volume={4},
+  number={4},
+  pages={781--796},
+  year={2023},
+  publisher={Springer}
+}
+```
+
+## Example Useage
+
+```python
+import numpy as np
+from skops.io import dump, load, get_untrusted_types
+from huggingface_hub import hf_hub_download
+
+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          
+
+# Load model and weights
+au_model = SVMClassifier()
+model_path = hf_hub_download(repo_id="py-feat/svm_au", filename="svm_au_classifier.skops")
+unknown_types = get_untrusted_types(file=model_path)
+loaded_model = load(model_path, trusted=unknown_types)
+au_model.load_weights(scaler_upper = loaded_model.scaler_upper, 
+                      pca_model_upper = loaded_model.pca_model_upper,
+                      scaler_lower = loaded_model.scaler_lower, 
+                      pca_model_lower = loaded_model.scaler_full, 
+                      pca_model_full=loaded_model.pca_model_full, 
+                      classifiers=loaded_model.classifiers)
+
+# Test model
+frame = "path/to/your/test_image.jpg"  # Replace with your loaded image
+landmarks = np.array([...])  # Replace with your landmarks data
+pred = au_model.detect_au(frame, landmarks)
+print(pred)
+
+```
+
+