Updated models added

A12/A12_classifier.py

@@ -0,0 +1,579 @@
+# Recognizing Start and Stop Positions
+
+# Imports
+import os
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from pathlib import Path
+
+from sklearn.model_selection import StratifiedKFold, train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import (confusion_matrix, classification_report,
+                             precision_score, recall_score, f1_score,
+                             roc_auc_score, average_precision_score)
+from sklearn.utils.class_weight import compute_class_weight
+
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers, regularizers
+
+
+# Paths
+DATA_DIR    = Path(os.getcwd()) / 'classification_data'
+RESULTS_DIR = Path(os.getcwd()) / 'A12_results'
+RESULTS_DIR.mkdir(exist_ok=True)
+CSV_PATH = DATA_DIR / 'not_cut_classification_data.csv'
+
+
+# Joint and feature definitions
+
+JOINTS = [
+    'head', 'left_shoulder', 'left_elbow', 'right_shoulder', 'right_elbow',
+    'left_hand', 'right_hand', 'left_hip', 'right_hip',
+    'left_knee', 'right_knee', 'left_foot', 'right_foot'
+]
+
+# Problem A — Kinect 3D: x,y,z 39 features
+KINECT_COLS = []
+for j in JOINTS:
+    KINECT_COLS += [f'{j}_x', f'{j}_y', f'{j}_z']
+
+# Problem B — PoseNet 2D: x,y  26 features
+POSENET_COLS = []
+for j in JOINTS:
+    POSENET_COLS += [f'{j}_x', f'{j}_y']
+
+
+EXTRA_COLS = [
+    'left_hand_to_left_shoulder', 'right_hand_to_right_shoulder',
+    'left_hand_to_left_hip', 'right_hand_to_right_hip',
+    'left_elbow_to_left_shoulder', 'right_elbow_to_right_shoulder',
+    'head_to_hip',
+    'head_vx', 'head_vy', 'head_vz', 'head_speed',
+    'left_hand_vx', 'left_hand_vy', 'left_hand_vz', 'left_hand_speed',
+    'right_hand_vx', 'right_hand_vy', 'right_hand_vz', 'right_hand_speed',
+    'head_ax', 'head_ay', 'head_az', 'head_accel',
+    'left_hand_ax', 'left_hand_ay', 'left_hand_az', 'left_hand_accel',
+    'right_hand_ax', 'right_hand_ay', 'right_hand_az', 'right_hand_accel',
+]
+
+# Columns NOT used as features
+META_COLS = ['FrameNo', 'file_id', 'is_not_cut', 'label']
+
+# Label mapping
+LABEL_MAP = {'neutral': 0, 'start': 1, 'stop': 2}
+LABEL_NAMES = ['neutral', 'start', 'stop']
+
+
+# Load and examine data
+
+print("\nLoading data")
+raw_df = pd.read_csv(str(CSV_PATH))
+raw_df.columns = raw_df.columns.str.strip()
+
+print(f"Total frames: {len(raw_df)}")
+print(f"\nLabel distribution:")
+label_counts = raw_df['label'].value_counts()
+for label, count in label_counts.items():
+    pct = count / len(raw_df) * 100
+    print(f"  {label:10s}: {count:6d} ({pct:.2f}%)")
+
+# Convert string labels to integers
+raw_df['label_int'] = raw_df['label'].map(LABEL_MAP)
+
+print("Transforming to Binary: Exercise (1) vs Non-Exercise (0)...")
+raw_df['label_binary'] = 0
+for file_id in raw_df['file_id'].unique():
+    mask = raw_df['file_id'] == file_id
+    # Find the rows where this specific video starts and stops
+    start_idx = raw_df.index[mask & (raw_df['label'] == 'start')]
+    stop_idx = raw_df.index[mask & (raw_df['label'] == 'stop')]
+    
+    if len(start_idx) > 0 and len(stop_idx) > 0:
+        # Mark every frame BETWEEN start and stop as 1
+        raw_df.loc[start_idx[0] : stop_idx[-1], 'label_binary'] = 1
+
+# Overwrite the target variable to use our new binary labels
+raw_df['label_int'] = raw_df['label_binary']
+LABEL_NAMES = ['non-exercise', 'exercise']
+
+# Prepare features for Problem A and B
+
+def prepare_features(df, problem='A', use_extra=True):
+    if problem == 'A':
+        base_cols = KINECT_COLS      # 39 features
+    else:
+        base_cols = POSENET_COLS     
+
+    feat_cols = [c for c in base_cols if c in df.columns]
+
+    if use_extra:
+        extra = [c for c in EXTRA_COLS if c in df.columns]
+        feat_cols = feat_cols + extra
+
+    X = df[feat_cols].values.astype(np.float32)
+    y = df['label_int'].values.astype(np.int32)
+
+    print(f"\nProblem {problem}:")
+    print(f"  Features: {len(feat_cols)}")
+    print(f"  Samples : {len(X)}")
+
+    return X, y, feat_cols
+
+
+# Prepare both problems
+X_A, y_A, cols_A = prepare_features(raw_df, problem='A', use_extra=True)
+X_B, y_B, cols_B = prepare_features(raw_df, problem='B', use_extra=True)
+
+# Split train/test 
+
+def initial_split(X, y, test_size=0.1, random_state=42):
+    X_trainval, X_test, y_trainval, y_test = train_test_split(
+        X, y,
+        test_size=test_size,
+        random_state=random_state,
+        stratify=y   
+    )
+    print(f"Train+Val: {len(X_trainval)} frames")
+    print(f"Test     : {len(X_test)} frames")
+    return X_trainval, X_test, y_trainval, y_test
+
+print("\nSplitting Problem A:")
+X_A_tv, X_A_test, y_A_tv, y_A_test = initial_split(X_A, y_A)
+
+print("\nSplitting Problem B:")
+X_B_tv, X_B_test, y_B_tv, y_B_test = initial_split(X_B, y_B)
+
+
+# Resampling 
+
+def create_sequences(X, y, window_size=30):
+    Xs, ys = [], []
+    for i in range(len(X) - window_size + 1):
+        Xs.append(X[i:(i + window_size)])
+        ys.append(y[i + window_size - 1])
+    
+    return np.array(Xs), np.array(ys)
+    
+    
+def compute_class_weights(y):
+    classes = np.unique(y)
+    weights = compute_class_weight('balanced', classes=classes, y=y)
+    weight_dict = dict(zip(classes.tolist(), weights.tolist()))
+    print(f"\nClass weights (higher = rarer = more important):")
+    for cls, w in weight_dict.items():
+        print(f"  {LABEL_NAMES[cls]:10s} (class {cls}): {w:.2f}x")
+    return weight_dict
+
+
+def oversample_minority(X, y, random_state=42):
+    rng = np.random.default_rng(random_state)
+
+    n_neutral = (y == 0).sum()
+    n_start   = (y == 1).sum()
+    n_stop    = (y == 2).sum()
+
+    print(f"\nBefore oversampling: neutral={n_neutral} start={n_start} stop={n_stop}")
+
+    # Oversample start frames to match neutral count
+    start_idx = np.where(y == 1)[0]
+    stop_idx  = np.where(y == 2)[0]
+
+    n_copies_start = n_neutral // n_start
+    n_copies_stop  = n_neutral // n_stop
+
+    # Repeat indices
+    start_oversampled = np.tile(start_idx, n_copies_start)
+    stop_oversampled  = np.tile(stop_idx,  n_copies_stop)
+
+    # Combine with original data
+    all_idx = np.concatenate([
+        np.where(y == 0)[0],   # all neutral frames
+        start_oversampled,      # repeated start frames
+        stop_oversampled        # repeated stop frames
+    ])
+
+    # Shuffle
+    rng.shuffle(all_idx)
+
+    X_resampled = X[all_idx]
+    y_resampled = y[all_idx]
+
+    n_neutral_new = (y_resampled == 0).sum()
+    n_start_new   = (y_resampled == 1).sum()
+    n_stop_new    = (y_resampled == 2).sum()
+
+    print(f"After oversampling:  neutral={n_neutral_new} "
+          f"start={n_start_new} stop={n_stop_new}")
+
+    return X_resampled, y_resampled
+
+
+# Compute class weights for training
+class_weights_A = compute_class_weights(y_A_tv)
+class_weights_B = compute_class_weights(y_B_tv)
+
+
+# Define network architectures
+
+def build_dense(input_dim, hidden_units=(128, 64),
+                activation='relu', dropout_rate=0.2,
+                l2_reg=1e-4, n_classes=2, name='Dense'):
+    
+    inputs = keras.Input(shape=(input_dim,), name='input')
+    x = inputs
+
+    for i, units in enumerate(hidden_units):
+        x = layers.Dense(
+            units, activation=activation,
+            kernel_regularizer=regularizers.l2(l2_reg) if l2_reg else None,
+            name=f'dense_{i+1}'
+        )(x)
+        x = layers.Dropout(dropout_rate, name=f'drop_{i+1}')(x)
+
+    # softmax = probability per class (must sum to 1)
+    outputs = layers.Dense(n_classes, activation='softmax',
+                           name='output')(x)
+    return keras.Model(inputs, outputs, name=name)
+
+
+def build_conv1d(input_dim, window_size=30,
+                 filters=(64, 128), kernel_size=3,
+                 dense_units=(64,), dropout_rate=0.2,
+                 n_classes=2, name='Conv1D'):
+    inputs = keras.Input(shape=(window_size, input_dim), name='input')
+    x = inputs
+
+    for i, f in enumerate(filters):
+        x = layers.Conv1D(f, kernel_size, activation='relu',
+                          padding='same', name=f'conv_{i+1}')(x)
+        x = layers.MaxPooling1D(2, padding='same', name=f'pool_{i+1}')(x)
+        x = layers.Dropout(dropout_rate, name=f'drop_conv_{i+1}')(x)
+
+    x = layers.GlobalAveragePooling1D(name='gap')(x)
+
+    for i, units in enumerate(dense_units):
+        x = layers.Dense(units, activation='relu', name=f'fc_{i+1}')(x)
+        x = layers.Dropout(dropout_rate, name=f'drop_fc_{i+1}')(x)
+
+    outputs = layers.Dense(n_classes, activation='softmax', name='output')(x)
+    return keras.Model(inputs, outputs, name=name)
+
+
+def build_lstm(input_dim, window_size=30,
+               lstm_units=(64, 32), dense_units=(32,),
+               dropout_rate=0.2, n_classes=2, name='LSTM'):
+    inputs = keras.Input(shape=(window_size, input_dim), name='input')
+    x = inputs
+    for i, u in enumerate(lstm_units):
+        rs = (i < len(lstm_units) - 1)
+        x = layers.LSTM(u, return_sequences=rs,
+                        dropout=dropout_rate, name=f'lstm_{i+1}')(x)
+    for i, u in enumerate(dense_units):
+        x = layers.Dense(u, activation='relu', name=f'fc_{i+1}')(x)
+        x = layers.Dropout(dropout_rate, name=f'drop_{i+1}')(x)
+    outputs = layers.Dense(n_classes, activation='softmax', name='output')(x)
+    return keras.Model(inputs, outputs, name=name)
+
+
+def build_gru(input_dim, window_size=30,
+              gru_units=(64, 32), dense_units=(32,),
+              dropout_rate=0.2, n_classes=2, name='GRU'):
+    inputs = keras.Input(shape=(window_size, input_dim), name='input')
+    x = inputs
+    for i, u in enumerate(gru_units):
+        rs = (i < len(gru_units) - 1)
+        x = layers.GRU(u, return_sequences=rs,
+                       dropout=dropout_rate, name=f'gru_{i+1}')(x)
+    for i, u in enumerate(dense_units):
+        x = layers.Dense(u, activation='relu', name=f'fc_{i+1}')(x)
+        x = layers.Dropout(dropout_rate, name=f'drop_{i+1}')(x)
+    outputs = layers.Dense(n_classes, activation='softmax', name='output')(x)
+    return keras.Model(inputs, outputs, name=name)
+
+
+# Compile the model
+
+def compile_model(model, optimizer='adam', lr=1e-3):
+    opt_map = {
+        'adam':    keras.optimizers.Adam(learning_rate=lr),
+        'rmsprop': keras.optimizers.RMSprop(learning_rate=lr),
+        'sgd':     keras.optimizers.SGD(learning_rate=lr, momentum=0.9),
+    }
+    opt = opt_map.get(optimizer, keras.optimizers.Adam(lr))
+
+    model.compile(
+        optimizer=opt,
+        loss='sparse_categorical_crossentropy',
+        metrics=[
+            'accuracy'
+        ]
+    )
+    return model
+
+
+# Cross-Validation
+
+def run_10fold_cv(X_trainval, y_trainval, X_test, y_test,
+                  build_fn, input_dim, optimizer, batch_size,
+                  class_weights, problem_name, arch_name,
+                  use_oversampling=True, n_folds=3):
+    run_name = f"{problem_name}_{arch_name}_{optimizer}_bs{batch_size}"
+    print(f"  {run_name}  ({n_folds}-fold CV)")
+
+    skf = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=42)
+
+    fold_metrics = []
+    best_val_f1  = -1
+    best_model   = None
+    best_scaler  = None
+
+    for fold_idx, (tr_idx, val_idx) in enumerate(
+            skf.split(X_trainval, y_trainval)):
+
+        print(f"\n  Fold {fold_idx+1}/{n_folds}", end='  ')
+
+        X_tr, X_val = X_trainval[tr_idx], X_trainval[val_idx]
+        y_tr, y_val = y_trainval[tr_idx], y_trainval[val_idx]
+
+        if use_oversampling:
+            X_tr, y_tr = oversample_minority(X_tr, y_tr,
+                                             random_state=42 + fold_idx)
+
+        is_seq = any(n in arch_name for n in ['Conv1D', 'LSTM', 'GRU'])
+        
+        if is_seq:
+            X_tr, y_tr = create_sequences(X_tr, y_tr, window_size=30)
+            X_val, y_val = create_sequences(X_val, y_val, window_size=30)
+
+            scaler = StandardScaler()
+            N, W, F = X_tr.shape
+            X_tr_sc = scaler.fit_transform(X_tr.reshape(-1, F)).reshape(N, W, F)
+            X_val_sc = scaler.transform(X_val.reshape(-1, F)).reshape(-1, W, F)
+        else:
+            scaler = StandardScaler()
+            X_tr_sc = scaler.fit_transform(X_tr)
+            X_val_sc = scaler.transform(X_val)
+
+        model = build_fn(input_dim)
+        model = compile_model(model, optimizer=optimizer, lr=1e-3)
+
+        early_stop = keras.callbacks.EarlyStopping(
+            monitor='val_loss',
+            patience=10,
+            restore_best_weights=True,
+            verbose=0
+        )
+
+        history = model.fit(
+            X_tr_sc, y_tr,
+            validation_data=(X_val_sc, y_val),
+            epochs=100,
+            batch_size=batch_size,
+            class_weight=class_weights,  # handle imbalance
+            callbacks=[early_stop],
+            verbose=0
+        )
+
+        y_pred = np.argmax(model.predict(X_val_sc, verbose=0), axis=1)
+
+        # Calculate metrics for the 'Exercise' class (1)
+        f1_ex = f1_score(y_val, y_pred, pos_label=1, zero_division=0)
+        p_ex = precision_score(y_val, y_pred, pos_label=1, zero_division=0)
+        r_ex = recall_score(y_val, y_pred, pos_label=1, zero_division=0)
+
+        print(f"EXERCISE F1={f1_ex:.3f} P={p_ex:.3f} R={r_ex:.3f} epochs={len(history.history['loss'])}")
+
+        fold_metrics.append({
+            'fold': fold_idx + 1,
+            'f1': f1_ex, 'p': p_ex, 'r': r_ex,
+            'epochs': len(history.history['loss']),
+        })
+
+        if f1_ex > best_val_f1:
+            best_val_f1 = f1_ex
+            best_model  = model
+            best_scaler = scaler
+
+    fold_df = pd.DataFrame(fold_metrics)
+    avg = fold_df.mean(numeric_only=True)
+
+    print(f"\n  {n_folds}-FOLD AVERAGE:")
+    print(f"  EXERCISE -> P:{avg['p']:.3f} R:{avg['r']:.3f} F1:{avg['f1']:.3f}")
+    print(f"  Avg epochs: {avg['epochs']:.1f}")
+
+
+    print(f"\n  FINAL TEST SET EVALUATION (held-out 10%):")
+    # 1. Prepare test data 
+    X_test_final = X_test
+    y_test_final = y_test
+    
+    # Check if the BEST model was a sequence model
+    is_seq = any(n in arch_name for n in ['Conv1D', 'LSTM', 'GRU'])
+
+    if is_seq:
+        # Turn test data into sequences
+        X_test_final, y_test_final = create_sequences(X_test, y_test, window_size=30)
+        # Scale 3D data (Flatten -> Transform -> Reshape)
+        Nt, Wt, Ft = X_test_final.shape
+        X_test_sc = best_scaler.transform(X_test_final.reshape(-1, Ft)).reshape(Nt, Wt, Ft)
+    else:
+        # Standard 2D scaling
+        X_test_sc = best_scaler.transform(X_test_final).astype(np.float32)
+
+    # 2. Predict using the best model
+    y_pred_test = np.argmax(best_model.predict(X_test_sc, verbose=0), axis=1)
+
+    # 3. Report
+    print(classification_report(
+        y_test_final, y_pred_test,
+        target_names=LABEL_NAMES, digits=3
+    ))
+
+    assess_frame_offset(y_test_final, y_pred_test, problem_name)
+
+    # 4. Save best model
+    best_model.save_weights(str(RESULTS_DIR / f'{run_name}.weights.h5'))
+    
+    import joblib
+    joblib.dump(best_scaler, str(RESULTS_DIR / f'{run_name}_scaler.pkl'))
+
+    return {
+        'run':          run_name,
+        'problem':      problem_name,
+        'architecture': arch_name,
+        'optimizer':    optimizer,
+        'batch_size':   batch_size,
+        'avg_f1':       avg['f1'],
+        'avg_p':        avg['p'],
+        'avg_r':        avg['r'],
+        'avg_epochs':   avg['epochs'],
+        'test_f1':      f1_score(y_test_final, y_pred_test, pos_label=1, zero_division=0)
+    }
+
+
+#  Frame offset analysis
+
+def assess_frame_offset(y_true, y_pred, problem_name):
+    true_starts = [i for i in range(1, len(y_true)) if y_true[i-1]==0 and y_true[i]==1]
+    pred_starts = [i for i in range(1, len(y_pred)) if y_pred[i-1]==0 and y_pred[i]==1]
+    true_stops  = [i for i in range(1, len(y_true)) if y_true[i-1]==1 and y_true[i]==0]
+    pred_stops  = [i for i in range(1, len(y_pred)) if y_pred[i-1]==1 and y_pred[i]==0]
+
+    print(f"\n  Frame Offset ({problem_name}):")
+    for label, tp, pp in [('START', true_starts, pred_starts),
+                           ('STOP',  true_stops,  pred_stops)]:
+        pp = np.array(pp)
+        if len(pp) > 0 and len(tp) > 0:
+            offs = [abs(t - pp[np.argmin(np.abs(pp - t))]) for t in tp]
+            avg  = np.mean(offs)
+            print(f"    {label}: avg={avg:.1f} frames = {avg/30:.2f}s at 30fps")
+        else:
+            print(f"    {label}: {len(tp)} true, {len(pp)} predicted")
+
+
+# Training configurations to test
+
+
+# Architecture variants 
+def make_architectures(input_dim):
+    return {
+        'Dense_relu':   lambda d: build_dense(
+            d, hidden_units=(128, 64), activation='relu', dropout_rate=0.2, n_classes=2),
+        'Conv1D':       lambda d: build_conv1d(
+            d, window_size=30, filters=(64, 128), dropout_rate=0.2, n_classes=2),
+        'LSTM':         lambda d: build_lstm(
+            d, window_size=30, lstm_units=(64, 32), dropout_rate=0.2, n_classes=2),
+        'GRU':          lambda d: build_gru(
+            d, window_size=30, gru_units=(64, 32), dropout_rate=0.2, n_classes=2),
+    }
+
+OPTIMIZERS  = ['adam', 'rmsprop']  
+BATCH_SIZES = [32, 64]              
+
+all_results = []
+
+
+# Problem A (Kinect 39 features) and Problem B (PoseNet 26 features)
+
+print("PROBLEM A: Kinect (x,y,z) - 39 features")
+
+archs_A = make_architectures(X_A.shape[1])
+
+for arch_name, build_fn in archs_A.items():
+    for opt in OPTIMIZERS:
+        for bs in BATCH_SIZES:
+            result = run_10fold_cv(
+                X_trainval=X_A_tv, y_trainval=y_A_tv,
+                X_test=X_A_test,   y_test=y_A_test,
+                build_fn=build_fn, input_dim=X_A.shape[1],
+                optimizer=opt, batch_size=bs,
+                class_weights=class_weights_A,
+                problem_name='A_Kinect', arch_name=arch_name,
+                use_oversampling=False, n_folds=3
+            )
+            all_results.append(result)
+
+
+print("PROBLEM B: PoseNet (x,y) — 26 features")
+
+archs_B = make_architectures(X_B.shape[1])
+
+for arch_name, build_fn in archs_B.items():
+    for opt in OPTIMIZERS:
+        for bs in BATCH_SIZES:
+            result = run_10fold_cv(
+                X_trainval=X_B_tv, y_trainval=y_B_tv,
+                X_test=X_B_test,   y_test=y_B_test,
+                build_fn=build_fn, input_dim=X_B.shape[1],
+                optimizer=opt, batch_size=bs,
+                class_weights=class_weights_B,
+                problem_name='B_PoseNet', arch_name=arch_name,
+                use_oversampling=False, n_folds=3
+            )
+            all_results.append(result)
+
+
+# Final results table and comparison
+
+results_df = pd.DataFrame(all_results)
+results_df = results_df.sort_values('avg_f1', ascending=False)
+
+print(f"\n{'='*70}")
+print("FINAL RESULTS — All experiments sorted by START F1")
+print(f"{'='*70}")
+print(results_df[['problem','architecture','optimizer','batch_size',
+            'avg_f1','avg_p','avg_r','test_f1','avg_epochs']].to_string(index=False))
+
+results_df.to_csv(str(RESULTS_DIR / 'all_results.csv'), index=False)
+
+# Best per problem
+best_A = results_df[results_df['problem'] == 'A_Kinect'].iloc[0]
+best_B = results_df[results_df['problem'] == 'B_PoseNet'].iloc[0]
+
+print(f"\n{'='*60}")
+print("COMPARISON: Problem A (Kinect) vs Problem B (PoseNet)")
+print(f"{'='*60}")
+print(f"{'Metric':<28} {'Problem A':>12} {'Problem B':>12}")
+print('-' * 55)
+print(f"{'Input features':<28} {X_A.shape[1]:>12} {X_B.shape[1]:>12}")
+print(f"{'Best arch':<28} {best_A['architecture']:>12} {best_B['architecture']:>12}")
+print(f"{'Best optimizer':<28} {best_A['optimizer']:>12} {best_B['optimizer']:>12}")
+print(f"{'CV F1 Score':<28} {best_A['avg_f1']:>12.3f} {best_B['avg_f1']:>12.3f}")
+print(f"{'Test F1 Score':<28} {best_A['test_f1']:>12.3f} {best_B['test_f1']:>12.3f}")
+
+diff = best_A['avg_f1'] - best_B['avg_f1']
+if diff > 0.02:
+    conclusion = (f"Kinect (A) outperforms PoseNet (B) by {diff:.3f} F1. "
+                  f"Depth (z) helps detect start/stop transitions.")
+elif diff < -0.02:
+    conclusion = (f"PoseNet (B) matches Kinect (A). "
+                  f"2D coordinates are sufficient for start/stop detection.")
+else:
+    conclusion = (f"Similar performance (diff={diff:.3f}). "
+                  f"Z coordinate adds minimal value for this task.")
+
+print(f"\nConclusion: {conclusion}")
+print(f"\nAll results saved to: {RESULTS_DIR}")

