Skeleton code for prototype.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2241810e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import datetime as dt\n",
    "from IPython.display import display\n",
    "from sklearn.impute import SimpleImputer\n",
    "import os\n",
    "import tensorflow as tf\n",
    "\n",
    "# tf.config.experimental.set_memory_growth(gpus[0], True)\n",
    "\n",
    "# Hide GPU from visible devices\n",
    "#tf.config.set_visible_devices([], 'GPU')\n",
    "\n",
    "class DataPreprocessor:\n",
    "    def __init__(self, filename):\n",
    "        self.filename = filename\n",
    "        self.df = pd.read_csv(self.filename)\n",
    "    \n",
    "    def drop_duplicates(self):\n",
    "        remove_duplicates = input(\"Do you want to remove duplicates? Input T or F \") == \"T\"\n",
    "        if remove_duplicates:\n",
    "            self.df.drop_duplicates(inplace=True)\n",
    "    \n",
    "    def impute_missing(self, method='mean'):\n",
    "        \n",
    "        impute_strategy = input(\"How do you want to impute your missing values? e.g. \\\"median\\\", \\\"0\\\" \" )\n",
    "        imputer = SimpleImputer()\n",
    "        if impute_strategy.isdigit():\n",
    "            imputer = SimpleImputer(strategy='constant', fill_value=int(impute_strategy))\n",
    "        else:\n",
    "            imputer = SimpleImputer(strategy = impute_strategy)\n",
    "        self.df = pd.DataFrame(imputer.fit_transform(self.df), columns=self.df.columns)\n",
    "            \n",
    "    def display_table(self):\n",
    "        display(self.df)\n",
    "        to_csv = input(\"This is your new data file -- do you want to download it? Input T or F \") == \"T\"\n",
    "        if to_csv:\n",
    "            # Get the current timestamp\n",
    "            timestamp = dt.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n",
    "\n",
    "            # Define the output filename\n",
    "            # Split the filename into basename and extension\n",
    "            basename, extension = os.path.splitext(self.filename)\n",
    "            download_filename = f'{basename}_{timestamp}{extension}'\n",
    "\n",
    "            # Download the dataframe to the output file\n",
    "            self.df.to_csv(download_filename, index=False)\n",
    "            \n",
    "    def return_data(self):\n",
    "        return self.df.iloc[:, :-1].values\n",
    "        \n",
    "    def return_labels(self):\n",
    "        return self.df.iloc[:, -1].values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "045249e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "from sklearn.manifold import TSNE\n",
    "\n",
    "class DimensionReduction():\n",
    "    def __init__(self, n_components):\n",
    "        self.model = None\n",
    "        self.n_components = n_components\n",
    "    \n",
    "    def fit_transform(self, data):\n",
    "        pass\n",
    "    \n",
    "class MyPCA(DimensionReduction):\n",
    "    def __init__(self, n_components):\n",
    "        super().__init__(n_components)\n",
    "    \n",
    "    def fit_transform(self, data):\n",
    "        self.model = PCA(n_components=self.n_components)\n",
    "        X_pca = self.model.fit_transform(data)\n",
    "        return X_pca\n",
    "\n",
    "class MyTSNE(DimensionReduction):\n",
    "    def __init__(self, n_components):\n",
    "        super().__init__(n_components)\n",
    "    \n",
    "    def fit_transform(self, data):\n",
    "        self.model = TSNE(n_components=self.n_components, perplexity=30, n_iter=500)\n",
    "        X_tsne = self.model.fit_transform(data)\n",
    "        return X_tsne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "09d8708c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.cluster import KMeans, DBSCAN\n",
    "from sklearn.metrics import f1_score, recall_score, precision_score, silhouette_score\n",
    "from sklearn.decomposition import PCA\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "\n",
    "class Clustering:\n",
    "    def __init__(self, data):\n",
    "        self.model = None\n",
    "        self.data = data\n",
    "        self.pc_to_plot = 2\n",
    "        \n",
    "        #used to calculate different scores, if needed\n",
    "        self.labels = None\n",
    "    \n",
    "    def f1_score(self, labels_true):\n",
    "        return f1_score(labels_true, self.labels)\n",
    "    \n",
    "    def recall_score(self, labels_true):\n",
    "        return recall_score(labels_true, self.labels)\n",
    "    \n",
    "    def precision_score(self, labels_true):\n",
    "        return precision_score(labels_true, self.labels)\n",
    "    \n",
    "    def silhouette_score(self, data):\n",
    "        return silhouette_score(data, self.labels)\n",
    "    \n",
    "    def cluster(self):\n",
    "        raise NotImplementedError()\n",
    "    \n",
    "    def plot_clusters(self, model):\n",
    "        # Fit PCA to the data\n",
    "        pca = PCA(n_components=2)\n",
    "        X_pca = pca.fit_transform(self.data)\n",
    "        \n",
    "        # Get the cluster labels and the number of clusters\n",
    "        labels = self.labels\n",
    "        n_clusters = len(set(labels)) - (1 if -1 in labels else 0)\n",
    "\n",
    "        # Plot the data points colored by cluster\n",
    "        plt.scatter(X_pca[:, 0], X_pca[:, 1], c=labels, s=50, cmap='viridis')\n",
    "        plt.title(f'Clustering on PCA (Number of Clusters: {n_clusters})')\n",
    "        plt.xlabel('Principal Component 1')\n",
    "        plt.ylabel('Principal Component 2')\n",
    "        \n",
    "        # Remove values on the x and y axes\n",
    "        plt.tick_params(labelbottom=False, labelleft=False)\n",
    "        \n",
    "        #Show the plot\n",
    "        plt.show()\n",
    "\n",
    "class KMeansClustering(Clustering):\n",
    "    def __init__(self, data):\n",
    "        super().__init__(data)\n",
    "    \n",
    "    def elbow_method(self):\n",
    "        # Calculate the within-cluster sum of squares (WCSS) for each k value\n",
    "        wcss = []\n",
    "        \n",
    "        # Define range of k values to test\n",
    "        k_values = range(1, 10)\n",
    "        \n",
    "        for k in k_values:\n",
    "            kmeans = KMeans(n_clusters=k)\n",
    "            kmeans.fit(self.data)\n",
    "            wcss.append(kmeans.inertia_)\n",
    "\n",
    "        # Plot the elbow curve\n",
    "        plt.plot(k_values, wcss, 'bx-')\n",
    "        plt.xlabel('Number of clusters (k)')\n",
    "        plt.ylabel('WCSS')\n",
    "        plt.title('Elbow Method')\n",
    "\n",
    "        # Determine the optimal number of clusters\n",
    "        diffs = np.diff(wcss)\n",
    "        diff_ratios = diffs[1:] / diffs[:-1]\n",
    "        optimal_k = k_values[np.argmin(diff_ratios) + 1]\n",
    "\n",
    "        # Display the optimal number of clusters\n",
    "        plt.axvline(x=optimal_k, linestyle='--', color='r', label=f'Optimal k={optimal_k}')\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "\n",
    "        print(f\"Optimal number of clusters: {optimal_k}\")\n",
    "        \n",
    "        return optimal_k\n",
    "    \n",
    "    def cluster(self, n_clusters=None):\n",
    "        warnings.filterwarnings(\"ignore\")\n",
    "        if n_clusters is None:\n",
    "            n_clusters = self.elbow_method()\n",
    "        kmeans = KMeans(n_clusters=n_clusters)\n",
    "        self.model = kmeans\n",
    "        self.labels = kmeans.fit_predict(self.data)\n",
    "        \n",
    "        #plot the clusters\n",
    "        self.plot_clusters(self.model)\n",
    "\n",
    "class DBSCANClustering(Clustering):\n",
    "    def __init__(self, data):\n",
    "        super().__init__(data)\n",
    "    \n",
    "    def cluster(self, eps=None, min_samples=None):\n",
    "        warnings.filterwarnings(\"ignore\")\n",
    "        if eps is None:\n",
    "#             eps = np.sqrt(self.data.shape[1])\n",
    "            eps=5000\n",
    "        if min_samples is None:\n",
    "            min_samples = 2 * self.data.shape[1]\n",
    "        dbscan = DBSCAN(eps=eps, min_samples=min_samples)\n",
    "        self.model = dbscan\n",
    "        self.labels = dbscan.fit_predict(self.data)\n",
    "        \n",
    "        #plot the clusters\n",
    "        self.plot_clusters(self.model)\n",
    "        \n",
    "from sklearn.cluster import AgglomerativeClustering\n",
    "\n",
    "class AgglomerativeClusteringAlgorithm(Clustering):\n",
    "    def __init__(self, data):\n",
    "        super().__init__(data)\n",
    "    \n",
    "    # The linkage parameter specifies the method used to compute the distance between clusters. \n",
    "    # It determines the way clusters are merged during the hierarchical clustering process.\n",
    "    def cluster(self, n_clusters=2, linkage='ward'):\n",
    "        self.model = AgglomerativeClustering(n_clusters=n_clusters, linkage=linkage)\n",
    "        self.labels = model.fit_predict(self.data)\n",
    "        \n",
    "        #plot the clusters\n",
    "        self.plot_clusters(self.model)\n",
    "        \n",
    "from sklearn.cluster import MeanShift\n",
    "\n",
    "class MeanShiftClustering(Clustering):\n",
    "    def __init__(self, data):\n",
    "        super().__init__(data)\n",
    "    \n",
    "    def cluster(self):\n",
    "        self.model = MeanShift()\n",
    "        self.labels = self.model.fit_predict(self.data)\n",
    "        self.centers = self.model.cluster_centers_\n",
    "        \n",
    "        #plot the clusters\n",
    "        self.plot_clusters(self.model)\n",
    "        \n",
    "from sklearn.ensemble import IsolationForest\n",
    "\n",
    "class IsolationForestClustering(Clustering):\n",
    "    def __init__(self, data):\n",
    "        super().__init__(data)\n",
    "\n",
    "    def cluster(self, contamination=None):\n",
    "        if contamination is None:\n",
    "            contamination = 0.05\n",
    "        self.model = IsolationForest(contamination=contamination)\n",
    "        self.model.fit(self.data)\n",
    "        self.labels = self.model.predict(self.data)\n",
    "        \n",
    "        #plot the clusters\n",
    "        self.plot_clusters(self.model)\n",
    "        \n",
    "from sklearn.mixture import BayesianGaussianMixture\n",
    "\n",
    "class BGMMClustering(Clustering):\n",
    "    def __init__(self, data):\n",
    "        super().__init__(data)\n",
    "    \n",
    "    def cluster(self, n_components=None):\n",
    "        if n_components is None:\n",
    "            n_components = 2\n",
    "        self.model = BayesianGaussianMixture(n_components=n_components)\n",
    "        self.model.fit(self.data)\n",
    "        self.labels = self.model.predict(self.data)\n",
    "        \n",
    "        #plot the clusters\n",
    "        self.plot_clusters(self.model)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a241d79d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Model, load_model\n",
    "from keras.layers import Input, Dense, Conv1D, MaxPooling1D, UpSampling1D, Conv2D, MaxPooling2D, UpSampling2D, Cropping1D\n",
    "from keras.callbacks import ModelCheckpoint\n",
    "from sklearn.model_selection import train_test_split\n",
    "import datetime as dt\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "class DLModel:\n",
    "    def __init__(self):\n",
    "        self.model = None\n",
    "        self.history = None\n",
    "\n",
    "    def train(self):\n",
    "        pass\n",
    "\n",
    "    def detect(self, new_data):\n",
    "        pass\n",
    "\n",
    "    def define_model(self):\n",
    "        pass\n",
    "\n",
    "    def save_model(self):\n",
    "\n",
    "        # Get the current time as a string\n",
    "        timestamp = dt.datetime.now().strftime('%Y%m%d_%H%M%S')\n",
    "\n",
    "        # Construct the filename with the timestamp\n",
    "        filename = f'my_model_{timestamp}.h5'\n",
    "\n",
    "        # Save the model to the file with the timestamped name\n",
    "        self.model.save(filename)\n",
    "\n",
    "        # Print message indicating the model has been saved\n",
    "        print(f'Model saved to {filename}')\n",
    "\n",
    "class AnomalyDetectionModel(DLModel):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "class ConvolutionalAutoencoder(AnomalyDetectionModel):\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "    def define_model(self, height, width):\n",
    "        #Feel free to adjust this accordingly\n",
    "        x = Input(shape=(height, width, 1))\n",
    "\n",
    "        # Encoder\n",
    "        conv1_1 = Conv2D(16, (3, 3), activation='relu', padding='same')(x)\n",
    "        pool1 = MaxPooling2D((2, 2), padding='same')(conv1_1)\n",
    "        conv1_2 = Conv2D(8, (3, 3), activation='relu', padding='same')(pool1)\n",
    "        pool2 = MaxPooling2D((2, 2), padding='same')(conv1_2)\n",
    "        conv1_3 = Conv2D(8, (3, 3), activation='relu', padding='same')(pool2)\n",
    "        h = MaxPooling2D((2, 2), padding='same')(conv1_3)\n",
    "\n",
    "        # Decoder\n",
    "        conv2_1 = Conv2D(8, (3, 3), activation='relu', padding='same')(h)\n",
    "        up1 = UpSampling2D((2, 2))(conv2_1)\n",
    "        conv2_2 = Conv2D(8, (3, 3), activation='relu', padding='same')(up1)\n",
    "        up2 = UpSampling2D((2, 2))(conv2_2)\n",
    "        conv2_3 = Conv2D(16, (3, 3), activation='relu', padding='same')(up2)\n",
    "        up3 = UpSampling2D((2, 2))(conv2_3)\n",
    "        r = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(up3)\n",
    "\n",
    "        autoencoder = Model(inputs=x, outputs=r)\n",
    "        autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')\n",
    "        self.model = autoencoder\n",
    "        self.model.summary()\n",
    "\n",
    "    def train_model(self, X_train, X_test, checkpoint_filepath='model_checkpoint.h5'):\n",
    "        self.height = X_train.shape[1]\n",
    "        self.width = X_train.shape[2]\n",
    "        self.define_model(self.height, self.width)\n",
    "        checkpoint = ModelCheckpoint(checkpoint_filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')\n",
    "\n",
    "        # Train the model with checkpoints\n",
    "        self.history = self.model.fit(X_train, X_train, batch_size=128,\n",
    "                                      epochs=10, verbose=1, validation_data=(X_test, X_test))\n",
    "\n",
    "        self.save_model()\n",
    "\n",
    "    def plot_loss(self):\n",
    "        if not self.history:\n",
    "            print(\"Please train your model to get your model history\")\n",
    "            return\n",
    "        print(self.history.history.keys())\n",
    "\n",
    "        plt.plot(self.history.history['loss'])\n",
    "        plt.plot(self.history.history['val_loss'])\n",
    "        plt.title('model loss')\n",
    "        plt.ylabel('loss')\n",
    "        plt.xlabel('epoch')\n",
    "        plt.legend(['train', 'validation'], loc='upper right')\n",
    "        plt.show()\n",
    "\n",
    "    def plot_decoded_imgs(self, X_test):\n",
    "        decoded_imgs = self.model.predict(X_test)\n",
    "        n = 10\n",
    "        plt.figure(figsize=(20, 6))\n",
    "        for i in range(n):\n",
    "            # display original\n",
    "            ax = plt.subplot(3, n, i+1)\n",
    "            plt.imshow(X_test[i].reshape(self.height, self.width))\n",
    "            plt.gray()\n",
    "            ax.get_xaxis().set_visible(False)\n",
    "            ax.get_yaxis().set_visible(False)\n",
    "\n",
    "\n",
    "            # display reconstruction\n",
    "            ax = plt.subplot(3, n, i+n+1)\n",
    "            plt.imshow(decoded_imgs[i].reshape(self.height, self.width))\n",
    "            plt.gray()\n",
    "            ax.get_xaxis().set_visible(False)\n",
    "            ax.get_yaxis().set_visible(False)\n",
    "\n",
    "        plt.show()\n",
    "\n",
    "    def load_model(self, model_path):\n",
    "        self.model = load_model(model_path)\n",
    "        self.model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a9217ff8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from PIL import Image\n",
    "from Util import isImage\n",
    "\n",
    "class ImageResizer:\n",
    "    \"\"\"\n",
    "    A class that resizes all images in a folder to a given height and width and saves them to a new folder.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        \"\"\"\n",
    "        Initializes the ImageResizer with the path of the folder containing the images, the new width,\n",
    "        and the new height for the images.\n",
    "        \"\"\"\n",
    "        self.path = input(\"Enter the path of the folder containing the images: \")\n",
    "        self.new_width = int(input(\"Enter the new width for the images: \"))\n",
    "        self.new_height = int(input(\"Enter the new height for the images: \"))\n",
    "        self.new_folder = None\n",
    "        self.num_images = 0\n",
    "\n",
    "    def resize_images(self):\n",
    "        \"\"\"\n",
    "        Resizes all images in a folder to a given height and width and saves them to a new folder.\n",
    "        \"\"\"\n",
    "\n",
    "        # Create a new folder to save the resized images\n",
    "        new_folder = os.path.join(self.path, 'resized')\n",
    "        if not os.path.exists(new_folder):\n",
    "            os.mkdir(new_folder)\n",
    "        self.new_folder = new_folder\n",
    "\n",
    "        # Loop through all images in the folder\n",
    "        for file_name in os.listdir(self.path):\n",
    "            if isImage(file_name):\n",
    "                # Open the image\n",
    "                image = Image.open(os.path.join(self.path, file_name))\n",
    "\n",
    "                # Resize the image\n",
    "                new_image = image.resize((self.new_width, self.new_height))\n",
    "\n",
    "                # Save the resized image to the new folder\n",
    "                new_image.save(os.path.join(new_folder, file_name))\n",
    "\n",
    "                # Increment the number of resized images\n",
    "                self.num_images += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a9941b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sample use case\n",
    "\n",
    "from DLModels import ConvolutionalAutoencoder\n",
    "from ImageResizer import ImageResizer\n",
    "from Util import isImage\n",
    "from PIL import Image\n",
    "import tensorflow as tf\n",
    "import os\n",
    "import numpy as np\n",
    "\n",
    "print(tf.config.list_physical_devices('GPU'))\n",
    "nb_classes = 10\n",
    "\n",
    "print(\"Resize Training Set\")\n",
    "train_resizer = ImageResizer()\n",
    "train_resizer.resize_images()\n",
    "width, height, train_path = train_resizer.new_width, train_resizer.new_height, train_resizer.new_folder\n",
    "\n",
    "print(\"Resize Validation Set\")\n",
    "val_resizer = ImageResizer()\n",
    "val_resizer.resize_images()\n",
    "val_path = val_resizer.new_folder\n",
    "\n",
    "# Get a list of all image filenames\n",
    "train_files = [os.path.join(train_path, f) for f in os.listdir(train_path) if isImage(f)]\n",
    "val_files = [os.path.join(val_path, f) for f in os.listdir(val_path) if isImage(f)]\n",
    "\n",
    "# Create empty NumPy arrays to store the training and test images\n",
    "X_train = np.empty((len(train_files), height, width), dtype=np.float32)\n",
    "X_val = np.empty((len(val_files), height, width), dtype=np.float32)\n",
    "\n",
    "# Load the training images into the X_train array\n",
    "for i, filename in enumerate(train_files):\n",
    "    image = Image.open(filename)\n",
    "    X_train[i] = np.asarray(image, dtype=np.float32) / 255.0 # Normalize the pixel values to between 0 and 1\n",
    "\n",
    "# Load the test images into the X_test array\n",
    "for i, filename in enumerate(val_files):\n",
    "    image = Image.open(filename)\n",
    "    X_val[i] = np.asarray(image, dtype=np.float32) / 255.0 # Normalize the pixel values to between 0 and 1\n",
    "\n",
    "# Print the shapes of the X_train and X_test arrays\n",
    "print('X_train shape:', X_train.shape)\n",
    "print('X_test shape:', X_val.shape)\n",
    "\n",
    "# y_train = np_utils.to_categorical(y_train, nb_classes)\n",
    "# y_test = np_utils.to_categorical(y_test, nb_classes)\n",
    "\n",
    "# Create a convolutional autoencoder object\n",
    "autoencoder = ConvolutionalAutoencoder()\n",
    "\n",
    "# Train the autoencoder\n",
    "autoencoder.train_model(X_train, X_val)\n",
    "\n",
    "# Plot the loss\n",
    "autoencoder.plot_loss()\n",
    "\n",
    "autoencoder.plot_decoded_imgs(X_val)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "37e29f59",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "class Classifier:\n",
    "\n",
    "    def __init__(self):\n",
    "        # clf stands for classifier\n",
    "        self.clf = None\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        self.clf.fit(X, y)\n",
    "\n",
    "    def predict(self, X):\n",
    "        return self.clf.predict(X)\n",
    "\n",
    "    def score(self, X, y):\n",
    "        y_pred = self.predict(X)\n",
    "        print(accuracy_score(y,y_pred))\n",
    "        return accuracy_score(y, y_pred)\n",
    "\n",
    "class DecisionTree(Classifier):\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__()\n",
    "        self.clf = DecisionTreeClassifier(**kwargs)\n",
    "\n",
    "class RandomForest(Classifier):\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__()\n",
    "        self.clf = RandomForestClassifier(**kwargs)\n",
    "\n",
    "class XGBoost(Classifier):\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__()\n",
    "        self.clf = XGBClassifier(**kwargs)\n",
    "\n",
    "class MLP(Classifier):\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__()\n",
    "        self.clf = MLPClassifier(**kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "797bc88a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example usage\n",
    "X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])\n",
    "y = np.array([0, 1, 1, 0])\n",
    "\n",
    "# Train a decision tree classifier\n",
    "dt = DecisionTree()\n",
    "dt.fit(X, y)\n",
    "accuracy_dt = dt.score(X, y)\n",
    "\n",
    "#Since classification is supervised, will try running on the mura_dataset after we obtain the labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "5ef383b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Util:\n",
    "    \n",
    "    @staticmethod\n",
    "    def getClusteringClass(user_input_clustering_algorithm, data):\n",
    "        # create a dictionary that maps user input to the corresponding class\n",
    "        clustering_class_dict = {\n",
    "            \"kmeans\": KMeansClustering(data),\n",
    "            \"dbscan\": DBSCANClustering(data),\n",
    "            \"agglomerative\": AgglomerativeClusteringAlgorithm(data),\n",
    "            \"meanshift\": MeanShiftClustering(data),\n",
    "            \"isolation forest\": IsolationForestClustering(data),\n",
    "            \"bgmm\": BGMMClustering(data)\n",
    "        }\n",
    "\n",
    "        return clustering_class_dict[user_input_clustering_algorithm]\n",
    "    \n",
    "    def getDimReductionClass(user_input_dim_reduction_algorithm, n_components):\n",
    "        # create a dictionary that maps user input to the corresponding class\n",
    "        dim_reduction_class_dict = {\n",
    "            \"t-SNE\": MyTSNE(n_components),\n",
    "            \"PCA\": MyPCA(n_components)\n",
    "        }\n",
    "        \n",
    "        return dim_reduction_class_dict[user_input_dim_reduction_algorithm]\n",
    "    \n",
    "    @staticmethod\n",
    "    def isImage(filename):\n",
    "        return filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp'))\n",
    "    \n",
    "class App:\n",
    "    def __init__(self, filename):\n",
    "        self.preprocessor = DataPreprocessor(filename)\n",
    "        self.clustering = None\n",
    "        self.dim_reduction = None\n",
    "        self.classifier = None\n",
    "        \n",
    "    def start(self):\n",
    "        \n",
    "        # Ask the user for preprocessing options\n",
    "        self.preprocessor.drop_duplicates()\n",
    "        self.preprocessor.impute_missing()\n",
    "\n",
    "        # Show the user how the new table looks, and ask the user if he/she wants to download it\n",
    "        self.preprocessor.display_table()\n",
    "\n",
    "        data = self.preprocessor.return_data()\n",
    "        print(data.shape)\n",
    "        \n",
    "        #Ask the user for dimension reduction options\n",
    "        dim_reduction = input(\"Do you wish to perform dimension reduction? (y/n) \")\n",
    "        if dim_reduction.lower()==\"y\":\n",
    "            dimension_reduction_algorithm = input(\"\"\"Which dimension reduction algorithm do you wish to use? We currently support the following:\n",
    "                                        t-SNE, PCA \"\"\")\n",
    "            n_components = int(input(\"\"\"How many principal components are you looking for? \"\"\"))\n",
    "            self.dim_reduction = Util.getDimReductionClass(dimension_reduction_algorithm, n_components)\n",
    "            data = self.dim_reduction.fit_transform(data)\n",
    "            print(\"Data has been reshaped into a {} array with {} features\".format(data.shape[0], data.shape[1]))\n",
    "            \n",
    "            # Ask the user if they want to download the reshaped data as a CSV file\n",
    "            display(data)\n",
    "            download = input(\"Do you want to download the reshaped data as a CSV file? (y/n)\")\n",
    "\n",
    "            if download.lower() == 'y':\n",
    "                # Save the reshaped data as a CSV file\n",
    "                np.savetxt(\"reshaped_data.csv\", data_reshaped, delimiter=\",\")\n",
    "                print(\"Reshaped data has been saved as reshaped_data.csv\")\n",
    "            else:\n",
    "                print(\"Reshaped data was not downloaded\")\n",
    "                \n",
    "        # Ask the user for clustering options\n",
    "        clustering_algorithm = input(\"\"\"Which clustering algorithm do you wish to use? We currently support the following:\n",
    "                                        kmeans, dbscan, meanshift, agglomerative, isolation forest, bgmm \"\"\")\n",
    "        \n",
    "        self.clustering = Util.getClusteringClass(clustering_algorithm, data)\n",
    "\n",
    "        # Perform clustering\n",
    "        self.clustering.cluster()\n",
    "        \n",
    "        # Measure performance\n",
    "        silhouette_score = self.clustering.silhouette_score(data)\n",
    "\n",
    "        # Print the score\n",
    "        print(\"Silhouette score:\", silhouette_score)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "9878cddc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do you want to remove duplicates? Input T or F T\n",
      "How do you want to impute your missing values? e.g. \"median\", \"0\" mean\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Unnamed: 0</th>\n",
       "      <th>bright_sum</th>\n",
       "      <th>bright_size</th>\n",
       "      <th>bright_density</th>\n",
       "      <th>dark_sum</th>\n",
       "      <th>dark_size</th>\n",
       "      <th>dark_density</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2200.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>104.761905</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>137.861505</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>5411.0</td>\n",
       "      <td>48.0</td>\n",
       "      <td>112.729167</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>137.861505</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.0</td>\n",
       "      <td>4041.0</td>\n",
       "      <td>37.0</td>\n",
       "      <td>109.216216</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>137.861505</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3.0</td>\n",
       "      <td>16782.0</td>\n",
       "      <td>149.0</td>\n",
       "      <td>112.630872</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>137.861505</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4.0</td>\n",
       "      <td>31296.0</td>\n",
       "      <td>267.0</td>\n",
       "      <td>117.213483</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>137.861505</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1934</th>\n",
       "      <td>1934.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>116.969190</td>\n",
       "      <td>46759.0</td>\n",
       "      <td>368.0</td>\n",
       "      <td>127.062500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1935</th>\n",
       "      <td>1935.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>116.969190</td>\n",
       "      <td>26529.0</td>\n",
       "      <td>203.0</td>\n",
       "      <td>130.684729</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1936</th>\n",
       "      <td>1936.0</td>\n",
       "      <td>2692.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>107.680000</td>\n",
       "      <td>120569.0</td>\n",
       "      <td>957.0</td>\n",
       "      <td>125.986416</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1937</th>\n",
       "      <td>1937.0</td>\n",
       "      <td>4334.0</td>\n",
       "      <td>41.0</td>\n",
       "      <td>105.707317</td>\n",
       "      <td>84513.0</td>\n",
       "      <td>643.0</td>\n",
       "      <td>131.435459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1938</th>\n",
       "      <td>1938.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>116.969190</td>\n",
       "      <td>631.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>126.200000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1939 rows × 7 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      Unnamed: 0  bright_sum  bright_size  bright_density  dark_sum   \n",
       "0            0.0      2200.0         21.0      104.761905       0.0  \\\n",
       "1            1.0      5411.0         48.0      112.729167       0.0   \n",
       "2            2.0      4041.0         37.0      109.216216       0.0   \n",
       "3            3.0     16782.0        149.0      112.630872       0.0   \n",
       "4            4.0     31296.0        267.0      117.213483       0.0   \n",
       "...          ...         ...          ...             ...       ...   \n",
       "1934      1934.0         0.0          0.0      116.969190   46759.0   \n",
       "1935      1935.0         0.0          0.0      116.969190   26529.0   \n",
       "1936      1936.0      2692.0         25.0      107.680000  120569.0   \n",
       "1937      1937.0      4334.0         41.0      105.707317   84513.0   \n",
       "1938      1938.0         0.0          0.0      116.969190     631.0   \n",
       "\n",
       "      dark_size  dark_density  \n",
       "0           0.0    137.861505  \n",
       "1           0.0    137.861505  \n",
       "2           0.0    137.861505  \n",
       "3           0.0    137.861505  \n",
       "4           0.0    137.861505  \n",
       "...         ...           ...  \n",
       "1934      368.0    127.062500  \n",
       "1935      203.0    130.684729  \n",
       "1936      957.0    125.986416  \n",
       "1937      643.0    131.435459  \n",
       "1938        5.0    126.200000  \n",
       "\n",
       "[1939 rows x 7 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is your new data file -- do you want to download it? Input T or F F\n",
      "(1939, 6)\n",
      "Do you wish to perform dimension reduction? (y/n) y\n",
      "Which dimension reduction algorithm do you wish to use? We currently support the following:\n",
      "                                        t-SNE, PCA t-SNE\n",
      "How many principal components are you looking for? 2\n",
      "Data has been reshaped into a 1939 array with 2 features\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ -8.3556795,  17.857141 ],\n",
       "       [ -3.2171843,  13.681285 ],\n",
       "       [ -6.4759884,  15.7051115],\n",
       "       ...,\n",
       "       [ 27.574442 ,   3.294142 ],\n",
       "       [ 19.484064 ,  -1.2184479],\n",
       "       [-13.962769 ,  31.498268 ]], dtype=float32)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do you want to download the reshaped data as a CSV file? (y/n)n\n",
      "Reshaped data was not downloaded\n",
      "Which clustering algorithm do you wish to use? We currently support the following:\n",
      "                                        kmeans, dbscan, meanshift, agglomerative, isolation forest, bgmm kmeans\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal number of clusters: 4\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Silhouette score: 0.45481542\n"
     ]
    }
   ],
   "source": [
    "app = App(\"mura_data.csv\")\n",
    "app.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "3ececf6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "empty_arr = np.empty((3, 400, 400))\n",
    "zeros_arr = np.zeros((3, 400, 400))\n",
    "ones_arr = np.ones((3, 400, 400))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "7825b22c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1.68627456e-001  5.13725519e-001  6.47058845e-001 ...\n",
      "    2.58823544e-001  4.11764711e-001  8.11764717e-001]\n",
      "  [ 6.00000024e-001  4.23529416e-001  3.25490206e-001 ...\n",
      "    4.00000006e-001  6.98039234e-001  5.29411793e-001]\n",
      "  [ 5.09803951e-001  1.88235298e-001  4.70588237e-001 ...\n",
      "    1.45098045e-001  5.41176498e-001  6.74509823e-001]\n",
      "  ...\n",
      "  [ 5.01960814e-001  2.35294119e-001  4.07843143e-001 ...\n",
      "    6.98039234e-001  4.78431374e-001  6.82352960e-001]\n",
      "  [ 3.64705890e-001  6.43137276e-001  7.84313753e-002 ...\n",
      "    3.33333343e-001  2.70588249e-001  7.68627465e-001]\n",
      "  [ 1.00000000e+000  6.86274529e-001  8.62745121e-002 ...\n",
      "    5.25490224e-001  7.96078444e-001  6.58823550e-001]]\n",
      "\n",
      " [[ 2.28234781e+005  1.84316574e-317  6.53967423e-316 ...\n",
      "    2.29751855e-001  1.25050836e-009  5.40891360e+000]\n",
      "  [ 5.05502909e-008  1.26414203e+001  7.70960330e+000 ...\n",
      "    3.15993078e+001  3.93267946e-002  1.18647141e+005]\n",
      "  [ 9.28887973e-007  2.00455597e+002  1.70750617e+001 ...\n",
      "    1.57647019e-028  7.40442929e-010  6.08787764e-027]\n",
      "  ...\n",
      "  [-2.16717749e-014  2.16448689e-008  1.95787252e-009 ...\n",
      "    2.18876472e-008  5.05807948e-010 -1.01837396e-012]\n",
      "  [-9.97145556e-011  1.11314274e-014  1.04870085e-008 ...\n",
      "    3.34297000e-014 -1.21967058e-008 -6.42064035e-007]\n",
      "  [-8.49539634e-009 -4.46843556e-007 -5.46323802e-007 ...\n",
      "   -1.61383261e-008 -1.86165638e-009 -2.88984942e-008]]\n",
      "\n",
      " [[-9.46664468e-008 -1.16879905e-009 -3.61623563e-010 ...\n",
      "   -5.44249040e-017  1.52489381e-010 -7.57529317e-009]\n",
      "  [-8.87496183e-007 -8.10846388e-010  6.10332778e-010 ...\n",
      "   -3.70666884e-010 -2.54717967e-010  2.99817157e-012]\n",
      "  [-6.95446247e-010 -3.74197311e-008 -1.58291224e-009 ...\n",
      "   -2.05006106e-012 -1.29032485e-007 -9.64227908e-006]\n",
      "  ...\n",
      "  [ 2.73874760e-015  2.34845121e-025  7.77563300e-024 ...\n",
      "    1.23347005e-017  1.16291593e-020  1.98988578e-015]\n",
      "  [ 3.28313733e-020  5.23252547e-017  2.10734517e-016 ...\n",
      "    4.24972639e-017  1.29231965e-021  1.07495944e-023]\n",
      "  [ 5.51225296e-018  3.20116815e-013  1.28784493e-017 ...\n",
      "    7.54990818e-014  4.81782701e-016  7.33032154e-016]]]\n"
     ]
    }
   ],
   "source": [
    "image = np.random.randint(low=0, high=256, size=(400, 400))\n",
    "empty_arr[0] = np.asarray(image,dtype=np.float32) / 255.0\n",
    "print(empty_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "254b81c4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf",
   "language": "python",
   "name": "tf"
  },
  "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}