{"metadata":{"kernelspec":{"display_name":"TensorFlow","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.11.5"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":73479,"databundleVersionId":8152410,"sourceType":"competition"}],"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nfrom PIL import Image\nimport os\nimport matplotlib.pyplot as plt\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Upload Image Data and Visualize","metadata":{}},{"cell_type":"code","source":"size = 128 # change for how complex pictures get","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Set the paths\ntrain_images_dir = \"image_data/train\"\ntrain_csv_path = \"image_data/train.csv\"\nval_images = \"image_data/val\"\n\n# read in targets\ntrain_data = pd.read_csv(train_csv_path)\n\n# read in images and process\nimage_paths = [os.path.join(train_images_dir, f) for f in os.listdir(train_images_dir)]\nimage_paths.sort()\ntrain_images_flat = np.array([np.array(Image.open(img).resize((size, size))).flatten() for img in image_paths])\ntrain_images = np.array([np.array(Image.open(img).resize((size, size))) for img in image_paths])","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# validation images\nimage_paths_val = [os.path.join(val_images, f) for f in os.listdir(val_images)]\nimage_paths_val.sort()\nval_images = np.array([np.array(Image.open(img).resize((size, size))) for img in image_paths_val])\nval_images_flat = np.array([np.array(Image.open(img).resize((size, size))).flatten() for img in image_paths_val])","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Number of images to show\nselect_imgs = range(0,9)\nj = 0\nrows = 3\ncols = 3\nlabels = train_data['motor_visible']\nfilepath = train_data['image_name']\nx = train_data['x']\ny = train_data['y']\n\nplt.figure(figsize=(20, 10))\nfor i in select_imgs:\n    ax = plt.subplot(rows, cols, j + 1)\n    j += 1\n    img_dim = int(np.sqrt(train_images_flat[i].shape[0]))\n#    ax.imshow(train_images[i], cmap='gray')\n    ax.imshow(train_images_flat[i].reshape(img_dim, img_dim, 1), cmap='gray')\n    ax.set_title(f\"\"\"Motor: {labels[i]}, Coords: X:{x[i]}, Y:{y[i]}, \n                 Filepath: {filepath[i]}, \n                 Name: {image_paths[i]}\"\"\")\n    ax.axis('off')\nplt.tight_layout()\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Start with evaluating Binary Outcome with Flagella","metadata":{}},{"cell_type":"markdown","source":"## Train/Test Split","metadata":{}},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"if all(train_images_dir + '/' + train_data['image_name'] == image_paths):\n    Y = train_data['motor_visible']\n#    X_train, X_test, y_train, y_test = train_test_split(train_images_flat, Y, test_size=0.2, random_state=42)\n    X_train, X_test, y_train, y_test = train_test_split(train_images, Y, test_size=0.2, random_state=42)\n    id_train = y_train.index\n    id_test = y_test.index\n    print(f\"Train Size: {X_train.shape}, Test Size: {X_test.shape}\")\nelse:\n    print(\"File paths do not match, please resort them\")","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = X_train.astype(\"float32\") / (size-1)\nX_test = X_test.astype(\"float32\") / (size-1)\n# Make sure images have shape (516, 516, 1), or whatever your size is\nX_train = np.expand_dims(X_train, -1)\nX_test = np.expand_dims(X_test, -1)\nprint(\"X_train shape:\", X_train.shape)\nprint(X_train.shape[0], \"train samples\")\nprint(X_test.shape[0], \"test samples\")","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Example for checking the first 9 samples\nfor i in range(9):\n    ax = plt.subplot(3, 3, i + 1)\n    ax.imshow(X_train[i].squeeze(), cmap='gray')  # Squeeze to remove channel dimension if grayscale\n    ax.axis('off')\n    plt.title(f'Label: {y_train.iloc[i]}')\nplt.tight_layout()\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## CNN Config","metadata":{}},{"cell_type":"code","source":"import tensorflow as tf\nimport tensorflow.keras as keras\nfrom tensorflow.keras import layers, models\nfrom tensorflow.keras.applications import MobileNet\nfrom tensorflow.keras.layers import Flatten, Dense\n\nfrom sklearn.metrics import accuracy_score, roc_curve, auc","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# CNN_monitor = models.Sequential()\n# CNN_monitor.add(layers.Input(shape = (size, size, 1)))\n# CNN_monitor.add(layers.Conv2D(32, (3, 3), activation='relu'))\n# CNN_monitor.add(layers.MaxPooling2D((2, 2)))\n# CNN_monitor.add(layers.Conv2D(64, (3, 3), activation='relu'))\n# CNN_monitor.add(layers.MaxPooling2D((2, 2)))\n# CNN_monitor.add(layers.Conv2D(64, (3, 3), activation='relu'))\n# CNN_monitor.add(layers.Flatten())\n# CNN_monitor.add(layers.Dense(64, activation='relu'))\n# CNN_monitor.add(layers.Dense(2)) \n\nCNN_monitor = tf.keras.Sequential([\n  layers.Conv2D(16, 3, padding='same', activation='relu'),\n  layers.MaxPooling2D(),\n  layers.Conv2D(32, 3, padding='same', activation='relu'),\n  layers.MaxPooling2D(),\n  layers.Conv2D(64, 3, padding='same', activation='relu'),\n  layers.MaxPooling2D(),\n  layers.Flatten(),\n  layers.Dense(128, activation='relu'),\n])\n\n# Compile the model\nCNN_monitor.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) \n\n\n\n\n\n# CNN_monitor.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) \n\n# print(CNN_monitor.summary())","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Define the residual block as a custom layer\nclass ResidualBlock(tf.keras.layers.Layer):\n    def __init__(self, filters, kernel_size):\n        super(ResidualBlock, self).__init__()\n        self.conv1 = tf.keras.layers.Conv2D(filters, kernel_size, padding='same')\n        self.bn1 = tf.keras.layers.BatchNormalization()\n        self.relu1 = tf.keras.layers.ReLU()\n        self.conv2 = tf.keras.layers.Conv2D(filters, kernel_size, padding='same')\n        self.bn2 = tf.keras.layers.BatchNormalization()\n        self.add = tf.keras.layers.Add()\n        self.relu2 = tf.keras.layers.ReLU()\n\n    def call(self, inputs):\n        shortcut = inputs\n        x = self.conv1(inputs)\n        x = self.bn1(x)\n        x = self.relu1(x)\n        x = self.conv2(x)\n        x = self.bn2(x)\n        x = self.add([x, shortcut])\n        return self.relu2(x)\n\nbase_model = MobileNet(weights='imagenet', include_top=False, input_shape=(size, size, 3))\nfor layer in base_model.layers:\n    layer.trainable = False\n\nCNN_monitor = tf.keras.Sequential([\n    base_model,\n    tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),\n    tf.keras.layers.MaxPooling2D(padding='same'), \n    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),\n    tf.keras.layers.MaxPooling2D(padding='same'), \n    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),\n    tf.keras.layers.MaxPooling2D(padding='same'), \n    ResidualBlock(filters=64, kernel_size=(3, 3)),  \n    tf.keras.layers.Flatten(),\n    tf.keras.layers.Dense(128, activation='relu'),\n])\n\nCNN_monitor.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) ","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train_tensor = tf.convert_to_tensor(X_train)\nX_test_tensor = tf.convert_to_tensor(X_test)\nX_train_rgb = tf.image.grayscale_to_rgb(X_train_tensor)\nX_test_rgb = tf.image.grayscale_to_rgb(X_test_tensor)\nbatch_size = 64\nn_epochs= 20\n\nhistory = CNN_monitor.fit(X_train_rgb, y_train, epochs=n_epochs, \n                    batch_size=batch_size, verbose=1, validation_split=.1)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Test Set","metadata":{}},{"cell_type":"code","source":"test_eval = CNN_monitor.evaluate(X_test_rgb, y_test, verbose=1)\n\nprint('Test loss:', test_eval[0])\nprint('Test accuracy:', test_eval[1])\n\nplt.plot(history.history['accuracy'], label='accuracy')\nplt.plot(history.history['val_accuracy'], label = 'val_accuracy')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\nplt.ylim([0, 1.05])\nplt.legend(loc='lower right')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## ROC Curve, Finding Best Class Split","metadata":{}},{"cell_type":"code","source":"from sklearn.metrics import roc_curve, auc, f1_score, recall_score, precision_score\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# on train set, for evaluation\nlogits = CNN_monitor.predict(X_train_rgb, verbose=1)\nprobabilities = tf.nn.softmax(logits).numpy()\ny_train_probs = probabilities[:, 1]\n# for specificity/sensitivity\nlogits = CNN_monitor.predict(X_test_rgb, verbose=1)\nprobabilities = tf.nn.softmax(logits).numpy()\ny_test_probs = probabilities[:, 1]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fpr, tpr, threshold = roc_curve(y_test, y_test_probs)\nroc_auc = auc(fpr, tpr)\n\nplt.title('Receiver Operating Characteristic')\nplt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\nplt.legend(loc = 'lower right')\nplt.plot([0, 1], [0, 1],'r--')\nplt.xlim([0, 1])\nplt.ylim([0, 1])\nplt.ylabel('True Positive Rate')\nplt.xlabel('False Positive Rate')\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"cutoffs = np.arange(0., 1.0, 0.05)\nfor co in cutoffs:\n    y_hat_co = y_test_probs > co\n    print(f\"\"\"Cutoff Value: {co}\n            Precision: {precision_score(y_hat_co, y_test)}\n            Recall: {recall_score(y_hat_co, y_test)}\n            F1: {f1_score(y_hat_co, y_test)}\n            Accuracy: {accuracy_score(y_hat_co, y_test)}\n\"\"\")\n# I think we want the highest precision, so we get the ones with monitors","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"cutoff = .05\ny_hat = y_test_probs > cutoff","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Number of images to show\nnum_images = 16\nrows = 4\ncols = 4\ntest_images_flat = train_images_flat[id_test]\nlabels_test = labels[id_test]\nx_lab = x[id_test]\ny_lab = y[id_test]\n\nplt.figure(figsize=(20, 10))\nfor i in range(num_images):\n    ax = plt.subplot(rows, cols, i + 1)\n    img_dim = int(np.sqrt(test_images_flat[i].shape[0]))\n    ax.imshow(test_images_flat[i].reshape(img_dim, img_dim, 1), cmap='gray')\n    ax.set_title(f\"\"\"Motor: {labels_test.iloc[i]}, X:{x_lab.iloc[i]}, Y:{y_lab.iloc[i]}, \n                Pred: {y_hat[i]}, Prob: {y_test_probs[i]}\"\"\")\n    ax.axis('off')\nplt.tight_layout()\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(f\"Final Accuracy: {accuracy_score(y_hat, y_test)}\")\nprint(f\"Final Precision: {precision_score(y_hat, y_test)}\")","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Location Detection of Flagella","metadata":{}},{"cell_type":"markdown","source":"## Train Test Split","metadata":{}},{"cell_type":"code","source":"loc_data = train_data[train_data['motor_visible'] == 1]\nloc_image = train_images[train_data['motor_visible'] == 1]\n\nY_loc = loc_data[['x','y']]\nX_train, X_test, y_train_loc, y_test_loc = train_test_split(loc_image, Y_loc, test_size=0.2, random_state=42)\nid_train_ = y_train_loc.index\nid_test_ = y_test_loc.index\nprint(f\"Train Size: {X_train.shape}, Test Size: {X_test.shape}\")","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = X_train.astype(\"float32\") / (size-1)\nX_test = X_test.astype(\"float32\") / (size-1)\n# Make sure images have shape (516, 516, 1)\nX_train = np.expand_dims(X_train, -1)\nX_test = np.expand_dims(X_test, -1)\nprint(\"X_train shape:\", X_train.shape)\nprint(X_train.shape[0], \"train samples\")\nprint(X_test.shape[0], \"test samples\")","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## CNN Config -- Location Detection","metadata":{}},{"cell_type":"code","source":"from sklearn.metrics import mean_absolute_error\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"base_model = MobileNet(weights='imagenet', include_top=False, input_shape=(size, size, 3))\nfor layer in base_model.layers:\n    layer.trainable = False\n\n# CNN_loc = tf.keras.Sequential([\n#    base_model,\n#    tf.keras.layers.Conv2D(32, (3, 3), activation='relu'),\n#    tf.keras.layers.MaxPooling2D((2, 2)),\n#    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n#    tf.keras.layers.MaxPooling2D((2, 2)),\n#    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n#    tf.keras.layers.Dropout(0.5),\n#    tf.keras.layers.Flatten(),\n#    tf.keras.layers.Dense(64, activation='relu'),\n#    tf.keras.layers.Dropout(0.5),\n#    tf.keras.layers.Dense(2)\n# ])\n\nCNN_loc = tf.keras.Sequential([\n    base_model,\n    tf.keras.layers.Conv2D(32, (3, 3), activation='relu', strides=(2, 2), padding='same'),\n    tf.keras.layers.Conv2D(64, (3, 3), activation='relu', strides=(2, 2), padding='same'),\n    tf.keras.layers.Conv2D(64, (3, 3), activation='relu', strides=(2, 2), padding='same'),\n    tf.keras.layers.Dropout(0.5),\n    tf.keras.layers.Flatten(),\n    tf.keras.layers.Dense(64, activation='relu'),\n    tf.keras.layers.Dropout(0.5),\n    tf.keras.layers.Dense(2)\n])\n\n# Compile the model\nCNN_loc.compile(optimizer='adam', \n              loss='mean_squared_error',\n              metrics=['mae'])  \n\nprint(CNN_loc.summary())","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Define the FPN architecture\nbase_model = MobileNet(weights='imagenet', include_top=False, input_shape=(size, size, 3))\nfor layer in base_model.layers:\n    layer.trainable = False\n\n# FPN layers\nC3, C4, C5 = base_model.get_layer('conv_pw_1_relu').output, base_model.get_layer('conv_pw_3_relu').output, base_model.get_layer('conv_pw_5_relu').output\nP5 = layers.Conv2D(32, (1, 1), activation='relu')(C5)\nP4 = layers.Conv2D(32, (1, 1), activation='relu')(C4) + layers.UpSampling2D((2, 2))(P5)\nP3 = layers.Conv2D(32, (1, 1), activation='relu')(C3) + layers.UpSampling2D((2, 2))(P4)\n\n# Final prediction layers\noutput = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(P3)\noutput = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(output)\noutput = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(output)\noutput = layers.Dropout(0.5)(output)\noutput = layers.Flatten()(output)\noutput = layers.Dense(64, activation='relu')(output)\noutput = layers.Dropout(0.5)(output)\noutput = layers.Dense(2)(output)\n\n# Build the model\nCNN_loc = tf.keras.Model(inputs=base_model.input, outputs=output)\n\n# Compile the model\nCNN_loc.compile(optimizer='adam', \n                loss='mean_squared_error',\n                metrics=['mae'])\n\nprint(CNN_loc.summary())\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train_tensor = tf.convert_to_tensor(X_train)\nX_test_tensor = tf.convert_to_tensor(X_test)\nX_train_rgb = tf.image.grayscale_to_rgb(X_train_tensor)\nX_test_rgb = tf.image.grayscale_to_rgb(X_test_tensor)\n\nbatch_size = 64\nn_epochs= 5\nhistory = CNN_loc.fit(X_train_rgb, y_train_loc, epochs=n_epochs, \n                    batch_size=batch_size, verbose=1, validation_split=.2)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Test Evaluation","metadata":{}},{"cell_type":"code","source":"y_hat_coords = CNN_loc.predict(X_test_rgb)\nprint(f\"MAE: {mean_absolute_error(y_hat_coords, y_test_loc)}\")","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.plot(history.history['mae'], label='mae')\nplt.plot(history.history['val_mae'], label = 'val_mae')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\nplt.ylim([0,250])\nplt.legend(loc='lower right')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dist = []\nfor i in range(len(np.array(y_test_loc))):\n    dist.append(np.linalg.norm(np.array(y_test_loc)[i] - y_hat_coords[i]))  # Calculate Euclidean distance\n\nmean_distance = np.mean(dist)\nmax_distance = np.max(dist)\nprint(\"Mean distance:\", mean_distance)\nprint(\"Max distance:\", max_distance)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.hist(dist)\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Checking Overall Accuracy","metadata":{}},{"cell_type":"code","source":"# from motor_visible\ncutoff = .05\ny_hat = y_test_probs > cutoff","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"xloc = []\nyloc = []\nj = 0\nfor i in range(len(y_hat)):\n    if y_hat[i] == 1:\n        xloc.append(y_hat_coords[j,0]) \n        yloc.append(y_hat_coords[j,1]) \n        j += 1\n    else:\n        xloc.append(-1) \n        yloc.append(-1) ","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"preds = pd.DataFrame({'x': xloc,'y': yloc,\n              'motor_visible': y_hat})\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"truth = train_data.iloc[id_test]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"preds","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n# Assuming xloc, yloc, y_hat, y_test_loc, and y_test are defined elsewhere and correctly\n\npreds = pd.DataFrame({'x': xloc, 'y': yloc, 'motor_visible': y_hat})\n# truth = pd.DataFrame({'x': y_test_loc['x'], 'y': y_test_loc['y'], 'motor_visible': y_test})\n\ndef full_accuracy_score(preds, truth):\n    correct = []  # This will be a list of 1's (correct predictions) and 0's (incorrect predictions)\n    for i in range(len(truth)):\n        if (preds['motor_visible'].iloc[i] == 1) and (truth['motor_visible'].iloc[i] == 1):\n            # Accessing the row with .iloc and then values to get it as an array\n            yhat_coords = preds[['x','y']].iloc[i].values\n            true_coords = truth[['x', 'y']].iloc[i].values\n            # Append the distance calculation directly\n            current_distance = np.linalg.norm(true_coords - yhat_coords)\n            if current_distance < 40:\n                correct.append(1)  # Append 1 if the prediction is correct\n            else:\n                correct.append(0)  # Append 0 otherwise\n        elif (preds['motor_visible'].iloc[i] == 0) and (truth['motor_visible'].iloc[i] == 0):\n            correct.append(1)  # Correct non-visible\n        else:\n            correct.append(0)  # Incorrect prediction\n\n    # Calculate accuracy as the mean of correct predictions\n    accuracy = sum(correct) / len(correct)\n    return accuracy\n\n# Assuming 'preds' and 'truth' DataFrames are defined above this\naccuracy = full_accuracy_score(preds, truth)\nprint(f\"Full Accuracy: {accuracy}\")\n       \n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Output to Predictions.csv","metadata":{}},{"cell_type":"markdown","source":"## Standardize Images","metadata":{}},{"cell_type":"code","source":"train_images_std = train_images.astype(\"float32\") / (size-1)\n# Make sure images have shape (516, 516, 1)\ntrain_images_std = np.expand_dims(train_images_std, -1)\nprint(\"Train Images Shape:\", train_images_std.shape)\nprint(train_images_std.shape[0], \"Train Samples\")\nprint(\"Number of Monitors is Equal to Number of Available Location Data:\", Y.sum() == Y_loc.shape[0])\nprint(\"Number of Monitors:\", Y.sum())\ntrain_images_std_loc = train_images_std[train_data['motor_visible'] == 1]\nprint(\"Location Image Sample Size:\", train_images_std_loc.shape[0])","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"val_images_std = val_images.astype(\"float32\") / (size-1)\n# Make sure images have shape (516, 516, 1)\nval_images_std = np.expand_dims(val_images_std, -1)\nprint(\"Val Images Shape:\", val_images_std.shape)\nprint(val_images_std.shape[0], \"Val Samples\")","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_images_std_tensor = tf.convert_to_tensor(train_images_std)\ntrain_images_std_rgb = tf.image.grayscale_to_rgb(train_images_std_tensor)\n\ntrain_images_std_loc_tensor = tf.convert_to_tensor(train_images_std_loc)\ntrain_images_std_loc_rgb = tf.image.grayscale_to_rgb(train_images_std_loc_tensor)\n\nval_images_std_tensor = tf.convert_to_tensor(val_images_std)\nval_images_std_rgb = tf.image.grayscale_to_rgb(val_images_std_tensor)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Take all image data for model, and fit to monitor ID","metadata":{}},{"cell_type":"code","source":"batch_size = 64\nn_epochs= 10\nhistory = CNN_monitor.fit(train_images_std_rgb, Y, epochs=n_epochs, \n                    batch_size=batch_size, verbose=1, validation_split=.2)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# make predictions for monitor == 1 based off of cutoff value of .2\nlogits = CNN_monitor.predict(val_images_std_rgb, verbose=1)\nprobabilities = tf.nn.softmax(logits).numpy()\nval_probs = probabilities[:, 1]\ny_val_hat = val_probs > .05","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Take all monitor == 1 images to train CNN Locator","metadata":{}},{"cell_type":"code","source":"batch_size = 64\nn_epochs= 10\nhistory = CNN_loc.fit(train_images_std_loc_rgb, Y_loc, epochs=n_epochs, \n                    batch_size=batch_size, verbose=1, validation_split=.2)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"val_images_std_loc_rgb = val_images_std_rgb[y_val_hat]\ny_val_loc = CNN_loc.predict(val_images_std_loc_rgb)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Build Predictions Output ","metadata":{}},{"cell_type":"code","source":"base_paths = [os.path.basename(path) for path in image_paths_val]\nval_xloc = []\nval_yloc = []\nj = 0\nfor i in range(len(y_val_hat)):\n    if y_val_hat[i] == 1:\n        val_xloc.append(y_val_loc[j,0]) \n        val_yloc.append(y_val_loc[j,1]) \n        j += 1\n    else:\n        val_xloc.append(-1) \n        val_yloc.append(-1) \n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"preds = pd.DataFrame({'image_name': base_paths,\n              'x': val_xloc,\n              'y': val_yloc,\n              'motor_visible': y_val_hat})\n\npreds.to_csv('predictions.csv')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"preds","metadata":{},"execution_count":null,"outputs":[]}]}