From 979c05947e56f348df7271ec13661e46317c2b34 Mon Sep 17 00:00:00 2001
From: asyaturhal <asya.turhal@analog.com>
Date: Sat, 3 Feb 2024 01:33:41 +0300
Subject: [PATCH] Add AutoEncoder model

---
 datasets/samplemotordatalimerick.py  | 704 +++++++++++++++++++++++++++
 models/ai85net-autoencoder.py        | 178 +++++++
 notebooks/AutoEncoder_Eval.ipynb     | 560 +++++++++++++++++++++
 policies/qat_policy_autoencoder.yaml |   4 +
 scripts/evaluate_autoencoder.sh      |   2 +
 scripts/train_autoencoder.sh         |   2 +
 utils/autoencoder_eval_utils.py      | 261 ++++++++++
 7 files changed, 1711 insertions(+)
 create mode 100755 datasets/samplemotordatalimerick.py
 create mode 100755 models/ai85net-autoencoder.py
 create mode 100755 notebooks/AutoEncoder_Eval.ipynb
 create mode 100755 policies/qat_policy_autoencoder.yaml
 create mode 100755 scripts/evaluate_autoencoder.sh
 create mode 100755 scripts/train_autoencoder.sh
 create mode 100755 utils/autoencoder_eval_utils.py