A12/A12_results/A_Kinect_Dense_relu_adam_bs64.weights.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83f6b716c6b62bcae8d4687396a7cc56f53d5f2adfee7445931875470b5c635c
+size 237656

A12/A12_results/A_Kinect_Dense_relu_adam_bs64_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6889db987986cc2292fa40d0dd9d1bedc6ecd4bbe9ed9a62fd6d2eaec78636ad
+size 2295

A12/A12_results/B_PoseNet_Dense_relu_adam_bs64.weights.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bae1f466ac9c530323f2c5f4f6559fd942b8fc66b4f0ba7eaad25b27b040a697
+size 217688

A12/A12_results/B_PoseNet_Dense_relu_adam_bs64_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:228b9f5c31aa323897666491f4e5d2d6593747172c321174df88310b8e11ff2a
+size 1967

A12/A12_results/all_results.csv

@@ -0,0 +1,33 @@
+run,problem,architecture,optimizer,batch_size,avg_f1,avg_p,avg_r,avg_epochs,test_f1
+A_Kinect_Dense_relu_adam_bs64,A_Kinect,Dense_relu,adam,64,0.9494464599947943,0.9214460305062514,0.9792082771374502,81.33333333333333,0.948843728100911
+A_Kinect_Dense_relu_adam_bs32,A_Kinect,Dense_relu,adam,32,0.9456869648872676,0.912499023021148,0.9814559384840078,72.33333333333333,0.9439775910364145
+B_PoseNet_Dense_relu_adam_bs64,B_PoseNet,Dense_relu,adam,64,0.9378048261537056,0.904321581065244,0.9739900824608375,77.33333333333333,0.9426485922836287
+B_PoseNet_Dense_relu_adam_bs32,B_PoseNet,Dense_relu,adam,32,0.9339650032654129,0.9005934223996852,0.9699763006862895,64.33333333333333,0.9372822299651568
+A_Kinect_Dense_relu_rmsprop_bs64,A_Kinect,Dense_relu,rmsprop,64,0.9329939785956064,0.8998354313884457,0.9687728350144543,54.333333333333336,0.9337517433751743
+A_Kinect_Dense_relu_rmsprop_bs32,A_Kinect,Dense_relu,rmsprop,32,0.9241883767228444,0.8896991181046472,0.9614673315372301,39.0,0.9240374609781478
+B_PoseNet_Dense_relu_rmsprop_bs64,B_PoseNet,Dense_relu,rmsprop,64,0.92234254707232,0.8849348886782392,0.9630727901196078,58.0,0.9268802228412256
+B_PoseNet_Dense_relu_rmsprop_bs32,B_PoseNet,Dense_relu,rmsprop,32,0.9131224832164339,0.8749101516286387,0.9550457098512407,48.666666666666664,0.926589392342817
+A_Kinect_Conv1D_adam_bs32,A_Kinect,Conv1D,adam,32,0.8327652499217123,0.7723062309692167,0.903540830227446,54.333333333333336,0.827928524156188
+A_Kinect_LSTM_adam_bs32,A_Kinect,LSTM,adam,32,0.8267333481597587,0.7655730022118564,0.8985510984777236,31.0,0.8284102223697312
+A_Kinect_Conv1D_adam_bs64,A_Kinect,Conv1D,adam,64,0.8254831613431838,0.7676677219382606,0.8927598635633291,56.0,0.828
+A_Kinect_LSTM_rmsprop_bs32,A_Kinect,LSTM,rmsprop,32,0.8245556169432104,0.7763738854101477,0.8791613296059468,32.666666666666664,0.8262783609888249
+A_Kinect_LSTM_adam_bs64,A_Kinect,LSTM,adam,64,0.820165562705342,0.7639814381131628,0.8856853163721553,30.333333333333332,0.8245033112582781
+A_Kinect_LSTM_rmsprop_bs64,A_Kinect,LSTM,rmsprop,64,0.8186241565131747,0.7765837268721133,0.8658863897021606,34.666666666666664,0.8194957983193277
+A_Kinect_Conv1D_rmsprop_bs32,A_Kinect,Conv1D,rmsprop,32,0.8162964270930465,0.7660058899638699,0.8736933014326329,48.333333333333336,0.8189452468928451
+A_Kinect_GRU_adam_bs32,A_Kinect,GRU,adam,32,0.8156510708745536,0.7560009639125966,0.8856012485523,31.0,0.8136831617402857
+B_PoseNet_Conv1D_adam_bs64,B_PoseNet,Conv1D,adam,64,0.8155099923003636,0.7628939438995047,0.8761039437247238,58.333333333333336,0.8202360876897133
+A_Kinect_Conv1D_rmsprop_bs64,A_Kinect,Conv1D,rmsprop,64,0.8143812370564226,0.7707596646250626,0.8642749804748283,50.666666666666664,0.8276096565793948
+A_Kinect_GRU_adam_bs64,A_Kinect,GRU,adam,64,0.8126466704444959,0.7555510309447894,0.8791644744347374,32.0,0.8141768797615104
+A_Kinect_GRU_rmsprop_bs32,A_Kinect,GRU,rmsprop,32,0.8115159332925455,0.7579717381990746,0.8733711819108877,26.0,0.8090699967137693
+B_PoseNet_Conv1D_adam_bs32,B_PoseNet,Conv1D,adam,32,0.8107344558018864,0.7660752715171834,0.8616292566000517,47.0,0.8203412512546002
+A_Kinect_GRU_rmsprop_bs64,A_Kinect,GRU,rmsprop,64,0.8095376156181283,0.7658202943213573,0.858567656745724,26.0,0.8180277871907828
+B_PoseNet_Conv1D_rmsprop_bs64,B_PoseNet,Conv1D,rmsprop,64,0.7997232193847029,0.7521364518525036,0.8544610097910863,55.333333333333336,0.8146666666666667
+B_PoseNet_LSTM_adam_bs32,B_PoseNet,LSTM,adam,32,0.7996634344878477,0.756430522255528,0.8486763965813681,29.0,0.801762114537445
+B_PoseNet_LSTM_rmsprop_bs32,B_PoseNet,LSTM,rmsprop,32,0.7991433709103725,0.7714179872824435,0.8292050455449416,30.333333333333332,0.8021164021164021
+B_PoseNet_Conv1D_rmsprop_bs32,B_PoseNet,Conv1D,rmsprop,32,0.7964834575250429,0.7602660298789227,0.837082064913138,48.0,0.8092643051771117
+B_PoseNet_GRU_adam_bs32,B_PoseNet,GRU,adam,32,0.7940393366437886,0.7359858464658354,0.863308018929314,31.333333333333332,0.8015899304405433
+B_PoseNet_GRU_rmsprop_bs32,B_PoseNet,GRU,rmsprop,32,0.793993152232214,0.749062435617784,0.8449737041712876,30.333333333333332,0.7962466487935657
+B_PoseNet_GRU_rmsprop_bs64,B_PoseNet,GRU,rmsprop,64,0.7931333036191383,0.7459325424744568,0.8467430404611639,29.333333333333332,0.7970380343318748
+B_PoseNet_LSTM_rmsprop_bs64,B_PoseNet,LSTM,rmsprop,64,0.7919016433571686,0.7518383286396242,0.836921830335339,32.333333333333336,0.8002694509936006
+B_PoseNet_GRU_adam_bs64,B_PoseNet,GRU,adam,64,0.7910667630366844,0.7379220653225212,0.8530220842372742,31.333333333333332,0.7966273187183811
+B_PoseNet_LSTM_adam_bs64,B_PoseNet,LSTM,adam,64,0.7898076918529106,0.737772490491876,0.8497973776809582,22.666666666666668,0.7990591397849462