actinet 0.0.dev5__tar.gz → 0.0.dev6__tar.gz

{actinet-0.0.dev5 → actinet-0.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: actinet
-Version: 0.0.dev5
+Version: 0.0.dev6
 Summary: Activity detection algorithm compatible with the UK Biobank Accelerometer Dataset
 Home-page: https://github.com/OxWearables/actinet
 Download-URL: https://github.com/OxWearables/actinet
@@ -77,7 +77,7 @@ $ actinet -f sample.csv
 Some systems may face issues with Java when running the script. If this is your case, try fixing OpenJDK to version 8:
 
 ```console
-conda install -n actinet openjdk=8
+conda create -n actinet openjdk=8
 ```
 
 ### Offline usage

{actinet-0.0.dev5 → actinet-0.0.dev6}/README.md

@@ -55,7 +55,7 @@ $ actinet -f sample.csv
 Some systems may face issues with Java when running the script. If this is your case, try fixing OpenJDK to version 8:
 
 ```console
-conda install -n actinet openjdk=8
+conda create -n actinet openjdk=8
 ```
 
 ### Offline usage

{actinet-0.0.dev5 → actinet-0.0.dev6}/src/actinet/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-02-06T18:32:30+0000",
+ "date": "2024-03-09T08:28:09+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "ae03389ab9965e52140c46a6c43e39799ad1c61b",
- "version": "0.0.dev5"
+ "full-revisionid": "5b419d5fe6079975dbc6ccbca13b128c52709f3f",
+ "version": "0.0.dev6"
 }
 '''  # END VERSION_JSON
 

{actinet-0.0.dev5 → actinet-0.0.dev6}/src/actinet/actinet.py

@@ -16,12 +16,12 @@ from actinet import __classifier_version__
 from actinet import __classifier_md5__
 from actinet.accPlot import plotTimeSeries
 from actinet.models import ActivityClassifier
-from actinet.sslmodel import SAMPLE_RATE
 from actinet.summarisation import getActivitySummary
 from actinet.utils.utils import infer_freq
 
 BASE_URL = "https://zenodo.org/records/10625542/files/"
 
+
 def main():
 
     parser = argparse.ArgumentParser(
@@ -99,10 +99,14 @@ def main():
 
         return
 
+    else:
+        if not args.filepath:
+            raise ValueError("Please provide a file to process.")
+
     # Load file
     data, info = read(
         args.filepath,
-        resample_hz=SAMPLE_RATE,
+        resample_hz=None,
         sample_rate=args.sample_rate,
         verbose=verbose,
     )
@@ -118,7 +122,11 @@ def main():
 
     check_md5 = args.classifier_path is None
     classifier: ActivityClassifier = load_classifier(
-        args.classifier_path or classifier_path, args.model_repo_path, check_md5, args.force_download, verbose
+        args.classifier_path or classifier_path,
+        args.model_repo_path,
+        check_md5,
+        args.force_download,
+        verbose,
     )
 
     classifier.verbose = verbose
@@ -126,7 +134,7 @@ def main():
 
     if verbose:
         print("Running activity classifier...")
-    Y = classifier.predict_from_frame(data)
+    Y = classifier.predict_from_frame(data, args.sample_rate)
 
     # Save predicted activities
     timeSeriesFile = f"{outdir}/{basename}-timeSeries.csv.gz"
@@ -145,7 +153,7 @@ def main():
             print("Output plot written to:", plotFile)
 
     # Summary
-    summary = getActivitySummary(Y, classifier.labels, True, True, verbose)
+    summary = getActivitySummary(Y, list(classifier.labels), True, True, verbose)
 
     # Join the actipy processing info, with acitivity summary data
     outputSummary = {**summary, **info}
@@ -162,24 +170,33 @@ def main():
     if verbose:
         print("\nSummary Stats\n---------------------")
         print(
-            json.dumps({
-                key: outputSummary[key]
-                for key in [
-                    "Filename",
-                    "Filesize(MB)",
-                    "WearTime(days)",
-                    "NonwearTime(days)",
-                    "ReadOK",
-                ]
-                + [f"{label}-overall-avg" for label in ["acc"] + classifier.labels]
-            }, indent=4, cls=NpEncoder)
+            json.dumps(
+                {
+                    key: outputSummary[key]
+                    for key in [
+                        "Filename",
+                        "Filesize(MB)",
+                        "WearTime(days)",
+                        "NonwearTime(days)",
+                        "ReadOK",
+                    ]
+                    + [
+                        f"{label}-overall-avg"
+                        for label in ["acc"] + list(classifier.labels)
+                    ]
+                },
+                indent=4,
+                cls=NpEncoder,
+            )
         )
 
     after = time.time()
     print(f"Done! ({round(after - before,2)}s)")
 
 
-def read(filepath, resample_hz="uniform", sample_rate=None, verbose=True):
+def read(
+    filepath, resample_hz="uniform", sample_rate=None, lowpass_hz=None, verbose=True
+):
 
     p = pathlib.Path(filepath)
     ftype = p.suffixes[0].lower()
@@ -210,7 +227,7 @@ def read(filepath, resample_hz="uniform", sample_rate=None, verbose=True):
         data, info = actipy.process(
             data,
             sample_rate,
-            lowpass_hz=None,
+            lowpass_hz=lowpass_hz,
             calibrate_gravity=True,
             detect_nonwear=True,
             resample_hz=resample_hz,
@@ -231,7 +248,7 @@ def read(filepath, resample_hz="uniform", sample_rate=None, verbose=True):
 
         data, info = actipy.read_device(
             filepath,
-            lowpass_hz=None,
+            lowpass_hz=lowpass_hz,
             calibrate_gravity=True,
             detect_nonwear=True,
             resample_hz=resample_hz,

actinet-0.0.dev6/src/actinet/evaluate.py

@@ -0,0 +1,215 @@
+from sklearn.model_selection import StratifiedGroupKFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import (
+    classification_report,
+    accuracy_score,
+    f1_score,
+    cohen_kappa_score,
+)
+import numpy as np
+import pandas as pd
+import os
+from imblearn.ensemble import BalancedRandomForestClassifier
+
+from actinet.models import ActivityClassifier
+from actinet.hmm import HMM
+from actinet.utils.utils import safe_indexer
+
+WINSEC = 30
+
+
+def evaluate_preprocessing(
+    classifier: ActivityClassifier,
+    X,
+    Y,
+    groups=None,
+    T=None,
+    weights_path="models/weights.pt",
+    verbose=True,
+):
+    skf = StratifiedGroupKFold(n_splits=5)
+
+    le = LabelEncoder().fit(Y)
+    Y_encoded = le.transform(Y)
+
+    Y_preds = np.empty_like(Y_encoded)
+
+    for fold, (train_index, test_index) in enumerate(skf.split(X, Y_encoded, groups)):
+        X_train, X_test = X[train_index], X[test_index]
+        y_train, y_test = Y_encoded[train_index], Y_encoded[test_index]
+        groups_train = safe_indexer(groups, train_index)
+        t_train = safe_indexer(T, train_index)
+
+        classifier.fit(
+            X_train,
+            y_train,
+            groups_train,
+            t_train,
+            weights_path.format(fold),
+            n_splits=1,
+        )
+        y_pred = classifier.predict(X_test, False)
+
+        if verbose:
+            print(
+                f"Fold {fold+1} Test Scores - Accuracy: {accuracy_score(y_test, y_pred):.3f}, "
+                + f"Macro F1: {f1_score(y_test, y_pred, average='macro'):.3f}"
+            )
+
+        Y_preds[test_index] = y_pred
+
+    Y_preds = le.inverse_transform(Y_preds)
+
+    if verbose:
+        print(classification_report(Y, Y_preds))
+
+    return Y_preds
+
+
+def evaluate_models(
+    actinet_classifier: ActivityClassifier,
+    rf_classifier: BalancedRandomForestClassifier,
+    X_actinet,
+    X_rf,
+    Y_actinet,
+    Y_rf,
+    groups_actinet,
+    groups_rf,
+    T_actinet=None,
+    T_rf=None,
+    weights_path="models/weights.pt",
+    out_dir=None,
+    verbose=True,
+):
+    skf = StratifiedGroupKFold(n_splits=5)
+
+    le = LabelEncoder().fit(Y_rf)
+    Y_encoded_rf = le.transform(Y_rf)
+    Y_encoded_actinet = le.transform(Y_actinet)
+
+    Y_preds_rf = np.empty_like(Y_encoded_rf)
+    Y_preds_actinet = np.empty_like(Y_encoded_actinet)
+
+    results_rf = []
+    results_actinet = []
+
+    for fold, (train_index, test_index) in enumerate(
+        skf.split(X_rf, Y_encoded_rf, groups_rf)
+    ):
+        if verbose:
+            print(f"======== Evalating Fold {fold+1} ========")
+        # Ensure the same train and test split for groups are used in both models in each fold
+        train_index_actinet = np.isin(groups_actinet, np.unique(groups_rf[train_index]))
+        test_index_actinet = np.isin(groups_actinet, np.unique(groups_rf[test_index]))
+
+        train_index_rf = np.isin(groups_rf, np.unique(groups_rf[train_index]))
+        test_index_rf = np.isin(groups_rf, np.unique(groups_rf[test_index]))
+
+        # Train test split for actinet model
+        X_train_actinet, X_test_actinet = (
+            X_actinet[train_index_actinet],
+            X_actinet[test_index_actinet],
+        )
+        y_train_actinet, y_test_actinet = (
+            Y_encoded_actinet[train_index_actinet],
+            Y_encoded_actinet[test_index_actinet],
+        )
+        groups_train_actinet = groups_actinet[train_index_actinet]
+        groups_test_actinet = groups_actinet[test_index_actinet]
+
+        t_train_actinet = safe_indexer(T_actinet, train_index_actinet)
+        t_test_actinet = safe_indexer(T_actinet, test_index_actinet)
+
+        # Train test split for accelerometer model
+        X_train_rf, X_test_rf = X_rf[train_index_rf], X_rf[test_index_rf]
+        y_train_rf, y_test_rf = (
+            Y_encoded_rf[train_index_rf],
+            Y_encoded_rf[test_index_rf],
+        )
+        t_train_rf = safe_indexer(T_rf, train_index_rf)
+        t_test_rf = safe_indexer(T_rf, test_index_rf)
+
+        groups_test_rf = groups_rf[test_index_rf]
+
+        actinet_classifier.fit(
+            X_train_actinet,
+            y_train_actinet,
+            groups_train_actinet,
+            t_train_actinet,
+            weights_path.format(fold),
+            n_splits=5,
+        )
+        y_pred_actinet = actinet_classifier.predict(
+            X_test_actinet, True, t_test_actinet
+        ).astype(int)
+
+        # Analysis of accelerometer random forest model
+        rf_classifier.fit(
+            X_train_rf,
+            y_train_rf,
+        )
+
+        hmm_rf = HMM()
+        hmm_rf.fit(
+            rf_classifier.oob_decision_function_,
+            y_train_rf,
+            t_train_rf,
+            WINSEC,
+        )
+        y_pred_rf = hmm_rf.predict(rf_classifier.predict(X_test_rf), t_test_rf, WINSEC)
+
+        # Display model performance for each fold
+        if verbose:
+            print(
+                f"Actinet test scores for fold {fold+1}\n"
+                + f"Accuracy: {accuracy_score(y_test_actinet, y_pred_actinet):.3f}, "
+                + f"Macro F1: {f1_score(y_test_actinet, y_pred_actinet, average='macro'):.3f}, "
+                + f"Kappa: {cohen_kappa_score(y_test_actinet, y_pred_actinet):.3f}"
+            )
+            print(
+                f"Accelerometer test scores for fold {fold+1}\n"
+                + f"Accuracy: {accuracy_score(y_test_rf, y_pred_rf):.3f}, "
+                + f"Macro F1: {f1_score(y_test_rf, y_pred_rf, average='macro'):.3f}, "
+                + f"Kappa: {cohen_kappa_score(y_test_rf, y_pred_rf):.3f}"
+            )
+
+        Y_preds_actinet[test_index_actinet] = y_pred_actinet
+        Y_preds_rf[test_index_rf] = y_pred_rf
+
+        results_actinet.append(
+            {
+                "fold": [fold] * len(y_pred_actinet),
+                "group": groups_test_actinet,
+                "Y_pred": le.inverse_transform(y_pred_actinet),
+                "Y_true": le.inverse_transform(y_test_actinet),
+            }
+        )
+        results_rf.append(
+            {
+                "fold": [fold] * len(y_pred_rf),
+                "group": groups_test_rf,
+                "Y_pred": le.inverse_transform(y_pred_rf),
+                "Y_true": le.inverse_transform(y_test_rf),
+            }
+        )
+
+    Y_preds_actinet = le.inverse_transform(Y_preds_actinet)
+    Y_preds_rf = le.inverse_transform(Y_preds_rf)
+
+    # Report performance across all folds
+    if verbose:
+        print("Actinet performance:")
+        print(classification_report(Y_actinet, Y_preds_actinet))
+        print("Accelerometer performance:")
+        print(classification_report(Y_rf, Y_preds_rf))
+
+    # Save results to pickle files
+    results_actinet = pd.DataFrame(results_actinet)
+    results_rf = pd.DataFrame(results_rf)
+
+    if out_dir is not None:
+        os.makedirs(out_dir, exist_ok=True)
+        results_actinet.to_pickle(f"{out_dir}/actinet_results.pkl")
+        results_rf.to_pickle(f"{out_dir}/rf_results.pkl")
+
+    return results_actinet, results_rf

{actinet-0.0.dev5 → actinet-0.0.dev6}/src/actinet/hmm.py

@@ -27,31 +27,29 @@ class HMM:
             "Hidden Markov Model\n"
             "prior: {prior}\n"
             "emission: {emission}\n"
-            "transition: {transition}\n"
-            "labels: {labels}".format(
+            "transition: {transition}".format(
                 prior=self.prior,
                 emission=self.emission,
                 transition=self.transition,
-                labels=self.labels,
             )
         )
 
-    def train(self, y_prob, y_true, t=None, interval=None):
+    def fit(self, Y_prob, Y_true, T=None, interval=None):
         """https://en.wikipedia.org/wiki/Hidden_Markov_model
-        :param y_prob: Observation probabilities
-        :param y_true: Ground truth labels
+        :param Y_prob: Observation probabilities
+        :param Y_true: Ground truth labels
         """
 
         if self.labels is None:
-            self.labels = np.unique(y_true)
+            self.labels = np.unique(Y_true)
 
-        prior = np.mean(y_true.reshape(-1, 1) == self.labels, axis=0)
+        prior = np.mean(Y_true.reshape(-1, 1) == self.labels, axis=0)
 
         emission = np.vstack(
-            [np.mean(y_prob[y_true == label], axis=0) for label in self.labels]
+            [np.mean(Y_prob[Y_true == label], axis=0) for label in self.labels]
         )
 
-        transition = calculate_transition_matrix(y_true, t, interval)
+        transition = calculate_transition_matrix(Y_true, T, interval)
 
         self.prior = prior
         self.emission = emission
@@ -193,4 +191,9 @@ def calculate_transition_matrix(Y, t=None, interval=None):
     trans_mat = df.groupby([0, "shift"]).count().unstack().fillna(0)
 
     # normalise by occurences and save values to get the transition matrix
-    return trans_mat.div(trans_mat.sum(axis=1), axis=0).values
+    trans_mat = trans_mat.div(trans_mat.sum(axis=1), axis=0).values
+
+    if trans_mat.size == 0:
+        raise Exception("No transitions found in data")
+
+    return trans_mat