diff --git a/datasets/samplemotordatalimerick.py b/datasets/samplemotordatalimerick.py
new file mode 100755
index 000000000..b6bde2805
--- /dev/null
+++ b/datasets/samplemotordatalimerick.py
@@ -0,0 +1,704 @@
+###################################################################################################
+#
+# Copyright (C) 2024 Analog Devices, Inc. All Rights Reserved.
+# This software is proprietary to Analog Devices, Inc. and its licensors.
+#
+###################################################################################################
+"""
+Classes and functions used to create Cork Motor Data Dataset
+"""
+import errno
+import os
+import pickle
+import sys
+import math
+import numpy as np
+from torch.utils.data import Dataset
+from torchvision import transforms
+from numpy.fft import fft
+import pandas as pd
+import torch
+
+import ai8x
+
+from sklearn.preprocessing import QuantileTransformer
+import scipy
+
+
+class SampleMotorDataLimerick(Dataset):
+    """
+    ADXL356C
+    """
+
+    sensor_options = ('ADXL356C') # Order 0 is used for default sensor: ADX365C, do not change order
+    rpm_options = ('all', '0600', '1200', '1800', '2400', '3000') # Order 0 is reserved for 'all' do not change order
+ 
+    sensor_options_sr_Hz = (20000, 4000) # Order 0 is used for default sensor: ADX365C, do not change order
+    sensor_options_file_len_in_sec = (2, 10) # Order 0 is used for default sensor: ADX365C, do not change order
+
+    healthy_file_identifier = '_GoB_GS_BaLo_WA_' # Good Bearing, Good Shaft, Balanced Load and Well Aligned
+
+    cnn_1dinput_len = 256
+
+    num_end_zeros = 10
+    num_start_zeros = 3 
+
+    common_dataframe_columns = ["sensor_identifier", "file_identifier", "raw_data_accel_in_g"]
+
+    train_ratio = 0.8
+
+    @staticmethod
+    def sliding_windows_1d(array, window_size, overlap_ratio):
+        """
+        One dimensional array is windowed and returned in window_size length according to overlap ratio.
+        """
+
+        window_overlap = math.ceil(window_size * overlap_ratio)
+
+        slide_amount = window_size - window_overlap
+        num_of_windows = math.floor((len(array) - window_size) / slide_amount) + 1
+
+        result_list = np.zeros((num_of_windows, window_size))
+
+        for i in range(num_of_windows):
+            start_idx = slide_amount * i
+            end_idx = start_idx + window_size
+            result_list[i] = array[start_idx:end_idx]
+
+        return result_list
+
+    @staticmethod
+    def sliding_windows_on_columns_of_2d(array, window_size, overlap_ratio):
+        """
+        Two dimensional array is windowed and returned in window_size length according to overlap ratio.
+        """
+
+        array_len, num_of_cols = array.shape
+
+        window_overlap = math.ceil(window_size * overlap_ratio)
+        slide_amount = window_size - window_overlap
+        num_of_windows = math.floor((array_len - window_size) / slide_amount) + 1
+
+        result_list = np.zeros((num_of_cols, num_of_windows, window_size))
+
+        for i in range(num_of_cols):
+            result_list[i, :, :] = SampleMotorDataLimerick.sliding_windows_1d(array[:, i], window_size, overlap_ratio)
+
+        return result_list
+
+    @staticmethod
+    def split_file_raw_data(file_raw_data, file_raw_data_fs_in_Hz, duration_in_sec, overlap_ratio):
+        """
+        Raw data is splitted into windowed data.
+        """
+
+        num_of_samples_per_window = int(file_raw_data_fs_in_Hz * duration_in_sec)
+
+        sliding_windows = SampleMotorDataLimerick.sliding_windows_on_columns_of_2d(file_raw_data,
+                                                                    num_of_samples_per_window,
+                                                                    overlap_ratio)
+        return sliding_windows
+
+
+    def process_file_and_return_signal_windows(self, file_raw_data):
+        """
+        Windowed signals are constructed from 2D raw data.
+        Fast Fourier Transform performed on these signals.
+        """
+
+        new_sampling_rate = int(self.selected_sensor_sr / self.downsampling_ratio)
+
+        file_raw_data_sampled = scipy.signal.decimate(file_raw_data, self.downsampling_ratio, axis=0)
+
+        file_raw_data_windows = SampleMotorDataLimerick.split_file_raw_data(file_raw_data_sampled,
+                                                             new_sampling_rate,
+                                                             self.signal_duration_in_sec,
+                                                             self.overlap_ratio)
+
+        # First dimension: 3
+        # Second dimension: number of windows
+        # Third dimension: Window for self.duration_in_sec. 1000 samples for default settings
+        num_features = file_raw_data_windows.shape[0]
+        num_windows = file_raw_data_windows.shape[1]
+        input_window_size = file_raw_data_windows.shape[2]
+
+        fft_output_window_size = SampleMotorDataLimerick.cnn_1dinput_len
+
+        file_cnn_signals = np.zeros((num_features, num_windows, fft_output_window_size))
+
+        # Perform FFT on each window () for each feature
+        for window in range(num_windows):
+            for feature in range(num_features):
+
+                signal_for_fft = file_raw_data_windows[feature, window, :]
+
+                fft_out = abs(fft(signal_for_fft))
+                fft_out = fft_out[:fft_output_window_size]
+
+                fft_out[:SampleMotorDataLimerick.num_start_zeros] = 0
+                fft_out[-SampleMotorDataLimerick.num_end_zeros:] = 0
+
+                file_cnn_signals[feature, window, :] = fft_out
+
+            file_cnn_signals[:, window, :] = file_cnn_signals[:, window, :] / np.sqrt(np.power(file_cnn_signals[:, window, :], 2).sum())
+
+        # Reshape from (num_features, num_windows, window_size) into: (num_windows, num_features, window_size)
+        file_cnn_signals = file_cnn_signals.transpose([1, 0, 2])
+
+        return file_cnn_signals
+
+    @staticmethod
+    def create_common_empty_df():
+        df = pd.DataFrame(columns=SampleMotorDataLimerick.common_dataframe_columns)
+        return df
+
+    @staticmethod
+    def parse_LF300_and_return_common_df_row(file_full_path):
+        # Colums added just for readability can return raw data np array as well, can also add file identifier
+        df_raw = pd.read_csv(file_full_path, sep='\t', header=None, skiprows=(0, 1))
+        df_raw.columns = ["Acceleration_x (g)", "Acceleration_y (g)", "Acceleration_z (g)", "Parsing Artifact"] 
+
+        raw_data = df_raw[["Acceleration_x (g)", "Acceleration_y (g)", "Acceleration_z (g)"]].to_numpy()
+        #SampleMotorDataLimerick.common_dataframe_columns
+        return ['LF300', os.path.basename(file_full_path).split('/')[-1], raw_data]
+
+    @staticmethod
+    def parse_ADXL356C_and_return_common_df_row(file_full_path):
+        # Colums added just for readability can return raw data np array as well, can also add file identifier
+        df_raw = pd.read_csv(file_full_path, sep=';', header=None)
+        df_raw.rename(columns={0: 'Time', 1: 'Voltage_x', 2: 'Voltage_y', 3: 'Voltage_z', 4: 'x', 5: 'y', 6: 'z'}, inplace=True) 
+        ss_vibr_x1 = df_raw.iloc[0]['x']
+        ss_vibr_y1 = df_raw.iloc[0]['y']
+        ss_vibr_z1 = df_raw.iloc[0]['z']
+        df_raw["Acceleration_x (g)"] = 50 * (df_raw["Voltage_x"] - ss_vibr_x1)
+        df_raw["Acceleration_y (g)"] = 50 * (df_raw["Voltage_y"] - ss_vibr_y1)
+        df_raw["Acceleration_z (g)"] = 50 * (df_raw["Voltage_z"] - ss_vibr_z1)
+
+        raw_data = df_raw[["Acceleration_x (g)", "Acceleration_y (g)", "Acceleration_z (g)"]].to_numpy()
+        return ['ADXL356C', os.path.basename(file_full_path).split('/')[-1], raw_data]
+
+    def __makedir_exist_ok(self, dirpath):
+            try:
+                os.makedirs(dirpath)
+            except OSError as e:
+                if e.errno == errno.EEXIST:
+                    pass
+                else:
+                    raise
+
+    def __init__(self, root, d_type, transform=None,
+                 downsampling_ratio=2,
+                 signal_duration_in_sec=0.25,
+                 overlap_ratio=0.75,
+                 eval_mode=False,
+                 label_as_signal=True,
+                 random_or_speed_split=True,
+                 normalization_mode=1,
+                 accel_in_second_dim=True,
+                 sensor_selected=sensor_options,
+                 rpm_selected=rpm_options[0]):
+
+        if d_type not in ('test', 'train'):
+            raise ValueError("d_type can only be set to 'test' or 'train'")
+
+        if normalization_mode not in range(3):
+            raise ValueError(f"Invalid normalization mode value:{normalization_mode}, should have been selected from: {0, 1, 2}")
+
+        if rpm_selected not in SampleMotorDataLimerick.rpm_options:
+            raise ValueError(f"rpm_selected can only be set from: {SampleMotorDataLimerick.rpm_options}")
+
+        if not isinstance(downsampling_ratio, int) or downsampling_ratio < 1:
+            raise ValueError("downsampling_ratio can only be set to an integer value greater than 0")
+
+        self.selected_sensor_sr = SampleMotorDataLimerick.sensor_options_sr_Hz[0]
+
+        self.root = root
+        self.d_type = d_type
+        self.transform = transform
+
+        self.downsampling_ratio = downsampling_ratio
+        self.signal_duration_in_sec = signal_duration_in_sec
+        self.overlap_ratio = overlap_ratio
+
+        self.eval_mode = eval_mode
+        self.label_as_signal = label_as_signal
+
+        self.random_or_speed_split = random_or_speed_split
+        self.normalization_mode = normalization_mode
+        self.accel_in_second_dim = accel_in_second_dim
+
+        self.sensor_selected = sensor_selected
+        self.rpm_selected = rpm_selected
+
+        self.num_of_features = 3
+
+        processed_folder = \
+            os.path.join(root, self.__class__.__name__, 'processed')
+
+        self.__makedir_exist_ok(processed_folder)
+
+        self.specs_identifier = f'eval_mode_{self.eval_mode}_' + \
+                                f'label_as_signal_{self.label_as_signal}_' + \
+                                f'ds_{self.downsampling_ratio}_' + \
+                                f'dur_{self.signal_duration_in_sec}_' + \
+                                f'ovlp_ratio_{self.overlap_ratio}_' + \
+                                f'random_split_{self.random_or_speed_split}_' + \
+                                f'normalization_{self.normalization_mode}_' + \
+                                f'sensor_selected_{self.sensor_selected}_' +\
+                                f'rpm_{self.rpm_selected}' 
+
+        train_dataset_pkl_file_path = \
+            os.path.join(processed_folder, f'train_{self.specs_identifier}.pkl')
+
+        test_dataset_pkl_file_path =  \
+            os.path.join(processed_folder, f'test_{self.specs_identifier}.pkl')
+
+        if self.d_type == 'train':
+            self.dataset_pkl_file_path = train_dataset_pkl_file_path
+
+        elif self.d_type == 'test':
+            self.dataset_pkl_file_path = test_dataset_pkl_file_path
+
+        self.signal_list = []
+        self.lbl_list = []
+
+        self.__create_pkl_files()
+        self.is_truncated = False
+
+    def __create_pkl_files(self):
+        if os.path.exists(self.dataset_pkl_file_path):
+
+            print('\nPickle files are already generated ...\n')
+
+            (self.signal_list, self.lbl_list) = \
+                pickle.load(open(self.dataset_pkl_file_path, 'rb'))
+            return
+
+        self.__gen_datasets()
+    
+    def normalize_signal(self, train_features, test_normal_features, anomaly_features):
+        if(self.normalization_mode == 0): # Global Min Max
+
+            # Normalize data:
+            self.train_features_max = np.max(train_features, axis=0)
+            self.train_features_min = np.min(train_features, axis=0) # (3, 256)
+
+            # Normalize train normal data:
+            for feature in range(train_features.shape[1]):
+                for signal in range(train_features.shape[2]):
+                    train_features[:, feature, signal] = \
+                        (train_features[:, feature, signal] - self.train_features_min[feature, signal]) / \
+                        (self.train_features_max[feature, signal] - self.train_features_min[feature, signal])
+
+            # Normalize test normal data:            
+            for feature in range(test_normal_features.shape[1]):
+                for signal in range(test_normal_features.shape[2]):
+                    test_normal_features[:, feature, signal] = \
+                        (test_normal_features[:, feature, signal] - self.train_features_min[feature, signal]) / \
+                        (self.train_features_max[feature, signal] - self.train_features_min[feature, signal])
+
+            # Normalize anomaly features:
+            for feature in range(anomaly_features.shape[1]):
+                for signal in range(anomaly_features.shape[2]):
+                    anomaly_features[:, feature, signal] = \
+                        (anomaly_features[:, feature, signal] - self.train_features_min[feature, signal]) / \
+                        (self.train_features_max[feature, signal] - self.train_features_min[feature, signal])
+
+        elif(self.normalization_mode == 1): # Local Min Max
+            # Normalize data:
+            for instance in range(train_features.shape[0]):
+                instance_max = np.max(train_features[instance, :, :], axis=1)
+                instance_min = np.min(train_features[instance, :, :], axis=1)
+
+                for feature in range(train_features.shape[1]):
+                    for signal in range(train_features.shape[2]):
+                        train_features[instance, feature, signal] = \
+                            (train_features[instance, feature, signal] - instance_min[feature]) / \
+                            (instance_max[feature] - instance_min[feature])
+
+            # Normalize test normal data:
+            for instance in range(test_normal_features.shape[0]):
+                instance_max = np.max(test_normal_features[instance, :, :], axis=1)
+                instance_min = np.min(test_normal_features[instance, :, :], axis=1)
+
+                for feature in range(test_normal_features.shape[1]):
+                    for signal in range(test_normal_features.shape[2]):
+                        test_normal_features[instance, feature, signal] = \
+                            (test_normal_features[instance, feature, signal] - instance_min[feature]) / \
+                            (instance_max[feature] - instance_min[feature])
+
+            # Normalize anomaly features:
+            for instance in range(anomaly_features.shape[0]):
+                instance_min = np.min(anomaly_features[instance, :, :], axis=1)
+                instance_max = np.max(anomaly_features[instance, :, :], axis=1)
+
+                for feature in range(anomaly_features.shape[1]):
+                    for signal in range(anomaly_features.shape[2]):
+                        anomaly_features[instance, feature, signal] = \
+                            (anomaly_features[instance, feature, signal] - instance_min[feature]) / \
+                            (instance_max[feature] - instance_min[feature])
+
+        elif(self.normalization_mode == 2): # Quantile
+
+            scaler = QuantileTransformer(output_distribution='normal')
+            train_features = scaler.fit_transform(train_features.reshape(train_features.shape[0], -1)).reshape(train_features.shape)
+            train_features = np.clip(train_features, -3, 3)
+            train_features = (train_features + 3) / 6
+
+            test_normal_features = scaler.transform(test_normal_features.reshape(test_normal_features.shape[0], -1)).reshape(test_normal_features.shape)
+            test_normal_features = np.clip(test_normal_features, -3, 3)
+            test_normal_features = (test_normal_features + 3) / 6
+
+            anomaly_features = scaler.transform(anomaly_features.reshape(anomaly_features.shape[0], -1)).reshape(anomaly_features.shape)
+            anomaly_features = np.clip(anomaly_features, -3, 3)
+            anomaly_features = (anomaly_features + 3) / 6
+        else:
+            error_message = "Incorrect normalization mode is selected."
+            raise Exception(error_message)
+
+        return train_features, test_normal_features, anomaly_features
+
+    def __gen_datasets(self):
+        print(f'\nGenerating dataset pickle files from the raw data files (specs identifier: {self.specs_identifier}) ...\n')
+
+        actual_root_dir = os.path.join(self.root, self.__class__.__name__, "SpectraQuest Rig Data Voyager 3/CbM_Testing_Spectraquest/CbM_Testing_Spectraquest/")
+
+        data_dir = os.path.join(actual_root_dir, f'Test_Results_Data_{self.sensor_selected}/')
+
+        selected_rpm_prefixes = SampleMotorDataLimerick.rpm_options[1:] if self.rpm_selected == SampleMotorDataLimerick.rpm_options[0] else self.rpm_selected
+
+        faulty_data_list = []
+        healthy_data_list = []
+
+        df_normals = SampleMotorDataLimerick.create_common_empty_df()
+        df_anormals = SampleMotorDataLimerick.create_common_empty_df()
+
+        for file in os.listdir(data_dir):
+            full_path = os.path.join(data_dir, file)
+
+            if any(file.startswith(rpm_prefix + SampleMotorDataLimerick.healthy_file_identifier) for rpm_prefix in selected_rpm_prefixes):
+
+                if self.sensor_selected == 'ADXL356C':
+                    healthy_row = SampleMotorDataLimerick.parse_ADXL356C_and_return_common_df_row(file_full_path=full_path)
+                
+                if self.sensor_selected == 'LF300':
+                    healthy_row = SampleMotorDataLimerick.parse_LF300_and_return_common_df_row(file_full_path=full_path)
+
+                healthy_data_list.append(healthy_row)
+
+            else:
+
+                if self.sensor_selected == 'ADXL356C':
+                    faulty_row = SampleMotorDataLimerick.parse_ADXL356C_and_return_common_df_row(file_full_path=full_path)
+           
+                if self.sensor_selected == 'LF300':
+                    faulty_row = SampleMotorDataLimerick.parse_LF300_and_return_common_df_row(file_full_path=full_path)
+
+                faulty_data_list.append(faulty_row)
+
+        # Can keep and process those further
+        df_normals = pd.DataFrame(data=np.array(healthy_data_list, dtype=object), columns=SampleMotorDataLimerick.common_dataframe_columns)
+        df_anormals = pd.DataFrame(data=np.array(faulty_data_list,dtype=object), columns=SampleMotorDataLimerick.common_dataframe_columns)
+
+        # LOAD NORMAL FEATURES
+        test_train_idx_max = 4
+        test_train_idx = 0 # 0, 1, 2 : train, 3: test
+
+        train_features = list()
+        test_normal_features = list()
+
+        for _, row in df_normals.iterrows():
+            raw_data = row['raw_data_accel_in_g']
+            cnn_signals = self.process_file_and_return_signal_windows(raw_data)
+
+            if self.random_or_speed_split:
+                num_training = int(SampleMotorDataLimerick.train_ratio * cnn_signals.shape[0])
+
+                for i in range(cnn_signals.shape[0]):
+                    if(i < num_training):
+                        train_features.append(cnn_signals[i])
+                    else:
+                        test_normal_features.append(cnn_signals[i])
+            else:
+
+                if test_train_idx < test_train_idx_max - 1:
+                    for i in range(cnn_signals.shape[0]):
+                        train_features.append(cnn_signals[i])
+                else:
+                    for i in range(cnn_signals.shape[0]):
+                        test_normal_features.append(cnn_signals[i])
+
+                test_train_idx = (test_train_idx + 1) % test_train_idx_max
+
+        train_features = np.asarray(train_features)
+        test_normal_features = np.asarray(test_normal_features)
+
+        anomaly_features = list()
+
+        for _, row in df_anormals.iterrows():
+            raw_data = row['raw_data_accel_in_g']
+            cnn_signals = self.process_file_and_return_signal_windows(raw_data)
+            for i in range(cnn_signals.shape[0]):
+                anomaly_features.append(cnn_signals[i])
+
+        anomaly_features = np.asarray(anomaly_features)
+
+        train_features, test_normal_features, anomaly_features = self.normalize_signal(train_features, test_normal_features, anomaly_features)
+
+        # For eliminating filter effects
+        train_features[:, :, :SampleMotorDataLimerick.num_start_zeros] = 0.5
+        train_features[:, :, -SampleMotorDataLimerick.num_end_zeros:] = 0.5
+
+        test_normal_features[:, :, :SampleMotorDataLimerick.num_start_zeros] = 0.5
+        test_normal_features[:, :, -SampleMotorDataLimerick.num_end_zeros:] = 0.5
+
+        anomaly_features[:, :, :SampleMotorDataLimerick.num_start_zeros] = 0.5
+        anomaly_features[:, :, -SampleMotorDataLimerick.num_end_zeros:] = 0.5
+
+        # ARRANGE TEST-TRAIN SPLIT AND LABELS
+        if self.d_type == 'train':
+            self.lbl_list = [train_features[i, :, :] for i in range(train_features.shape[0])]
+            self.signal_list = [torch.Tensor(label) for label in self.lbl_list]
+            self.lbl_list = list(self.signal_list)
+
+            if not self.label_as_signal:
+                self.lbl_list = np.zeros([len(self.signal_list), 1])
+
+        elif self.d_type == 'test':
+
+            # Testing in training phase includes only normal test samples
+            if not self.eval_mode:
+                test_data = test_normal_features
+            else:
+                test_data = np.concatenate((test_normal_features, anomaly_features), axis=0)
+
+            self.lbl_list = [test_data[i, :, :] for i in range(test_data.shape[0])]
+            self.signal_list = [torch.Tensor(label) for label in self.lbl_list]
+            self.lbl_list = list(self.signal_list)
+
+            if not self.label_as_signal:
+                self.lbl_list = np.concatenate(
+                                    (np.zeros([len(test_normal_features), 1]),
+                                     np.ones([len(anomaly_features), 1])), axis=0)
+        # Save pickle file
+        pickle.dump((self.signal_list, self.lbl_list), open(self.dataset_pkl_file_path, 'wb'))
+
+    def __len__(self):
+        if self.is_truncated:
+            return 1
+        return len(self.signal_list)
+
+    def __getitem__(self, index):
+        if index >= len(self):
+            raise IndexError
+
+        if self.is_truncated:
+            index = 0
+
+        signal = self.signal_list[index]
+        lbl = self.lbl_list[index]
+
+        if self.transform is not None:
+            signal = self.transform(signal)
+
+            if self.label_as_signal:
+                lbl = self.transform(lbl)
+
+        if not self.label_as_signal:
+            lbl = lbl.astype(np.long)    
+        else:
+            lbl = lbl.numpy().astype(np.float32)
+
+        if self.accel_in_second_dim:
+            signal = torch.transpose(signal, 0, 1)
+            lbl = lbl.transpose()
+
+        return signal, lbl
+
+
+def samplemotordatalimerick_get_datasets(data, load_train=True, load_test=True,
+                               downsampling_ratio=10,
+                               signal_duration_in_sec=0.25,
+                               overlap_ratio=0.75,
+                               eval_mode=False,
+                               label_as_signal=True,
+                               random_or_speed_split=True,
+                               normalization_mode=1,
+                               accel_in_second_dim=True,
+                               sensor_selected=SampleMotorDataLimerick.sensor_options,
+                               rpm_selected=SampleMotorDataLimerick.rpm_options[0]):
+    """"
+    Returns Sample Motor Data Limerick Dataset
+    """
+    (data_dir, args) = data
+
+    if load_train:
+        train_transform = transforms.Compose([
+            ai8x.normalize(args=args)
+        ])
+
+        train_dataset = SampleMotorDataLimerick(root=data_dir, d_type='train',
+                                      transform=train_transform,
+                                      downsampling_ratio = downsampling_ratio,
+                                      signal_duration_in_sec=signal_duration_in_sec,
+                                      overlap_ratio=overlap_ratio,
+                                      eval_mode=eval_mode,
+                                      label_as_signal=label_as_signal,
+                                      random_or_speed_split=random_or_speed_split,
+                                      normalization_mode=normalization_mode,
+                                      accel_in_second_dim=accel_in_second_dim,
+                                      sensor_selected=sensor_selected,
+                                      rpm_selected=rpm_selected)
+
+        print(f'Train dataset length: {len(train_dataset)}\n')
+    else:
+        train_dataset = None
+
+    if load_test:
+        test_transform = transforms.Compose([
+            ai8x.normalize(args=args)
+        ])
+
+        test_dataset = SampleMotorDataLimerick(root=data_dir, d_type='test',
+                                     transform=test_transform,
+                                      downsampling_ratio = downsampling_ratio,
+                                      signal_duration_in_sec=signal_duration_in_sec,
+                                      overlap_ratio=overlap_ratio,
+                                      eval_mode=eval_mode,
+                                      label_as_signal=label_as_signal,
+                                      random_or_speed_split=random_or_speed_split,
+                                      normalization_mode=normalization_mode,
+                                      accel_in_second_dim=accel_in_second_dim,
+                                      sensor_selected=sensor_selected,
+                                      rpm_selected=rpm_selected)
+
+        print(f'Test dataset length: {len(test_dataset)}\n')
+    else:
+        test_dataset = None
+
+    return train_dataset, test_dataset
+
+
+def samplemotordatalimerick_get_datasets_for_train(data, load_train=True, load_test=True):
+
+    eval_mode = False   # Test set includes validation normals
+    label_as_signal = True
+
+    selected_sensor_idx = 0 # ADX356
+    signal_duration_in_sec = 0.25
+    overlap_ratio = 0.75
+
+    wanted_sampling_rate_Hz = 2000
+    downsampling_ratio = round(SampleMotorDataLimerick.sensor_options_sr_Hz[selected_sensor_idx] / wanted_sampling_rate_Hz) 
+
+    # ds_ratio = 10,  sr: 20K / 10 = 2000, 0.25 sec window, fft input will have: 500 samples, 
+    # fftout's first 256 samples will be used
+    # cnn input will have 2556 samples
+
+    accel_in_second_dim = True
+
+    random_or_speed_split = True
+
+    normalization_mode = 1 # Local MinMax
+
+    return samplemotordatalimerick_get_datasets(data, load_train, load_test,
+                                      downsampling_ratio=downsampling_ratio,
+                                      signal_duration_in_sec=signal_duration_in_sec,
+                                      overlap_ratio=overlap_ratio,
+                                      eval_mode=eval_mode,
+                                      label_as_signal=label_as_signal,
+                                      normalization_mode=normalization_mode,
+                                      random_or_speed_split=random_or_speed_split,
+                                      accel_in_second_dim=accel_in_second_dim
+    )
+
+
+def samplemotordatalimerick_get_datasets_for_eval_with_anomaly_label(data, load_train=True, load_test=True):
+
+    eval_mode = True   # Test set includes validation normals
+    label_as_signal = False
+
+    selected_sensor_idx = 0 # ADX356
+    signal_duration_in_sec = 0.25
+    overlap_ratio = 0.75
+
+    wanted_sampling_rate_Hz = 2000
+    downsampling_ratio = round(SampleMotorDataLimerick.sensor_options_sr_Hz[selected_sensor_idx] / wanted_sampling_rate_Hz) 
+
+    # ds_ratio = 10,  sr: 20K / 10 = 2000, 0.25 sec window, fft input will have: 500 samples, 
+    # fftout's first 256 samples will be used
+    # cnn input will have 2556 samples
+
+    accel_in_second_dim = True
+
+    random_or_speed_split = True
+
+    normalization_mode = 1 # Local MinMax
+
+    return samplemotordatalimerick_get_datasets(data, load_train, load_test,
+                                      downsampling_ratio=downsampling_ratio,
+                                      signal_duration_in_sec=signal_duration_in_sec,
+                                      overlap_ratio=overlap_ratio,
+                                      eval_mode=eval_mode,
+                                      label_as_signal=label_as_signal,
+                                      normalization_mode=normalization_mode,
+                                      random_or_speed_split=random_or_speed_split,
+                                      accel_in_second_dim=accel_in_second_dim
+    )
+
+
+def samplemotordatalimerick_get_datasets_for_eval_with_signal(data, load_train=True, load_test=True):
+
+    eval_mode = True   # Test set includes validation normals
+    label_as_signal = True
+
+    selected_sensor_idx = 0 # ADX356
+    signal_duration_in_sec = 0.25
+    overlap_ratio = 0.75
+
+    wanted_sampling_rate_Hz = 2000
+    downsampling_ratio = round(SampleMotorDataLimerick.sensor_options_sr_Hz[selected_sensor_idx] / wanted_sampling_rate_Hz) 
+
+    # ds_ratio = 10,  sr: 20K / 10 = 2000, 0.25 sec window, fft input will have: 500 samples, 
+    # fftout's first 256 samples will be used
+    # cnn input will have 2556 samples
+
+    accel_in_second_dim = True
+
+    random_or_speed_split = True
+
+    normalization_mode = 1 # Local MinMax
+
+    return samplemotordatalimerick_get_datasets(data, load_train, load_test,
+                                      downsampling_ratio=downsampling_ratio,
+                                      signal_duration_in_sec=signal_duration_in_sec,
+                                      overlap_ratio=overlap_ratio,
+                                      eval_mode=eval_mode,
+                                      label_as_signal=label_as_signal,
+                                      normalization_mode=normalization_mode,
+                                      random_or_speed_split=random_or_speed_split,
+                                      accel_in_second_dim=accel_in_second_dim
+    )
+
+
+datasets = [
+    {
+        'name': 'SampleMotorDataLimerick_ForTrain',
+        'input': (256, 3),
+        'output': ('signal'),
+        'regression': True,
+        'loader': samplemotordatalimerick_get_datasets_for_train,
+    },
+    {
+        'name': 'SampleMotorDataLimerick_ForEvalWithAnomalyLabel',
+        'input': (256, 3),
+        'output': ('normal', 'anomaly'),
+        'loader': samplemotordatalimerick_get_datasets_for_eval_with_anomaly_label,
+    },
+    {
+        'name': 'SampleMotorDataLimerick_ForEvalWithSignal',
+        'input': (256, 3),
+        'output': ('signal'),
+        'loader': samplemotordatalimerick_get_datasets_for_eval_with_signal,
+    }
+]
diff --git a/models/ai85net-autoencoder.py b/models/ai85net-autoencoder.py
new file mode 100755
index 000000000..e66e17e8e
--- /dev/null
+++ b/models/ai85net-autoencoder.py
@@ -0,0 +1,178 @@
+###################################################################################################
+#
+# Copyright (C) 2024 Analog Devices, Inc. All Rights Reserved.
+# This software is proprietary to Analog Devices, Inc. and its licensors.
+#
+###################################################################################################
+"""
+Auto Encoder Network
+"""
+
+from torch import nn
+import numpy as np
+import torch
+
+import ai8x
+
+class CNN_BASE(nn.Module):
+    """
+    Auto Encoder Network
+    """
+    def __init__(self,
+                 num_channels=3,
+                 bias=True,
+                 weight_init="kaiming",
+                 num_classes=0,
+                 **kwargs):
+        super().__init__()
+        
+    def initWeights(self, weight_init="kaiming"):
+        """
+        Auto Encoder Weigth Initilization
+        """
+        weight_init = weight_init.lower()
+        assert weight_init == "kaiming" or weight_init == "xavier" or weight_init == "glorot"
+    
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                if weight_init == "kaiming":
+                    print("Initialising Conv2d weights with Kaiming distribution")
+                    nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                    
+                elif weight_init == "glorot" or weight_init == "xavier":
+                    print("Initialising Conv2d weights with Xavier Glorot distribution")
+                    nn.init.xavier_uniform_(m.weight)
+            
+            elif isinstance(m, nn.ConvTranspose2d):
+                if weight_init == "kaiming":
+                    print("Initialising ConvTranspose2d weights with Kaiming distribution")
+                    nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+    
+                elif weight_init == "glorot" or weight_init == "xavier":
+                    print("Initialising ConvTranspose2d weights with Xavier Glorot distribution")
+                    nn.init.xavier_uniform_(m.weight)
+
+            elif isinstance(m, nn.Linear):
+                if weight_init == "kaiming":
+                    print("Initialising Linear weights with Kaiming distribution")
+                    nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+    
+                elif weight_init == "glorot" or weight_init == "xavier":
+                    print("Initialising Linear weights with Xavier Glorot distribution")
+                    nn.init.xavier_uniform_(m.weight)
+
+
+class AI85AutoEncoder(CNN_BASE):
+    """
+    Neural Network that has depthwise convolutions to reduce input dimensions.
+    Filters work across individual axis data first. 
+    Output of 1D Conv layer is then flattened before being fed to fully connected layers
+    Fully connected layers down sample the data to a bottleneck. This completes the encoder.
+    The decoder is then the same in reverse
+
+    Input Shape: [BATCH_SZ, FFT_LEN, N_AXES] -> [BATCH_SZ, 256, 3] = [N, N_CHANNELS, SIGNAL_LEN]
+    """
+
+    def __init__(self, num_channels=256, dimensions=None, num_classes=1, n_axes=3, bias=True, weight_init="kaiming", batchNorm=True, bottleNeckDim=4, **kwargs):
+
+        super().__init__()
+
+        print("Batchnorm setting in model = ", batchNorm)
+
+        weight_init = weight_init.lower()
+        assert weight_init == "kaiming" or weight_init == "xavier" or weight_init == "glorot"
+
+        # Num channels is equal to the length of FFTs here
+        self.num_channels = num_channels
+        self.n_axes = n_axes
+
+        S = 1
+        P = 0
+
+        # ----- DECODER ----- #
+        # Kernel in 1st layer looks at 1 axis at a time. Output width = input width
+        n_in = num_channels
+        n_out = 128
+        if batchNorm:
+            self.en_conv1 = ai8x.FusedConv1dBNReLU(n_in, n_out, 1, stride=S, padding=P, dilation=1,
+                                               bias=bias, batchnorm='Affine', **kwargs)
+        else:
+            self.en_conv1 = ai8x.FusedConv1dReLU(n_in, n_out, 1, stride=S, padding=P, dilation=1,
+                                               bias=bias, **kwargs)
+        self.layer1_n_in  = n_in
+        self.layer1_n_out = n_out
+
+        # Kernel in 2nd layer looks at 3 axes at once. Output Width = 1. Depth=n_out
+        n_in = n_out
+        n_out = 64
+        if batchNorm:
+            self.en_conv2 = ai8x.FusedConv1dBNReLU(n_in, n_out, 3, stride=S, padding=P, dilation=1,
+                                               bias=bias, batchnorm='Affine', **kwargs)
+        else:
+            self.en_conv2 = ai8x.FusedConv1dReLU(n_in, n_out, 3, stride=S, padding=P, dilation=1,
+                                               bias=bias, **kwargs)
+        self.layer2_n_in  = n_in
+        self.layer2_n_out = n_out
+
+        n_in=n_out
+        n_out=32
+        self.en_lin1 = ai8x.FusedLinearReLU(n_in, n_out, bias=bias, **kwargs)
+        # ----- END OF DECODER ----- #
+
+        # ---- BOTTLENECK ---- # 
+        n_in=n_out
+        self.bottleNeckDim = bottleNeckDim
+        n_out=self.bottleNeckDim
+        self.en_lin2 = ai8x.Linear(n_in, n_out, bias=0, **kwargs)
+        # ---- END OF BOTTLENECK ---- # 
+
+        # ----- ENCODER ----- #
+        n_in=n_out
+        n_out=32
+        self.de_lin1 = ai8x.FusedLinearReLU(n_in, n_out, bias=bias, **kwargs)
+        
+        n_in=n_out
+        n_out=96
+        self.de_lin2 = ai8x.FusedLinearReLU(n_in, n_out, bias=bias, **kwargs)
+
+        n_in=n_out
+        n_out=num_channels*n_axes
+        self.out_lin = ai8x.Linear(n_in, n_out, bias=0, **kwargs)
+        # ----- END OF ENCODER ----- #
+
+        self.initWeights(weight_init)
+
+    def forward(self, x ,return_bottleneck=False):
+        """Forward prop"""
+        x = self.en_conv1(x)
+        x = self.en_conv2(x)
+        x = x.view(x.shape[0], x.shape[1])
+        x = self.en_lin1(x)
+        x = self.en_lin2(x)
+
+        if return_bottleneck:
+            return x
+
+        x = self.de_lin1(x)
+        x = self.de_lin2(x)
+        x = self.out_lin(x)
+        x = x.view(x.shape[0], self.num_channels, self.n_axes)
+
+        return x
+
+
+def ai85autoencoder(pretrained=False, **kwargs):
+    """
+    Constructs an Autoencoder model
+    """
+    assert not pretrained
+    return AI85AutoEncoder(**kwargs)
+
+
+models = [
+    {
+        'name': 'ai85autoencoder',
+        'min_input': 1,
+        'dim': 1,
+    }
+]
diff --git a/notebooks/AutoEncoder_Eval.ipynb b/notebooks/AutoEncoder_Eval.ipynb
new file mode 100755
index 000000000..ccbf38593
--- /dev/null
+++ b/notebooks/AutoEncoder_Eval.ipynb
@@ -0,0 +1,560 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "###################################################################################################\n",
+    "#\n",
+    "# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved.\n",
+    "# This software is proprietary and confidential to Analog Devices, Inc. and its licensors.\n",
+    "#\n",
+    "###################################################################################################\n",
+    "import os\n",
+    "import sys\n",
+    "\n",
+    "import math\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "import importlib\n",
+    "\n",
+    "import matplotlib.patches as patches\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "sys.path.append(os.path.dirname(os.getcwd()))\n",
+    "sys.path.append(os.path.join(os.path.dirname(os.getcwd()), 'models'))\n",
+    "\n",
+    "from datasets import samplemotordatalimerick\n",
+    "\n",
+    "ai85net_autoencoder = __import__(\"ai85net-autoencoder\")\n",
+    "\n",
+    "import parse_qat_yaml\n",
+    "import ai8x\n",
+    "from torch import nn\n",
+    "\n",
+    "from torch.utils import data\n",
+    "\n",
+    "from distiller import apputils\n",
+    "\n",
+    "import seaborn as sns\n",
+    "\n",
+    "from statistics import mean\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from utils import autoencoder_eval_utils as utilsV5\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Configuring device: MAX78000, simulate=False.\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = torch.device(\"cuda:1\" if torch.cuda.is_available() else \"cpu\")\n",
+    "data_path = '/data_ssd/'\n",
+    "simulate = False\n",
+    "\n",
+    "class Args:\n",
+    "    def __init__(self, act_mode_8bit):\n",
+    "        self.act_mode_8bit = act_mode_8bit\n",
+    "        self.truncate_testset = False\n",
+    "\n",
+    "args = Args(act_mode_8bit=simulate)\n",
+    "\n",
+    "ai8x.set_device(device=85, simulate=simulate, round_avg=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Pickle files are already generated ...\n",
+      "\n",
+      "Train dataset length: 230\n",
+      "\n",
+      "\n",
+      "Pickle files are already generated ...\n",
+      "\n",
+      "Test dataset length: 3540\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Generate Dataset For Evaluation\n",
+    "train_set, test_set = samplemotordatalimerick.samplemotordatalimerick_get_datasets_for_eval_with_anomaly_label((data_path, args), load_train=True, load_test=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 32\n",
+    "train_dataloader = data.DataLoader(train_set, batch_size=batch_size, shuffle=True)\n",
+    "test_dataloader = data.DataLoader(test_set, batch_size=batch_size, shuffle=True)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **1. Load Trained AE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Batchnorm setting in model =  True\n",
+      "Initialising Linear weights with Kaiming distribution\n",
+      "Initialising Linear weights with Kaiming distribution\n",
+      "Initialising Linear weights with Kaiming distribution\n",
+      "Initialising Linear weights with Kaiming distribution\n",
+      "Initialising Linear weights with Kaiming distribution\n",
+      "\n",
+      "Number of Model Weights: 136640\n",
+      "Number of Model Bias: 544\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = ai85net_autoencoder.ai85autoencoder()\n",
+    "_ = utilsV5.calc_model_size(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Change this checkpoint file path with your own trained one\n",
+    "checkpoint_path = '../logs/2024.02.02-163128/qat_best.pth.tar' "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'start_epoch': 200, 'weight_bits': 8, 'shift_quantile': 0.995}\n",
+      "Configuring device: MAX78000, simulate=False.\n"
+     ]
+    }
+   ],
+   "source": [
+    "qat_yaml_file_used_in_training = '../policies/qat_policy_autoencoder.yaml'\n",
+    "qat_policy = parse_qat_yaml.parse(qat_yaml_file_used_in_training)\n",
+    "\n",
+    "ai8x.set_device(85, simulate, False)\n",
+    "\n",
+    "# Fuse the BN parameters into conv layers before Quantization Aware Training (QAT)\n",
+    "ai8x.fuse_bn_layers(model)\n",
+    "\n",
+    "# Switch model from unquantized to quantized for QAT\n",
+    "ai8x.initiate_qat(model, qat_policy)\n",
+    "\n",
+    "model = apputils.load_lean_checkpoint(model, checkpoint_path, model_device=device)\n",
+    "ai8x.update_model(model)\n",
+    "\n",
+    "model = model.to(device)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Visualizing whether trained model has good separation the latent space"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "230\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_base_tuple = utilsV5.extract_reconstructions_losses(model, train_dataloader, device)\n",
+    "train_base_reconstructions, train_base_losses, train_base_inputs, train_base_labels = \\\n",
+    "    train_base_tuple\n",
+    "    \n",
+    "    \n",
+    "print(len(train_base_losses))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3540\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_base_tuple = utilsV5.extract_reconstructions_losses(model, test_dataloader, device)\n",
+    "test_base_reconstructions, test_base_losses, test_base_inputs, test_base_labels = \\\n",
+    "    test_base_tuple\n",
+    "    \n",
+    "print(len(test_base_losses))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.08119853245560957"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mean(test_base_losses)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "60\n"
+     ]
+    }
+   ],
+   "source": [
+    "normal_test_sample_idxs = [test_item_idx for test_item_idx, test_item in enumerate(test_set) if test_item[1] == 0]\n",
+    "normal_test_samples = torch.utils.data.Subset(test_set, normal_test_sample_idxs)\n",
+    "normal_test_samples_loader = torch.utils.data.DataLoader(normal_test_samples, batch_size=batch_size)\n",
+    "print(len(normal_test_sample_idxs))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.011125961939493815, 0.013736804326375326, 0.013606866200764975, 0.019563595453898113, 0.021358013153076172, 0.024758259455362957, 0.0259093443552653, 0.017664750417073567, 0.021244525909423828, 0.028273820877075195, 0.024857123692830402, 0.026125987370808918, 0.03290375073750814, 0.02922797203063965, 0.02737704912821452, 0.025388479232788086, 0.019186735153198242, 0.021259148915608723, 0.03011480967203776, 0.029727697372436523, 0.028356313705444336, 0.028255701065063477, 0.025926510492960613, 0.023660659790039062, 0.012727896372477213, 0.010839462280273438, 0.008329947789510092, 0.011519193649291992, 0.017075538635253906, 0.022488832473754883, 0.029181877772013348, 0.03047347068786621, 0.029650211334228516, 0.030732234319051106, 0.024567604064941406, 0.022771596908569336, 0.009392817815144857, 0.011294921239217123, 0.010637362798055014, 0.010720332463582357, 0.009825785954793295, 0.013182322184244791, 0.019329071044921875, 0.021947065989176433, 0.021148125330607098, 0.020935455958048504, 0.017261187235514324, 0.02651357650756836, 0.018658796946207683, 0.017180760701497395, 0.017475128173828125, 0.022461970647176106, 0.028919378916422527, 0.025892337163289387, 0.020049333572387695, 0.03247531255086263, 0.026889801025390625, 0.02540270487467448, 0.035934130350748696, 0.03935011227925619]\n"
+     ]
+    }
+   ],
+   "source": [
+    "normal_base_output = utilsV5.extract_reconstructions_losses(model, normal_test_samples_loader, device)\n",
+    "    \n",
+    "test_base_normal_reconstructions, test_base_normal_losses, \\\n",
+    "test_base_normal_inputs, test_base_normal_labels = normal_base_output\n",
+    "\n",
+    "print(test_base_normal_losses)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3480\n"
+     ]
+    }
+   ],
+   "source": [
+    "anormal_test_sample_idxs = [test_item_idx for test_item_idx, test_item in enumerate(test_set) if test_item[1] == 1]\n",
+    "print(len(anormal_test_sample_idxs))\n",
+    "\n",
+    "anormal_test_samples = torch.utils.data.Subset(test_set, anormal_test_sample_idxs)\n",
+    "anormal_test_samples_loader = torch.utils.data.DataLoader(anormal_test_samples, batch_size=batch_size)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "anormal_base_output = utilsV5.extract_reconstructions_losses(model, anormal_test_samples_loader, device)\n",
+    "    \n",
+    "test_base_anormal_reconstructions, test_base_anormal_losses, \\\n",
+    "test_base_anormal_inputs, test_base_anormal_labels = anormal_base_output"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **2. Determine Reconst. Err. Threshold:** Using 100% percentile on base model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "60% percentile threshold: 0.0181\n",
+      "65% percentile threshold: 0.0192\n",
+      "70% percentile threshold: 0.0205\n",
+      "75% percentile threshold: 0.0218\n",
+      "80% percentile threshold: 0.0225\n",
+      "85% percentile threshold: 0.0238\n",
+      "90% percentile threshold: 0.0256\n",
+      "95% percentile threshold: 0.0277\n",
+      "99% percentile threshold: 0.0316\n",
+      "100% percentile threshold: 0.0346\n"
+     ]
+    }
+   ],
+   "source": [
+    "percentiles = [60, 65, 70, 75, 80, 85, 90, 95, 99, 100]\n",
+    "thresholds = np.percentile(train_base_losses, percentiles)\n",
+    "\n",
+    "for idx, threshold in enumerate(thresholds):\n",
+    "    print(f'{percentiles[idx]}% percentile threshold: {threshold:.4f}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.016639172512552012"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from statistics import mean\n",
+    "mean(train_base_losses)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.02204742564095391"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mean(test_base_normal_losses)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "60"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(test_base_normal_losses)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "F1:  0.9940, BalancedAccuracy:  0.6500, FPR:  0.7000, Precision:  0.9881, TPR (Recall):  1.0000, Accuracy:  0.9881, TRAIN-SET Accuracy:  0.6000\n",
+      "F1:  0.9943, BalancedAccuracy:  0.6667, FPR:  0.6667, Precision:  0.9886, TPR (Recall):  1.0000, Accuracy:  0.9887, TRAIN-SET Accuracy:  0.6478\n",
+      "F1:  0.9946, BalancedAccuracy:  0.6915, FPR:  0.6167, Precision:  0.9895, TPR (Recall):  0.9997, Accuracy:  0.9893, TRAIN-SET Accuracy:  0.7000\n",
+      "F1:  0.9951, BalancedAccuracy:  0.7330, FPR:  0.5333, Precision:  0.9909, TPR (Recall):  0.9994, Accuracy:  0.9904, TRAIN-SET Accuracy:  0.7478\n",
+      "F1:  0.9954, BalancedAccuracy:  0.7579, FPR:  0.4833, Precision:  0.9917, TPR (Recall):  0.9991, Accuracy:  0.9910, TRAIN-SET Accuracy:  0.8000\n",
+      "F1:  0.9951, BalancedAccuracy:  0.7740, FPR:  0.4500, Precision:  0.9923, TPR (Recall):  0.9980, Accuracy:  0.9904, TRAIN-SET Accuracy:  0.8478\n",
+      "F1:  0.9934, BalancedAccuracy:  0.8132, FPR:  0.3667, Precision:  0.9937, TPR (Recall):  0.9931, Accuracy:  0.9870, TRAIN-SET Accuracy:  0.9000\n",
+      "F1:  0.9897, BalancedAccuracy:  0.8670, FPR:  0.2500, Precision:  0.9956, TPR (Recall):  0.9839, Accuracy:  0.9799, TRAIN-SET Accuracy:  0.9478\n",
+      "F1:  0.9762, BalancedAccuracy:  0.9440, FPR:  0.0667, Precision:  0.9988, TPR (Recall):  0.9546, Accuracy:  0.9542, TRAIN-SET Accuracy:  0.9870\n",
+      "F1:  0.9631, BalancedAccuracy:  0.9480, FPR:  0.0333, Precision:  0.9994, TPR (Recall):  0.9293, Accuracy:  0.9299, TRAIN-SET Accuracy:  1.0000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Calculating performance metrics with respect to changing thresholds\n",
+    "F1s, BalancedAccuracies, FPRs, Recalls = utilsV5.sweep_performance_metrics(thresholds, train_base_tuple, test_base_tuple)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 0, 'Reconstruction Loss (RL)')"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(10, 2))\n",
+    "\n",
+    "plt.xlim([0, 0.3])\n",
+    "\n",
+    "sns.histplot(test_base_anormal_losses, element=\"step\", label='RL for Anomalies in Test Set', kde=True)\n",
+    "sns.histplot(test_base_normal_losses, element=\"step\", label='RL for Unseen Normals in Test Set', kde=True)\n",
+    "sns.histplot(train_base_losses, element=\"step\", label='RL for Normals in Training Set', kde=True)\n",
+    "\n",
+    "plt.legend(prop={'size': 9}, loc='best')\n",
+    "plt.xlabel('Reconstruction Loss (RL)')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 3600x1100 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "utilsV5.plot_all_metrics(F1s=F1s, BalancedAccuracies=BalancedAccuracies, FPRs=FPRs, Recalls=Recalls, percentiles=percentiles, thresholds=thresholds)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.8.11 ('venv': venv)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.11"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "f94e0c326c22ca109c8d98fac0e773823a480a04f73c52ef704532a18e9d37e9"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/policies/qat_policy_autoencoder.yaml b/policies/qat_policy_autoencoder.yaml
new file mode 100755
index 000000000..ff3c17aac
--- /dev/null
+++ b/policies/qat_policy_autoencoder.yaml
@@ -0,0 +1,4 @@
+---
+start_epoch: 200
+weight_bits: 8
+shift_quantile: 0.995
diff --git a/scripts/evaluate_autoencoder.sh b/scripts/evaluate_autoencoder.sh
new file mode 100755
index 000000000..f1398c93d
--- /dev/null
+++ b/scripts/evaluate_autoencoder.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+python train.py --deterministic --model ai85autoencoder --dataset SampleMotorDataLimerick_ForEvalWithSignal --regression --device MAX78000 --qat-policy policies/qat_policy_autoencoder.yaml --use-bias --evaluate --exp-load-weights-from ../ai8x-synthesis/trained/ae_cork_localminmax_random_qat-q.pth.tar -8 --print-freq 1 "$@"
diff --git a/scripts/train_autoencoder.sh b/scripts/train_autoencoder.sh
new file mode 100755
index 000000000..dda823d1b
--- /dev/null
+++ b/scripts/train_autoencoder.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+python train.py --deterministic --regression --print-freq 1 --epochs 400 --optimizer Adam --lr 0.001 --wd 0 --model ai85autoencoder --use-bias --dataset SampleMotorDataLimerick_ForTrain --device MAX78000 --batch-size 32 --validation-split 0 --show-train-accuracy full --qat-policy policies/qat_policy_autoencoder.yaml "$@"
\ No newline at end of file
diff --git a/utils/autoencoder_eval_utils.py b/utils/autoencoder_eval_utils.py
new file mode 100755
index 000000000..ce1cd100d
--- /dev/null
+++ b/utils/autoencoder_eval_utils.py
@@ -0,0 +1,261 @@
+###################################################################################################
+#
+# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved.
+# This software is proprietary to Analog Devices, Inc. and its licensors.
+#
+###################################################################################################
+""" Some utility functions for AutoEncoder Models """
+import numpy as np
+import torch
+
+from torch import nn
+import matplotlib.pyplot as plt
+
+import seaborn as sns
+sns.set_style("white")
+
+
+DECAY_FACTOR = 1
+
+def calc_model_size(model):
+    """
+    Returns the model's weight anf bias number.
+    """
+    model.eval()
+    num_weights = 0
+    num_bias = 0
+    for name, param in model.named_parameters():
+        if param.requires_grad:
+            if name.endswith('weight'):
+                num_weights += np.prod(param.size())
+            elif name.endswith('bias'):
+                num_bias += np.prod(param.size())
+
+    print(f'\nNumber of Model Weights: {num_weights}')
+    print(f'Number of Model Bias: {num_bias}\n')
+    return num_weights, num_bias
+
+
+def extract_reconstructions_losses(model, dataloader, device):
+    """
+    Calculates and returns reconstructed signal recontruction loss, input signals
+    and latent space representations for autoencoder model.
+    """
+    model.eval()
+    loss_fn = nn.MSELoss(reduce=False)
+    losses = []
+    reconstructions = []
+    inputs = []
+    labels = []
+    l_representations = []
+
+    with torch.no_grad():
+        for tup in dataloader:
+            if len(tup) == 2:
+                signal, label = tup
+            elif len(tup) == 3:
+                signal, label, _ = tup
+
+            signal = signal.to(device)
+            label = label.type(torch.long).to(device)
+
+            inputs.append(signal)
+            labels.append(label)
+            
+            model_out = model(signal)
+            if isinstance(model_out, tuple):
+                model_out = model_out[0]
+
+            loss = loss_fn(model_out, signal)
+            loss_numpy = loss.cpu().detach().numpy()
+            decay_vector = np.array([DECAY_FACTOR**i for i in range(loss_numpy.shape[2])])
+            decay_vector = np.tile(decay_vector, (loss_numpy.shape[0], loss_numpy.shape[1], 1))
+
+            decayed_loss = loss_numpy * decay_vector
+            losses.extend(decayed_loss.mean(axis=(1,2)))
+            reconstructions.append(model_out)
+
+    return reconstructions, losses, inputs, labels
+
+
+def plot_all_metrics(F1s, BalancedAccuracies, FPRs, Recalls, percentiles, thresholds):
+    """
+    F1, Balanced Accuracy, False Positive Rate metrics are plotted with respect to threshold decided 
+    according to percentiles of training loss in percentile list.
+    """ 
+    fontsize=22
+    linewidth = 4
+
+    fig, axs = plt.subplots(1, 4, figsize=(36, 11))
+
+    axs[0].plot(percentiles, F1s, '-o', linewidth=linewidth)
+    for i, xy in enumerate(zip(percentiles, F1s)):                                       
+        #axs[0].annotate(f"{thresholds[i]: .3f}\n{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2)
+        axs[0].annotate(f"{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2)
+
+    axs[0].grid()
+    #axs[0].set_xlabel('Reconstruction Loss distribution percentile of training samples (%) \n x Coords in Point labels represent percentile value', fontsize=fontsize)
+
+    axs[0].set_title('\nF1 Score on Testset\n\n', fontsize=fontsize + 4, color='#0070C0')
+    axs[0].tick_params(axis='both', which='both', labelsize=fontsize)
+    axs[0].legend(("F1 Score",), loc='lower left', fontsize=fontsize - 2)
+
+    axs[1].plot(percentiles, BalancedAccuracies, '-o', linewidth=linewidth)
+    for i, xy in enumerate(zip(percentiles, BalancedAccuracies)):                                       
+        #axs[1].annotate(f"{thresholds[i]: .3f}\n{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2)
+        axs[1].annotate(f"{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2)
+
+    axs[1].grid()
+    #axs[1].set_xlabel('Reconstruction Loss distribution percentile of training samples (%) \n x Coords in Point labels represent percentile value', fontsize=fontsize)
+
+    axs[1].set_title('\nBalanced Accuracy ((TPR + TNR) / 2) on Testset\n\n', fontsize=fontsize + 4, color='#0070C0')
+    axs[1].tick_params(axis='both', which='both', labelsize=fontsize)
+    axs[1].legend(("Balanced Acc.",), loc='lower left', fontsize=fontsize - 2)
+
+    axs[2].plot(percentiles, FPRs, '-o', linewidth=linewidth)
+    for i, xy in enumerate(zip(percentiles, FPRs)):                                       
+        # axs[2].annotate(f"{thresholds[i]: .3f}\n{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2)
+        axs[2].annotate(f"{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2)
+
+    axs[2].grid()
+    #axs[2].set_xlabel('Reconstruction Loss distribution percentile of training samples (%) \n x Coords in Point labels represent percentile value', fontsize=fontsize)
+
+    axs[2].set_title('\nFalse Positive Rate on Testset\n\n', fontsize=fontsize + 4, color='#0070C0')
+    axs[2].tick_params(axis='both', which='both', labelsize=fontsize)
+    axs[2].legend(("FPR",), loc='lower left', fontsize=fontsize - 2)
+
+
+    axs[3].plot(percentiles, Recalls, '-o', linewidth=linewidth)
+    for i, xy in enumerate(zip(percentiles, Recalls)):                                       
+        # axs[2].annotate(f"{thresholds[i]: .3f}\n{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2)
+        axs[3].annotate(f"{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2)
+
+    axs[3].grid()
+    #axs[2].set_xlabel('Reconstruction Loss distribution percentile of training samples (%) \n x Coords in Point labels represent percentile value', fontsize=fontsize)
+
+    axs[3].set_title('\nTrue Positive Rate on Testset\n\n', fontsize=fontsize + 4, color='#0070C0')
+    axs[3].tick_params(axis='both', which='both', labelsize=fontsize)
+    axs[3].legend(("Recall",), loc='lower left', fontsize=fontsize - 2)
+
+
+    fig.supxlabel('\nReconstruction Loss distribution percentile of training samples (%)', fontsize=fontsize + 4)
+    #fig.suptitle('\n\n')
+
+    plt.tight_layout()
+    plt.show()
+
+
+def sweep_performance_metrics(thresholds, train_tuple, test_tuple):
+    """
+    F1s, BalancedAccuracies, FPRs, Recalls are calculated and returned based on different thresholds.
+    """
+
+    if len(train_tuple) == 4:
+        train_reconstructions, train_losses, train_inputs, train_labels = train_tuple
+    elif len(train_tuple) == 7:
+        train_reconstructions, train_losses, train_inputs, train_labels, train_l_representations, train_l2_representations, train_latent_losses = train_tuple
+
+    if len(test_tuple) == 4:
+        test_reconstructions, test_losses, test_inputs, test_labels = test_tuple
+    elif len(test_tuple) == 7:
+        test_reconstructions, test_losses, test_inputs, test_labels, test_l_representations, test_l2_representations, test_latent_losses = test_tuple
+
+    FPRs = []
+    F1s = []
+    BalancedAccuracies = []
+    Recalls = []
+
+    for threshold in thresholds:
+        FPR, TNR, Recall, Precision, Accuracy, F1, BalancedAccuracy = calc_ae_perf_metrics(test_reconstructions, test_inputs, test_labels, threshold=threshold, print_all=False)
+        FPR_train, TNR_train, Recall_train, Precision_train, Accuracy_train, F1_train, BalancedAccuracy_train = calc_ae_perf_metrics(train_reconstructions, train_inputs, train_labels, threshold=threshold, print_all=False)
+        
+        F1s.append(F1.item())
+        BalancedAccuracies.append(BalancedAccuracy.item())
+        FPRs.append(FPR.item())
+        Recalls.append(Recall.item())
+    
+        print(f"F1: {F1: .4f}, BalancedAccuracy: {BalancedAccuracy: .4f}, FPR: {FPR: .4f}, Precision: {Precision: .4f}, TPR (Recall): {Recall: .4f}, Accuracy: {Accuracy: .4f}, TRAIN-SET Accuracy: {Accuracy_train: .4f}")
+
+    return F1s, BalancedAccuracies, FPRs, Recalls
+
+
+def calc_ae_perf_metrics(reconstructions, inputs, labels, threshold, print_all=True):
+    """
+    FPR, TNR, Recall, Precision, Accuracy, F1, BalancedAccuracy metrics of AutoEncoder are calculated and returned.
+    """
+
+    loss_fn = nn.MSELoss(reduce=False)
+    FP = 0
+    FN = 0
+    TP = 0
+    TN = 0
+    
+    Recall = -1
+    Precision = -1
+    Accuracy = -1
+    F1 = -1
+    FPR = -1
+
+    BalancedAccuracy = -1
+    TNR = -1   # specificity (SPC), selectivity
+    
+    for i in range(len(inputs)):
+        label_batch = labels[i]
+        reconstructions_batch = reconstructions[i]
+        inputs_batch = inputs[i]
+        
+        loss = loss_fn(reconstructions_batch, inputs_batch)
+
+        # Loss Decay
+        loss_numpy = loss.cpu().detach().numpy()
+        decay_vector = np.array([DECAY_FACTOR**i for i in range(loss_numpy.shape[2])])
+        decay_vector = np.tile(decay_vector, (loss_numpy.shape[0], loss_numpy.shape[1], 1))
+        decayed_loss = loss_numpy * decay_vector
+        decayed_loss = torch.Tensor(decayed_loss).to(label_batch.device)
+
+        loss_batch = decayed_loss.mean(dim=(1,2))
+        prediction_batch = loss_batch > threshold
+
+
+        b =  torch.squeeze(torch.logical_not(label_batch))
+        c = b
+
+        TN += torch.sum(torch.logical_and(torch.logical_not(prediction_batch), torch.squeeze(torch.logical_not(label_batch))))
+        TP += torch.sum(torch.logical_and((prediction_batch), torch.squeeze(label_batch)))
+        FN += torch.sum(torch.logical_and(torch.logical_not(prediction_batch), torch.squeeze(label_batch)))
+        FP += torch.sum(torch.logical_and((prediction_batch), torch.squeeze(torch.logical_not(label_batch))))
+
+
+    if TP + FN != 0:
+        Recall = TP / (TP + FN)
+
+    if TP + FP != 0:
+        Precision = TP / (TP + FP)
+
+    Accuracy = (TP + TN) / (TP + TN + FP + FN)
+
+    if (TN + FP) != 0:
+        FPR = FP / (TN + FP)
+        TNR = TN / (TN + FP)
+
+    if Precision + Recall != 0:
+        F1 = 2 * (Precision * Recall) / (Precision + Recall)
+
+    BalancedAccuracy = (Recall + TNR) / 2
+
+    if print_all:
+        print(f"TP: {TP}")
+        print(f"FP: {FP}")
+        print(f"TN: {TN}")
+        print(f"FN: {FN}")
+        print()
+        
+        print(f"FPR: {FPR}")
+        print(f"TNR = Specifity: {TNR}")
+        print(f"TPR (Recall): {Recall}")
+        print(f"Precision: {Precision}")
+        print(f"Accuracy: {Accuracy}")
+        print(f"F1: {F1}")
+        print(f"BalancedAccuracy: {BalancedAccuracy}")
+
+    return FPR, TNR, Recall, Precision, Accuracy, F1, BalancedAccuracy