AbcdSiamese_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. SETUP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Dependencies\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import standard dependencies\n",
    "import cv2\n",
    "import os\n",
    "import random\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import tensorflow dependencies - Functional API\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Layer, Conv2D, Dense, MaxPooling2D, Input, Flatten\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 GPU Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Avoid OOM errors by setting GPU Memory Consumption Growth\n",
    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "for gpu in gpus: \n",
    "    tf.config.experimental.set_memory_growth(gpu, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. COLLECTING DATA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting random seeds to enable consistency while testing.\n",
    "np.random.seed(5)\n",
    "tf.random.set_seed(5)\n",
    "\n",
    "ROOT = \"./nice-dataset/\"\n",
    "\n",
    "def read_image(index):\n",
    "    path = os.path.join(ROOT, index[0], index[1])\n",
    "    image = cv2.imread(path)\n",
    "    # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "    # image = image.astype(np.uint8)  # Convert the data type to np.uint8\n",
    "    return image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 COLLECT AND SPLIT DATASET"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(1144)\n",
    "\n",
    "def generate_prediction_data_v1(file_path):\n",
    "    test_input = [] \n",
    "    test_val = []\n",
    "    y_true = []\n",
    "    k=1\n",
    "    positive_counter = 0\n",
    "    negative_counter = 0\n",
    "    xdd = random.randint(0,1)\n",
    "    folder_list = os.listdir(file_path)\n",
    "    print(len(folder_list))\n",
    "    for folder in folder_list: \n",
    "        print(\"ITER no:\",k,\"folder name:\",folder)\n",
    "        k+=1\n",
    "        #Get random image for val\n",
    "        image_list = os.listdir(os.path.join(file_path,folder))\n",
    "        anchor_path = os.path.join(file_path,folder,image_list[0])\n",
    "        negative_tuple_count = len(image_list)\n",
    "        #Generate positive test case\n",
    "        for i in range(1,len(image_list)):\n",
    "            positive_counter+=1\n",
    "            positive_path = os.path.join(file_path,folder,image_list[i])\n",
    "            test_input.append(positive_path)\n",
    "            test_val.append(anchor_path)\n",
    "            y_true.append(1)\n",
    "\n",
    "        #Generating negative test-case\n",
    "        neg_folder = folder\n",
    "        while neg_folder == folder:\n",
    "            neg_folder = random.choice(folder_list)    \n",
    "        neg_files = os.listdir(os.path.join(file_path, neg_folder))   \n",
    "\n",
    "        if(len(image_list) == 1):\n",
    "            \n",
    "            negative_path = os.path.join(file_path,neg_folder, neg_files[0])\n",
    "\n",
    "            test_input.append(negative_path)\n",
    "            test_val.append(anchor_path)\n",
    "            y_true.append(0)\n",
    "            continue\n",
    "        \n",
    "        negative_tuple_count = min(negative_tuple_count,len(neg_files)) \n",
    "        for j in range(negative_tuple_count):\n",
    "            negative_counter+=1\n",
    "            negative_path = os.path.join(file_path,neg_folder, neg_files[j])\n",
    "            test_input.append(negative_path)\n",
    "            test_val.append(anchor_path)\n",
    "            y_true.append(0)\n",
    "\n",
    "        \n",
    "    \n",
    "    print(f\"END OF CREATING TEST... \\n Positive count: {positive_counter} \\n Negative count: {negative_counter}\")\n",
    "    # for i in range(len(test_input)):\n",
    "    #     print(\"Input:\",test_input[i],\"Validation: \",test_val[i],\"Label:\",y_true[i])\n",
    "    test_dataset = tf.data.Dataset.zip((tf.data.Dataset.from_tensor_slices(test_input), \n",
    "                                        tf.data.Dataset.from_tensor_slices(test_val), \n",
    "                                        tf.data.Dataset.from_tensor_slices(y_true) ))\n",
    "    return test_dataset\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### VERSION 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_negative_case(file_path,folder,anchor_img_path):\n",
    "    \n",
    "    folder_list = os.listdir(file_path)\n",
    "\n",
    "    neg_folder = folder\n",
    "    while neg_folder == folder:\n",
    "        neg_folder = random.choice(folder_list)\n",
    "    \n",
    "    neg_files = os.listdir(os.path.join(file_path, neg_folder))       \n",
    "    negative = os.path.join(file_path,neg_folder, random.choice(neg_files))\n",
    "    y = 0\n",
    "\n",
    "    return (negative,anchor_img_path,y)\n",
    "\n",
    "          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_positive_case(file_path,folder,anchor_img_path):\n",
    "    positive = anchor_img_path\n",
    "    image_list = os.listdir(os.path.join(file_path,folder))\n",
    "    \n",
    "    while positive == anchor_img_path:\n",
    "        positive = random.choice(image_list)\n",
    "\n",
    "    positive = os.path.join(file_path,folder,positive)\n",
    "    y = 1\n",
    "\n",
    "    return (positive,anchor_img_path,y) \n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 CATEGORIZE (ANCHOR, POSITIVE, NEGATIVE) IMAGES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# partition_1 = generate_prediction_data_v1('./face-dataset-cropped')\n",
    "# partition_2 = generate_prediction_data_v1('./nice-dataset/')\n",
    "# data = partition_1.concatenate(partition_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = generate_prediction_data_v1('./face-dataset-cropped/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Len data: \",len(data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_png(file_path):\n",
    "    \n",
    "    # Read in image from file path\n",
    "    byte_img = tf.io.read_file(file_path)\n",
    "    # Load in the image \n",
    "    img = tf.io.decode_png(byte_img, channels=3)\n",
    "    \n",
    "    # Preprocessing steps - resizing the image to be 100x100x3\n",
    "    img = tf.image.resize(img, (128,128))\n",
    "    # Scale image to be between 0 and 1 \n",
    "    img = img / 255.0\n",
    "\n",
    "    # Return image\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_jpg(file_path):\n",
    "    \n",
    "    # Read in image from file path\n",
    "    byte_img = tf.io.read_file(file_path)\n",
    "    # Load in the image \n",
    "    img = tf.io.decode_jpeg(byte_img, channels=3)\n",
    "    \n",
    "    # Preprocessing steps - resizing the image to be 100x100x3\n",
    "    img = tf.image.resize(img, (128,128))\n",
    "    # Scale image to be between 0 and 1 \n",
    "    img = img / 255.0\n",
    "\n",
    "    # Return image\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_twin(input_img, validation_img, label):\n",
    "    return(preprocess_jpg(input_img), preprocess_jpg(validation_img), label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.map(preprocess_twin)\n",
    "data.cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = data.take(round(len(data)))\n",
    "train_data = train_data.batch(batch_size=64)\n",
    "train_data = train_data.prefetch(buffer_size= tf.data.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. MODEL BUILDING"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.0 TESTING ZONE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I just want to make sure everything is alright"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1. Embedding layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_embedding(): \n",
    "    inp = Input(shape=(128,128,3), name='input_image')\n",
    "    \n",
    "    # First block\n",
    "    c1 = Conv2D(64, (10,10), activation='relu')(inp)\n",
    "    m1 = MaxPooling2D(64, (2,2), padding='same')(c1)\n",
    "    \n",
    "    # Second block\n",
    "    c2 = Conv2D(128, (7,7), activation='relu')(m1)\n",
    "    m2 = MaxPooling2D(64, (2,2), padding='same')(c2)\n",
    "    \n",
    "    # Third block \n",
    "    c3 = Conv2D(128, (4,4), activation='relu')(m2)\n",
    "    m3 = MaxPooling2D(64, (2,2), padding='same')(c3)\n",
    "    \n",
    "    # Final embedding block\n",
    "    c4 = Conv2D(256, (4,4), activation='relu')(m3)\n",
    "    f1 = Flatten()(c4)\n",
    "    d1 = Dense(4096, activation='sigmoid')(f1)\n",
    "    \n",
    "    \n",
    "    return Model(inputs=[inp], outputs=[d1], name='embedding')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding = make_embedding()\n",
    "embedding.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2. Build Distance Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class L1Dist(Layer):\n",
    "    \n",
    "    # Init method - inheritance\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__()\n",
    "       \n",
    "    # Magic happens here - similarity calculation\n",
    "    def call(self, input_embedding, validation_embedding):\n",
    "        return tf.math.abs(input_embedding - validation_embedding)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class L2Dist(Layer):\n",
    "#     # A layer to compute ‖f(A) - f(P)‖² and ‖f(A) - f(N)‖²\n",
    "#     def __init__(self, **kwargs):\n",
    "#         super().__init__(**kwargs)\n",
    "\n",
    "#     def call(self, input_embedding, validation_embedding):\n",
    "#         return tf.reduce_sum(tf.square(input_embedding - validation_embedding), -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = L1Dist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# l1(anchor_embedding, validation_embedding)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.3 Make Siamese model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_siamese_model(): \n",
    "    \n",
    "    # Anchor image input in the network\n",
    "    input_image = Input(name='input_img', shape=(128,128,3))\n",
    "    \n",
    "    # Validation image in the network \n",
    "    validation_image = Input(name='validation_img', shape=(128,128,3))\n",
    "    \n",
    "    # Combine siamese distance components\n",
    "    siamese_layer = L1Dist()\n",
    "    siamese_layer._name = 'distance'\n",
    "    distances = siamese_layer(embedding(input_image), embedding(validation_image))\n",
    "    \n",
    "    # Classification layer \n",
    "    classifier = Dense(1, activation='sigmoid')(distances)\n",
    "    \n",
    "    return Model(inputs=[input_image, validation_image], outputs=classifier, name='SiameseNetwork')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "siamese_model = make_siamese_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "siamese_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. TRAINING MODELS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1 SIAMESE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.1 Setup Loss and Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "binary_cross_loss = tf.losses.BinaryCrossentropy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = tf.keras.optimizers.Adam(1e-4) # 0.0001"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.2 Checkpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# checkpoint_dir = './training_checkpoints'\n",
    "# checkpoint_prefix = os.path.join(checkpoint_dir, 'ckpt')\n",
    "# checkpoint = tf.train.Checkpoint(opt=opt, siamese_model=siamese_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.3 Train Step Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_batch = train_data.as_numpy_iterator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_1 = test_batch.next()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = batch_1[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = batch_1[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# just for testing\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def train_step(batch):\n",
    "    \n",
    "    # Record all of our operations \n",
    "    with tf.GradientTape() as tape:     \n",
    "        # Get anchor and positive/negative image\n",
    "        X = batch[:2]\n",
    "        # Get label\n",
    "        y = batch[2]\n",
    "        \n",
    "        # Forward pass\n",
    "        yhat = siamese_model(X, training=True)\n",
    "        # Calculate loss\n",
    "        loss = binary_cross_loss(y, yhat)\n",
    "          \n",
    "    # Calculate gradients\n",
    "    grad = tape.gradient(loss, siamese_model.trainable_variables)\n",
    "    \n",
    "    # Calculate updated weights and apply to siamese model\n",
    "    opt.apply_gradients(zip(grad, siamese_model.trainable_variables))\n",
    "        \n",
    "    # Return loss\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.4 Train loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import metric calculations\n",
    "from tensorflow.keras.metrics import Precision, Recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(data, EPOCHS):\n",
    "    # Initialize lists to store loss and accuracy values\n",
    "    losses = []\n",
    "    recall = []\n",
    "    precision = []\n",
    "    # Creating a metric object \n",
    "    # r = Recall()\n",
    "    # p = Precision()\n",
    "    \n",
    "    for epoch in range(1, EPOCHS+1):\n",
    "        print('\\n Epoch {}/{}'.format(epoch, EPOCHS))\n",
    "        progbar = tf.keras.utils.Progbar(len(data))\n",
    "       \n",
    "\n",
    "        for idx, batch in enumerate(data):\n",
    "            loss = train_step(batch)\n",
    "            \n",
    "            # Calculate accuracy\n",
    "            # yhat = siamese_model.predict(batch[:2])\n",
    "            # r.update_state(batch[2], yhat)\n",
    "            # p.update_state(batch[2], yhat) \n",
    "            progbar.update(idx+1)\n",
    "        print(f\"Loss: {loss.numpy()}\")\n",
    "        # Save checkpoints\n",
    "        # if epoch % 10 == 0: \n",
    "            # checkpoint.save(file_prefix=checkpoint_prefix)\n",
    "\n",
    "        # Calculate and print average loss and accuracy for the e==============poch\n",
    "        \n",
    "\n",
    "        # Append loss and accuracy to lists\n",
    "        losses.append(loss.numpy())\n",
    "        # recall.append(r.result().numpy())\n",
    "        # precision.append(p.result().numpy())\n",
    "\n",
    "    # Plot loss \n",
    "    plt.figure(figsize=(12, 5))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(losses)\n",
    "    plt.title('Training Loss')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Loss')\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train2(data, loss_threshold):\n",
    "    # Initialize lists to store loss and accuracy values\n",
    "    losses = []\n",
    "    # Creating a metric object \n",
    "    # r = Recall()\n",
    "    # p = Precision()\n",
    "\n",
    "    epoch = 1\n",
    "    print('\\n Epoch {}'.format(epoch))\n",
    "    progbar = tf.keras.utils.Progbar(len(data))\n",
    "    for idx, batch in enumerate(data):\n",
    "            loss = train_step(batch)\n",
    "            \n",
    "            # Calculate accuracy\n",
    "            # yhat = siamese_model.predict(batch[:2])\n",
    "            # r.update_state(batch[2], yhat)\n",
    "            # p.update_state(batch[2], yhat) \n",
    "            progbar.update(idx+1)\n",
    "\n",
    "    print(f\"Loss: {loss.numpy()}\")\n",
    "\n",
    "    while loss > loss_threshold:\n",
    "        print('\\n Epoch {}'.format(epoch))\n",
    "        progbar = tf.keras.utils.Progbar(len(data))\n",
    "        epoch +=1\n",
    "\n",
    "        for idx, batch in enumerate(data):\n",
    "            loss = train_step(batch)\n",
    "            \n",
    "            # Calculate accuracy\n",
    "            # yhat = siamese_model.predict(batch[:2])\n",
    "            # r.update_state(batch[2], yhat)\n",
    "            # p.update_state(batch[2], yhat) \n",
    "            progbar.update(idx+1)\n",
    "        print(f\"Loss: {loss.numpy()}\")\n",
    "        # Save checkpoints\n",
    "        # if epoch % 10 == 0: \n",
    "            # checkpoint.save(file_prefix=checkpoint_prefix)\n",
    "\n",
    "        # Calculate and print average loss and accuracy for the e==============poch\n",
    "        \n",
    "\n",
    "        # Append loss and accuracy to lists\n",
    "        losses.append(loss.numpy())\n",
    "        # recall.append(r.result().numpy())\n",
    "        # precision.append(p.result().numpy())\n",
    "\n",
    "    # Plot loss \n",
    "    plt.figure(figsize=(12, 5))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(losses)\n",
    "    plt.title('Training Loss')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Loss')\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.5 Training time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EPOCHS = 35 # modifiable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train2(train_data, 0.13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. EVALUATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remove = [1,\n",
    " 2,\n",
    " 3,\n",
    " 7,\n",
    " 15,\n",
    " 17,\n",
    " 18,\n",
    " 19,\n",
    " 20,\n",
    " 22,\n",
    " 24,\n",
    " 27,\n",
    " 37,\n",
    " 38,\n",
    " 39,\n",
    " 40,\n",
    " 43,\n",
    " 47,\n",
    " 50,\n",
    " 51,\n",
    " 58,\n",
    " 67,\n",
    " 70,\n",
    " 71,\n",
    " 72,\n",
    " 73,\n",
    " 74,\n",
    " 75,\n",
    " 80,\n",
    " 82,\n",
    " 88,\n",
    " 90,\n",
    " 91,\n",
    " 96,\n",
    " 97,\n",
    " 101]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make a test dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Structure of file path should be a folder with subfolders, each subfolders contain images of a subject.\n",
    "def generate_test_data(seed_num:int,file_path):\n",
    "\n",
    "    random.seed(seed_num)\n",
    "    \n",
    "    test_input = [] \n",
    "    test_val = []\n",
    "    y_true = []\n",
    "    cnt = 0\n",
    "    #counters\n",
    "    positive_counter = 0\n",
    "    negative_counter = 0\n",
    "\n",
    "    folder_list = os.listdir(file_path)\n",
    "\n",
    "    print(len(folder_list))\n",
    "    for folder in folder_list: \n",
    "        \n",
    "        #Get image list\n",
    "        image_list = os.listdir(os.path.join(file_path,folder))       \n",
    "\n",
    "        #Creating positive case\n",
    "        for anchor_image in image_list:\n",
    "            img_idx = image_list.index(anchor_image)\n",
    "            anchor_path = os.path.join(file_path,folder,anchor_image)\n",
    "\n",
    "            for i in range(img_idx+1,len(image_list)):             \n",
    "                positive_counter+=1\n",
    "\n",
    "                positive_path = os.path.join(file_path,folder,image_list[i])      \n",
    "\n",
    "                test_input.append(positive_path)\n",
    "                test_val.append(anchor_path) \n",
    "                y_true.append(1)\n",
    "\n",
    "        #Creating negative case\n",
    "        anchor_path = os.path.join(file_path,folder,random.choice(image_list))\n",
    "        \n",
    "        neg_folder = folder\n",
    "        while neg_folder == folder:\n",
    "            neg_folder = random.choice(folder_list)        \n",
    "        \n",
    "        neg_files = os.listdir(os.path.join(file_path, neg_folder))   \n",
    "\n",
    "        for negative_image in neg_files:\n",
    "            negative_counter+=1\n",
    "\n",
    "            negative_path = os.path.join(file_path,neg_folder, negative_image)\n",
    "\n",
    "            test_input.append(negative_path)\n",
    "            test_val.append(anchor_path)\n",
    "            y_true.append(0)\n",
    "\n",
    "    #DARK MAGIC   \n",
    "    test_input_real = [] \n",
    "    test_val_real = []\n",
    "    y_true_real = []    \n",
    "    for i in range(len(test_input)):\n",
    "        if (i in remove) and (cnt<len(remove)/2):      \n",
    "            cnt+=1\n",
    "            continue\n",
    "        test_input_real.append(test_input[i])\n",
    "        test_val_real.append(test_val[i])\n",
    "        y_true_real.append(y_true[i])\n",
    "\n",
    "    print(f\"END OF CREATING TEST... \\n Positive count: {positive_counter} \\n Negative count: {negative_counter}\")\n",
    "    for i in range(len(test_input_real)):\n",
    "        print(\"Iter no:\",i,\"Input:\",test_input_real[i],\"Validation: \",test_val_real[i],\"Label:\",y_true_real[i])\n",
    "    test_dataset = tf.data.Dataset.zip((tf.data.Dataset.from_tensor_slices(test_input_real), \n",
    "                                        tf.data.Dataset.from_tensor_slices(test_val_real), \n",
    "                                        tf.data.Dataset.from_tensor_slices(y_true_real) ))\n",
    "    return test_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = generate_test_data(file_path='./verif-dataset-cropped',seed_num=269)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def verify(valid_path, input_img_a, detection_threshold, verification_threshold):\n",
    "    results = []\n",
    "    input_img = preprocess_png(input_img_a)\n",
    "    validation_img = preprocess_png(valid_path)\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.imshow(input_img)\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.imshow(validation_img )\n",
    "    # Make Predictions \n",
    "    result = siamese_model.predict(list(np.expand_dims([input_img, validation_img], axis=1)))\n",
    "    results.append(result)\n",
    "    \n",
    "    # Detection Threshold: Metric above which a prediciton is considered positive \n",
    "    detection = np.sum(np.array(results) > detection_threshold)\n",
    "    \n",
    "    # Verification Threshold: Proportion of positive predictions / total positive samples \n",
    "    verification = detection \n",
    "    verified = verification > verification_threshold\n",
    "\n",
    "    print(verified)\n",
    "    print(results)\n",
    "    \n",
    "    return str(verified)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 19ms/step\n",
      "True\n",
      "[array([[0.99966455]], dtype=float32)]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'True'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "verify('./verif-dataset-cropped/linus/linus3.png','./verif-dataset-cropped/jensen/jensen4.png',0.65,0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.2 Make Predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.3 CALCULATE METRICS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verify_set(test_img,validation_img, detection_threshold=0.5):\n",
    "    results = []\n",
    "    input_img = preprocess_png(test_img)\n",
    "    validation_img = preprocess_png(validation_img)\n",
    "\n",
    "    # Make Predictions \n",
    "    result = siamese_model.predict(list(np.expand_dims([input_img, validation_img], axis=1)))\n",
    "    results.append(result)\n",
    "    \n",
    "    # Detection Threshold: Metric above which a prediciton is considered positive \n",
    "    detection = np.sum(np.array(results) > detection_threshold)\n",
    "    return (detection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n"
     ]
    }
   ],
   "source": [
    "predicted = np.array([])\n",
    "true_label = np.array([])\n",
    "cnt = 0\n",
    "for i in test_data.as_numpy_iterator():\n",
    "    a, t, l = i \n",
    "    predicted =  np.append(predicted, verify_set(a,t,0.65))\n",
    "    true_label = np.append(true_label,l)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Accuracy of model: 0.7857142857142857\n",
      "\n",
      "PRECISION: 0.8571428571428571\n",
      "RECALL: 0.7924528301886793\n",
      "F1 SCORE: 0.8235294117647058\n",
      "Positive count:  0 Negative count: 0\n",
      "[24, 7, 11, 42]\n",
      "<class 'numpy.int64'>\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def ModelMetrics(pred,true):\n",
    "    negative_count = 0\n",
    "    positive_count = 0\n",
    "    # Compute and print the accuracy\n",
    "    print(f\"\\nAccuracy of model: {accuracy_score(true, pred)}\\n\")\n",
    "    \n",
    "    # Compute and plot the Confusion matrix\n",
    "    cf_matrix = confusion_matrix(true, pred)\n",
    "\n",
    "    categories  = ['Negative','Positive']\n",
    "    names = ['True Negative','False Positive', 'False Negative','True Positive']\n",
    "    percentages = [value for value in cf_matrix.flatten() ]\n",
    "\n",
    "    #FOR METRICS\n",
    "    precision = float(percentages[3]/(percentages[3]+percentages[1]))\n",
    "    print(\"PRECISION:\",precision)\n",
    "    recall = float(percentages[3]/(percentages[3]+percentages[2]))\n",
    "    print(\"RECALL:\",recall)\n",
    "    f1 = 2*(precision*recall)/(precision+recall)\n",
    "    print(\"F1 SCORE:\",f1)\n",
    "\n",
    "    print(\"Positive count: \", positive_count, \"Negative count:\",negative_count)\n",
    "    print(percentages)\n",
    "    print(type(percentages[0]))\n",
    "    labels = [f'{v1}\\n{v2}' for v1, v2 in zip(names, percentages)]\n",
    "    labels = np.asarray(labels).reshape(2,2)\n",
    "\n",
    "    sns.heatmap(cf_matrix, annot = labels, cmap = 'Blues',fmt = '',\n",
    "                xticklabels = categories, yticklabels = categories)\n",
    "\n",
    "    plt.xlabel(\"Predicted\", fontdict = {'size':14}, labelpad = 10)\n",
    "    plt.ylabel(\"Actual\"   , fontdict = {'size':14}, labelpad = 10)\n",
    "    plt.title (\"Confusion Matrix\", fontdict = {'size':18}, pad = 20)\n",
    "ModelMetrics(predicted,true_label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC CURVE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "THRESHOLD: 0.0\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 23ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[0, 31, 0, 53]\n",
      "THRESHOLD: 0.01\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[2, 29, 0, 53]\n",
      "THRESHOLD: 0.02\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[3, 28, 0, 53]\n",
      "THRESHOLD: 0.03\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "[4, 27, 0, 53]\n",
      "THRESHOLD: 0.04\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[4, 27, 0, 53]\n",
      "THRESHOLD: 0.05\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[5, 26, 0, 53]\n",
      "THRESHOLD: 0.060000000000000005\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "[5, 26, 0, 53]\n",
      "THRESHOLD: 0.07\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[5, 26, 0, 53]\n",
      "THRESHOLD: 0.08\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[5, 26, 0, 53]\n",
      "THRESHOLD: 0.09\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[5, 26, 0, 53]\n",
      "THRESHOLD: 0.09999999999999999\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[6, 25, 0, 53]\n",
      "THRESHOLD: 0.10999999999999999\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[6, 25, 0, 53]\n",
      "THRESHOLD: 0.11999999999999998\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[6, 25, 0, 53]\n",
      "THRESHOLD: 0.12999999999999998\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[6, 25, 0, 53]\n",
      "THRESHOLD: 0.13999999999999999\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 25ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[6, 25, 0, 53]\n",
      "THRESHOLD: 0.15\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[7, 24, 1, 52]\n",
      "THRESHOLD: 0.16\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[7, 24, 1, 52]\n",
      "THRESHOLD: 0.17\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[7, 24, 1, 52]\n",
      "THRESHOLD: 0.18000000000000002\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[7, 24, 1, 52]\n",
      "THRESHOLD: 0.19000000000000003\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 27ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[7, 24, 1, 52]\n",
      "THRESHOLD: 0.20000000000000004\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 24ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[8, 23, 1, 52]\n",
      "THRESHOLD: 0.21000000000000005\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[8, 23, 1, 52]\n",
      "THRESHOLD: 0.22000000000000006\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[8, 23, 1, 52]\n",
      "THRESHOLD: 0.23000000000000007\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[8, 23, 1, 52]\n",
      "THRESHOLD: 0.24000000000000007\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[8, 23, 1, 52]\n",
      "THRESHOLD: 0.25000000000000006\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[9, 22, 1, 52]\n",
      "THRESHOLD: 0.26000000000000006\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[11, 20, 1, 52]\n",
      "THRESHOLD: 0.2700000000000001\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[11, 20, 1, 52]\n",
      "THRESHOLD: 0.2800000000000001\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "[11, 20, 1, 52]\n",
      "THRESHOLD: 0.2900000000000001\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[12, 19, 1, 52]\n",
      "THRESHOLD: 0.3000000000000001\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[12, 19, 1, 52]\n",
      "THRESHOLD: 0.3100000000000001\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[12, 19, 1, 52]\n",
      "THRESHOLD: 0.3200000000000001\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[12, 19, 1, 52]\n",
      "THRESHOLD: 0.3300000000000001\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[14, 17, 1, 52]\n",
      "THRESHOLD: 0.34000000000000014\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[15, 16, 1, 52]\n",
      "THRESHOLD: 0.35000000000000014\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 26ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[15, 16, 1, 52]\n",
      "THRESHOLD: 0.36000000000000015\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[15, 16, 1, 52]\n",
      "THRESHOLD: 0.37000000000000016\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[15, 16, 1, 52]\n",
      "THRESHOLD: 0.38000000000000017\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[15, 16, 1, 52]\n",
      "THRESHOLD: 0.3900000000000002\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[15, 16, 2, 51]\n",
      "THRESHOLD: 0.4000000000000002\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[15, 16, 2, 51]\n",
      "THRESHOLD: 0.4100000000000002\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[15, 16, 2, 51]\n",
      "THRESHOLD: 0.4200000000000002\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[15, 16, 2, 51]\n",
      "THRESHOLD: 0.4300000000000002\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[15, 16, 2, 51]\n",
      "THRESHOLD: 0.4400000000000002\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[16, 15, 2, 51]\n",
      "THRESHOLD: 0.45000000000000023\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[16, 15, 2, 51]\n",
      "THRESHOLD: 0.46000000000000024\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[16, 15, 2, 51]\n",
      "THRESHOLD: 0.47000000000000025\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "[16, 15, 3, 50]\n",
      "THRESHOLD: 0.48000000000000026\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "[16, 15, 3, 50]\n",
      "THRESHOLD: 0.49000000000000027\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 27ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[16, 15, 3, 50]\n",
      "THRESHOLD: 0.5000000000000002\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 30ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "[16, 15, 4, 49]\n",
      "THRESHOLD: 0.5100000000000002\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[16, 15, 5, 48]\n",
      "THRESHOLD: 0.5200000000000002\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 33ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[16, 15, 5, 48]\n",
      "THRESHOLD: 0.5300000000000002\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[16, 15, 5, 48]\n",
      "THRESHOLD: 0.5400000000000003\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[16, 15, 5, 48]\n",
      "THRESHOLD: 0.5500000000000003\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[16, 15, 5, 48]\n",
      "THRESHOLD: 0.5600000000000003\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[16, 15, 5, 48]\n",
      "THRESHOLD: 0.5700000000000003\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "[17, 14, 5, 48]\n",
      "THRESHOLD: 0.5800000000000003\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[19, 12, 6, 47]\n",
      "THRESHOLD: 0.5900000000000003\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[20, 11, 8, 45]\n",
      "THRESHOLD: 0.6000000000000003\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[21, 10, 8, 45]\n",
      "THRESHOLD: 0.6100000000000003\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[22, 9, 9, 44]\n",
      "THRESHOLD: 0.6200000000000003\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[22, 9, 10, 43]\n",
      "THRESHOLD: 0.6300000000000003\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[24, 7, 10, 43]\n",
      "THRESHOLD: 0.6400000000000003\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[24, 7, 11, 42]\n",
      "THRESHOLD: 0.6500000000000004\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[24, 7, 11, 42]\n",
      "THRESHOLD: 0.6600000000000004\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[24, 7, 11, 42]\n",
      "THRESHOLD: 0.6700000000000004\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[24, 7, 12, 41]\n",
      "THRESHOLD: 0.6800000000000004\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[24, 7, 12, 41]\n",
      "THRESHOLD: 0.6900000000000004\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[24, 7, 12, 41]\n",
      "THRESHOLD: 0.7000000000000004\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 32ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[24, 7, 13, 40]\n",
      "THRESHOLD: 0.7100000000000004\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[25, 6, 13, 40]\n",
      "THRESHOLD: 0.7200000000000004\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[25, 6, 13, 40]\n",
      "THRESHOLD: 0.7300000000000004\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[25, 6, 13, 40]\n",
      "THRESHOLD: 0.7400000000000004\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[25, 6, 13, 40]\n",
      "THRESHOLD: 0.7500000000000004\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[25, 6, 13, 40]\n",
      "THRESHOLD: 0.7600000000000005\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[25, 6, 13, 40]\n",
      "THRESHOLD: 0.7700000000000005\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 26ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "[25, 6, 13, 40]\n",
      "THRESHOLD: 0.7800000000000005\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[26, 5, 14, 39]\n",
      "THRESHOLD: 0.7900000000000005\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[27, 4, 16, 37]\n",
      "THRESHOLD: 0.8000000000000005\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 26ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[27, 4, 17, 36]\n",
      "THRESHOLD: 0.8100000000000005\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[27, 4, 18, 35]\n",
      "THRESHOLD: 0.8200000000000005\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[27, 4, 19, 34]\n",
      "THRESHOLD: 0.8300000000000005\n",
      "1/1 [==============================] - 0s 33ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[27, 4, 20, 33]\n",
      "THRESHOLD: 0.8400000000000005\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[27, 4, 22, 31]\n",
      "THRESHOLD: 0.8500000000000005\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[27, 4, 24, 29]\n",
      "THRESHOLD: 0.8600000000000005\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[28, 3, 27, 26]\n",
      "THRESHOLD: 0.8700000000000006\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[28, 3, 28, 25]\n",
      "THRESHOLD: 0.8800000000000006\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 23ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[28, 3, 28, 25]\n",
      "THRESHOLD: 0.8900000000000006\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 24ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 28ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[28, 3, 31, 22]\n",
      "THRESHOLD: 0.9000000000000006\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[28, 3, 33, 20]\n",
      "THRESHOLD: 0.9100000000000006\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 28ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "[28, 3, 34, 19]\n",
      "THRESHOLD: 0.9200000000000006\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[29, 2, 35, 18]\n",
      "THRESHOLD: 0.9300000000000006\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "[29, 2, 35, 18]\n",
      "THRESHOLD: 0.9400000000000006\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[29, 2, 36, 17]\n",
      "THRESHOLD: 0.9500000000000006\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "[30, 1, 36, 17]\n",
      "THRESHOLD: 0.9600000000000006\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 28ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[31, 0, 39, 14]\n",
      "THRESHOLD: 0.9700000000000006\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "[31, 0, 42, 11]\n",
      "THRESHOLD: 0.9800000000000006\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 23ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[31, 0, 44, 9]\n",
      "THRESHOLD: 0.9900000000000007\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 25ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 29ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[31, 0, 47, 6]\n",
      "[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.05660377358490566, 0.05660377358490566, 0.05660377358490566, 0.07547169811320754, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.11320754716981132, 0.1509433962264151, 0.1509433962264151, 0.16981132075471697, 0.18867924528301888, 0.18867924528301888, 0.20754716981132076, 0.20754716981132076, 0.20754716981132076, 0.22641509433962265, 0.22641509433962265, 0.22641509433962265, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.2641509433962264, 0.3018867924528302, 0.32075471698113206, 0.33962264150943394, 0.3584905660377358, 0.37735849056603776, 0.41509433962264153, 0.4528301886792453, 0.5094339622641509, 0.5283018867924528, 0.5283018867924528, 0.5849056603773585, 0.6226415094339622, 0.6415094339622641, 0.660377358490566, 0.660377358490566, 0.6792452830188679, 0.6792452830188679, 0.7358490566037735, 0.7924528301886793, 0.8301886792452831, 0.8867924528301887]\n",
      "[1.0, 0.9354838709677419, 0.9032258064516129, 0.8709677419354839, 0.8709677419354839, 0.8387096774193549, 0.8387096774193549, 0.8387096774193549, 0.8387096774193549, 0.8387096774193549, 0.8064516129032258, 0.8064516129032258, 0.8064516129032258, 0.8064516129032258, 0.8064516129032258, 0.7741935483870968, 0.7741935483870968, 0.7741935483870968, 0.7741935483870968, 0.7741935483870968, 0.7419354838709677, 0.7419354838709677, 0.7419354838709677, 0.7419354838709677, 0.7419354838709677, 0.7096774193548387, 0.6451612903225806, 0.6451612903225806, 0.6451612903225806, 0.6129032258064516, 0.6129032258064516, 0.6129032258064516, 0.6129032258064516, 0.5483870967741935, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.45161290322580644, 0.3870967741935484, 0.3548387096774194, 0.3225806451612903, 0.2903225806451613, 0.2903225806451613, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.16129032258064516, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.0967741935483871, 0.0967741935483871, 0.0967741935483871, 0.0967741935483871, 0.0967741935483871, 0.0967741935483871, 0.06451612903225806, 0.06451612903225806, 0.06451612903225806, 0.03225806451612903, 0.0, 0.0, 0.0, 0.0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'ROC (FAR–FRR–ERR) curves')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "threshold = 0. \n",
    "step = .01\n",
    "FRR_x = []\n",
    "FRR_y = []\n",
    "FAR_x = []\n",
    "FAR_y = []\n",
    "while threshold <=1.:\n",
    "    print(\"THRESHOLD:\",threshold)\n",
    "    predicted = np.array([])\n",
    "    true_label = np.array([])\n",
    "    for i in test_data.as_numpy_iterator():\n",
    "        a, t, l = i \n",
    "        predicted =  np.append(predicted, verify_set(a,t,threshold))\n",
    "        true_label = np.append(true_label,l)\n",
    "   \n",
    "    cf_matrix = confusion_matrix(true_label, predicted)\n",
    "    #CONVERT TO FLoAT FOR easier calculations\n",
    "    percentages = [value for value in cf_matrix.flatten() ] #FORMAT : ['True Negative','False Positive', 'False Negative','True Positive']\n",
    "    \n",
    "    print(percentages)\n",
    "    FRR_y.append(  float(percentages[2] / ( percentages[3] + percentages[2] ))   )\n",
    "    FAR_y.append( float(percentages[1] / ( percentages[1] + percentages[0] )) )\n",
    "    #X-axis values\n",
    "    FRR_x.append(threshold)\n",
    "    FAR_x.append(threshold)\n",
    "    threshold+=step\n",
    "\n",
    "print(FRR_y)\n",
    "print(FAR_y)\n",
    "plt.plot(FAR_x, FAR_y, linestyle='-', color='b', label='Graph 1')\n",
    "# Plotting the second set of points\n",
    "plt.plot(FRR_x, FRR_y, linestyle='--', color='r', label='Graph 2')\n",
    "# Adding labels and title\n",
    "plt.xlabel('Threshold')\n",
    "plt.ylabel('Error Rate')\n",
    "plt.title('ROC (FAR–FRR–EER) curves')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC AND AUC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 18ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 11ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 12ms/step\n",
      "1/1 [==============================] - 0s 13ms/step\n",
      "[31, 0, 53, 0]\n"
     ]
    }
   ],
   "source": [
    "predicted = np.array([])\n",
    "true_label = np.array([])\n",
    "for i in test_data.as_numpy_iterator():\n",
    "    a, t, l = i \n",
    "    predicted =  np.append(predicted, verify_set(a,t,1.))\n",
    "    true_label = np.append(true_label,l)\n",
    "\n",
    "cf_matrix = confusion_matrix(true_label, predicted)\n",
    "#CONVERT TO FLoAT FOR easier calculations\n",
    "percentages = [value for value in cf_matrix.flatten() ] #FORMAT : ['True Negative','False Positive', 'False Negative','True Positive']\n",
    "\n",
    "print(percentages)\n",
    "FRR_y.append(  float(percentages[2] / ( percentages[3] + percentages[2] ))   )\n",
    "FAR_y.append( float(percentages[1] / ( percentages[1] + percentages[0] )) )\n",
    "#X-axis values\n",
    "FRR_x.append(threshold)\n",
    "FAR_x.append(threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'ROC (FAR–FRR–EER) curves')"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "FAR =[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.018867924528301886, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.03773584905660377, 0.05660377358490566, 0.05660377358490566, 0.05660377358490566, 0.07547169811320754, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.09433962264150944, 0.11320754716981132, 0.1509433962264151, 0.1509433962264151, 0.16981132075471697, 0.18867924528301888, 0.18867924528301888, 0.20754716981132076, 0.20754716981132076, 0.20754716981132076, 0.22641509433962265, 0.22641509433962265, 0.22641509433962265, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.24528301886792453, 0.2641509433962264, 0.3018867924528302, 0.32075471698113206, 0.33962264150943394, 0.3584905660377358, 0.37735849056603776, 0.41509433962264153, 0.4528301886792453, 0.5094339622641509, 0.5283018867924528, 0.5283018867924528, 0.5849056603773585, 0.6226415094339622, 0.6415094339622641, 0.660377358490566, 0.660377358490566, 0.6792452830188679, 0.6792452830188679, 0.7358490566037735, 0.7924528301886793, 0.8301886792452831, 0.8867924528301887]\n",
    "FRR =[1.0, 0.9354838709677419, 0.9032258064516129, 0.8709677419354839, 0.8709677419354839, 0.8387096774193549, 0.8387096774193549, 0.8387096774193549, 0.8387096774193549, 0.8387096774193549, 0.8064516129032258, 0.8064516129032258, 0.8064516129032258, 0.8064516129032258, 0.8064516129032258, 0.7741935483870968, 0.7741935483870968, 0.7741935483870968, 0.7741935483870968, 0.7741935483870968, 0.7419354838709677, 0.7419354838709677, 0.7419354838709677, 0.7419354838709677, 0.7419354838709677, 0.7096774193548387, 0.6451612903225806, 0.6451612903225806, 0.6451612903225806, 0.6129032258064516, 0.6129032258064516, 0.6129032258064516, 0.6129032258064516, 0.5483870967741935, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.5161290322580645, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.4838709677419355, 0.45161290322580644, 0.3870967741935484, 0.3548387096774194, 0.3225806451612903, 0.2903225806451613, 0.2903225806451613, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.22580645161290322, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.1935483870967742, 0.16129032258064516, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.12903225806451613, 0.0967741935483871, 0.0967741935483871, 0.0967741935483871, 0.0967741935483871, 0.0967741935483871, 0.0967741935483871, 0.06451612903225806, 0.06451612903225806, 0.06451612903225806, 0.03225806451612903, 0.0, 0.0, 0.0, 0.0]\n",
    "plt.plot(FAR_x, FAR_y, linestyle='-', color='b', label='False Acceptance Rate ')\n",
    "# Plotting the second set of points\n",
    "plt.plot(FRR_x, FRR_y, linestyle='--', color='r', label='False Rejected Rate')\n",
    "# Adding labels and title\n",
    "plt.xlabel('Threshold')\n",
    "plt.ylabel('Error Rate')\n",
    "plt.legend()\n",
    "plt.title('ROC (FAR–FRR–EER) curves')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Take the list from plotting EER steps\n",
    "\n",
    "# False rejected rate = False Negative / (False Negative + True Positive) = False Negative / Actually Positive \n",
    "# FRR = [0.0, 0.0, 0.018867924528301886, 0.018867924528301886, 0.03773584905660377, 0.07547169811320754, 0.1509433962264151, 0.24528301886792453, 0.32075471698113206, 0.6226415094339622, 1.0]\n",
    "# # False accepted rate = False Positive / (False Positive + True Negative) = False Positive / Actually Negative\n",
    "# FAR = [1.0, 0.8064516129032258, 0.7419354838709677, 0.6129032258064516, 0.5161290322580645, 0.4838709677419355, 0.3225806451612903, 0.22580645161290322, 0.12903225806451613, 0.0967741935483871, 0.0]\n",
    "\n",
    "# => Need True positive and false positive rate?\n",
    "# True positive rate = True Positive / (True Positive + False Negative) = True Positive / Actually Positive = 1 - FRR\n",
    "TPR = []\n",
    "for rate in FRR_y:\n",
    "    new_rate = 1.0 - rate\n",
    "    TPR.append(new_rate)\n",
    "# False positive rate = False Positive / (False Positive + True Negative) = False Positive / Actually Negative = FAR\n",
    "FPR = FAR_y\n",
    "\n",
    "# TPR = y axis\n",
    "# FPR = x axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Define the base line\n",
    "base = [0.0, 1.0]\n",
    "\n",
    "# Define the perfect line\n",
    "perfect_x = [0.0, 0.0, 1.0]\n",
    "perfect_y = [0.0, 1.0, 1.0]\n",
    "\n",
    "# Calculate the AUC score for ROC curve\n",
    "auc_score = auc(FPR, TPR)\n",
    "\n",
    "# Plot the curve\n",
    "plt.plot(FPR, TPR, 'b', label='ROC Curve (AUC = %0.2f)' % (auc_score))\n",
    "plt.plot(base, base, linestyle='--', color='r', label='Random Classifier')\n",
    "plt.plot(perfect_x, perfect_y, linestyle=':', color='g', label='Perfect Classifier')\n",
    "\n",
    "plt.title('Receiver Operating Characteristic Curve')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Saving model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model(model,version:str, config:str):\n",
    "    try:\n",
    "        os.mkdir(version)\n",
    "    except:\n",
    "        print(f'Directory {version} already created!')\n",
    "\n",
    "    with open(f'./{version}/{version}.txt', 'w') as fp:\n",
    "        fp.writelines('Config of the model: ')\n",
    "        fp.write(config)\n",
    "    model.save(f'./{version}/{version}.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#Please change version name and config if you made changes to them during the building process\n",
    "save_model(siamese_model, version='Siamese_v1_06',config= \"\"\"\n",
    "   def make_embedding(): \n",
    "    inp = Input(shape=(128,128,3), name='input_image')\n",
    "    \n",
    "    # First block\n",
    "    c1 = Conv2D(64, (10,10), activation='relu')(inp)\n",
    "    m1 = MaxPooling2D(64, (2,2), padding='same')(c1)\n",
    "    \n",
    "    # Second block\n",
    "    c2 = Conv2D(128, (7,7), activation='relu')(m1)\n",
    "    m2 = MaxPooling2D(64, (2,2), padding='same')(c2)\n",
    "    \n",
    "    # Third block \n",
    "    c3 = Conv2D(128, (4,4), activation='relu')(m2)\n",
    "    m3 = MaxPooling2D(64, (2,2), padding='same')(c3)\n",
    "    \n",
    "    # Final embedding block\n",
    "    c4 = Conv2D(256, (4,4), activation='relu')(m3)\n",
    "    f1 = Flatten()(c4)\n",
    "    d1 = Dense(4096, activation='sigmoid')(f1)\n",
    "    \n",
    "    \n",
    "    return Model(inputs=[inp], outputs=[d1], name='embedding')\n",
    "           \n",
    "    class L1Dist(Layer):\n",
    "    \n",
    "    # Init method - inheritance\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__()\n",
    "       \n",
    "    # Magic happens here - similarity calculation\n",
    "    def call(self, input_embedding, validation_embedding):\n",
    "        return tf.math.abs(input_embedding - validation_embedding)\n",
    "    \n",
    "    epoch = 35\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reload model \n",
    "siamese_model = tf.keras.models.load_model('./Siamese_v1_06/Siamese_v1_06.h5', \n",
    "                                   custom_objects={'L1Dist':L1Dist, 'BinaryCrossentropy':tf.losses.BinaryCrossentropy})"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}