model_DO_eval.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a9344b13-5d46-4d6e-85fd-95ece7f26f12",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import Sequential, layers, Input\n",
    "from tensorflow.keras.layers import Dense, BatchNormalization, Dropout, LSTM\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.callbacks import LearningRateScheduler\n",
    "import tensorflow.keras.backend as K\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.initializers import Constant\n",
    "from tensorflow.keras.initializers import RandomNormal, HeNormal, GlorotNormal\n",
    "import cv2\n",
    "\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5f2cfebb-b980-41ab-bb7d-466b46f59da8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_DO_label(val):\n",
    "    if val <= 7.0:\n",
    "    \treturn \"DO_S\"\n",
    "    elif val <= 8.0:\n",
    "    \treturn \"DO_M\"\n",
    "    elif val <= 9.0:\n",
    "    \treturn \"DO_L\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "250e5dfe-6159-400e-b997-b7259cd61507",
   "metadata": {},
   "outputs": [],
   "source": [
    "APRIL_DO = 9.0\n",
    "MAY_DO = 8.4\n",
    "JUNE_DO = 8.5\n",
    "JULY_DO = 6.4\n",
    "AUGUST_DO = 8.1\n",
    "SEPTEMBER_DO = 7.7\n",
    "OCTOBER_DO = 7.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "acb0c7db-acd2-4899-a4f4-b92e9ed3f33b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "April DO: 9.0\n",
      "May DO: 8.4\n",
      "June DO: 8.5\n",
      "July DO: 6.4\n",
      "August DO: 8.1\n",
      "September DO: 7.7\n",
      "October DO: 7.8\n"
     ]
    }
   ],
   "source": [
    "print(\"April DO:\", APRIL_DO)\n",
    "print(\"May DO:\", MAY_DO)\n",
    "print(\"June DO:\", JUNE_DO)\n",
    "print(\"July DO:\", JULY_DO)\n",
    "print(\"August DO:\", AUGUST_DO)\n",
    "print(\"September DO:\", SEPTEMBER_DO)\n",
    "print(\"October DO:\", OCTOBER_DO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1d030557-7ea1-46b1-ad5e-b9d6112dda11",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder_paths = ['./水質檢測/Image_data/1_April',\n",
    "                './水質檢測/Image_data/2_May',\n",
    "                './水質檢測/Image_data/3_June',\n",
    "                './水質檢測/Image_data/4_July',\n",
    "                './水質檢測/Image_data/5_August',\n",
    "                './水質檢測/Image_data/6_September']\n",
    "labels = [get_DO_label(APRIL_DO), get_DO_label(MAY_DO), get_DO_label(JUNE_DO), \n",
    "          get_DO_label(JULY_DO), get_DO_label(AUGUST_DO), get_DO_label(SEPTEMBER_DO)]  # 对应文件夹1和文件夹2的标签\n",
    "\n",
    "\n",
    "oct_paths = [\"./水質檢測/Image_data/7_October\"]\n",
    "oct_label_Stirng = [get_DO_label(OCTOBER_DO)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1e1020a6-c9cf-4e71-838e-fecae3b2a5ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import os\n",
    "\n",
    "def load_and_label_images(folder_path, label):\n",
    "    image_paths = []  # 存储图像文件的路径\n",
    "    labels = []       # 存储图像对应的标签\n",
    "\n",
    "    # 获取文件夹中的所有图像文件的路径\n",
    "    for filename in os.listdir(folder_path):\n",
    "        if filename.endswith('.jpg') or filename.endswith('.png'):  # 假设只加载jpg和png格式的图像文件\n",
    "            image_paths.append(os.path.join(folder_path, filename))\n",
    "            labels.append(label)\n",
    "\n",
    "    # 加载图像并为其指定标签\n",
    "    images = [tf.io.read_file(image_path) for image_path in image_paths]\n",
    "    images = [tf.image.decode_image(image, channels=3) for image in images]\n",
    "\n",
    "    # 可选的数据预处理：这里假设对图像进行归一化\n",
    "    #images = [tf.cast(image, tf.float32) / 255.0 for image in images]\n",
    "\n",
    "    return images, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c2761818-94fc-4df7-a0bd-4ce6cef4c993",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 你可以根据需要加载多个文件夹中的图像并为其指定不同的标签\n",
    "# folder_paths = ['/path/to/folder1', '/path/to/folder2']\n",
    "# labels = [1, 2]  # 对应文件夹1和文件夹2的标签\n",
    "\n",
    "# 加载所有文件夹中的图像和标签\n",
    "all_images = []\n",
    "all_labels = []\n",
    "for folder_path, label in zip(folder_paths, labels):\n",
    "    images, labels = load_and_label_images(folder_path, label)\n",
    "    all_images.extend(images)\n",
    "    all_labels.extend(labels)\n",
    "    \n",
    "\n",
    "oct_images = []\n",
    "oct_labels = []\n",
    "for oct_path, label in zip(oct_paths, oct_label_Stirng):\n",
    "    images, labels = load_and_label_images(oct_path, oct_label_Stirng)\n",
    "    images_resized = [tf.image.resize(img, (224, 224)) for img  in images]\n",
    "    oct_images.extend(images_resized)\n",
    "    oct_labels.extend(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f19c5df3-cafb-47de-a5ed-fbcf13e98e68",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(all_labels)\n",
    "# print(oct_labels)\n",
    "\n",
    "label_mapping = {\n",
    "    \"DO_S\":tf.constant([1,0,0], dtype=tf.float32),\n",
    "    \"DO_M\":tf.constant([0,1,0], dtype=tf.float32),\n",
    "    \"DO_L\":tf.constant([0,0,1], dtype=tf.float32)\n",
    "}\n",
    "\n",
    "# unique_labels_list = list(set(all_labels))\n",
    "# unique_labels_list.sort()\n",
    "# label_to_index = {label: index for index, label in enumerate(unique_labels_list)}\n",
    "# label_one_hot = [tf.one_hot(label_to_index[label], len(unique_labels_list)) for label in all_labels]\n",
    "label_one_hot = [label_mapping[label] for label in all_labels]\n",
    "oct_label_one_hot = [label_mapping[label[0]] for label in oct_labels]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "299027d8-c4b0-489e-891e-422ab9ed73cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9728\n",
      "(224, 224, 3)\n",
      "9728\n",
      "[<tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 1.], dtype=float32)>]\n",
      "=============================\n",
      "625\n",
      "(224, 224, 3)\n",
      "625\n",
      "[<tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>, <tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 1., 0.], dtype=float32)>]\n"
     ]
    }
   ],
   "source": [
    "print(len(all_images))\n",
    "print(all_images[0].shape)\n",
    "print(len(label_one_hot))\n",
    "print(label_one_hot[0:10])\n",
    "\n",
    "print(\"=============================\")\n",
    "\n",
    "print(len(oct_images))\n",
    "print(oct_images[0].shape)\n",
    "print(len(oct_label_one_hot))\n",
    "print(oct_label_one_hot[0:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "eef6c3ba-a682-4c61-b457-50e33ab78d0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "train_images, validation_images, train_labels, validation_labels = train_test_split(all_images, label_one_hot, test_size=0.2, random_state=42)\n",
    "\n",
    "# 创建训练集数据集\n",
    "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_labels))\n",
    "train_dataset = train_dataset.shuffle(buffer_size=len(train_images)).batch(batch_size=32)\n",
    "\n",
    "# 创建验证集数据集\n",
    "validation_dataset = tf.data.Dataset.from_tensor_slices((validation_images, validation_labels))\n",
    "validation_dataset = validation_dataset.shuffle(buffer_size=len(validation_images)).batch(batch_size=32)\n",
    "\n",
    "# 創建測試資料集\n",
    "test_dataset = tf.data.Dataset.from_tensor_slices((oct_images, oct_label_one_hot))\n",
    "test_dataset = test_dataset.shuffle(buffer_size=len(oct_images)).batch(batch_size=32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7eed6b3a-5282-45a6-ae23-1d73dd8c2e80",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# 定义一个简单的卷积神经网络模型\n",
    "def create_model():\n",
    "    model = tf.keras.Sequential([\n",
    "    tf.keras.layers.Conv2D(16, (3, 3), activation='relu', input_shape=(224, 224, 3)),\n",
    "    tf.keras.layers.MaxPooling2D((2, 2)),\n",
    "    # tf.keras.layers.Dropout(0.1),\n",
    "    tf.keras.layers.Conv2D(8, (3, 3), activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D((2, 2)),\n",
    "    tf.keras.layers.Dropout(0.1), \n",
    "    tf.keras.layers.Conv2D(4, (3, 3), activation='relu'),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(64, activation='relu'),\n",
    "    tf.keras.layers.Dropout(0.1),   \n",
    "    tf.keras.layers.Dense(3, activation='softmax')\n",
    "])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8a8e2b02-322c-458e-a940-760eda8a596d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/future-outlier/miniconda3/envs/dev/lib/python3.9/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
      "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "model = create_model()\n",
    "\n",
    "model.compile(optimizer='adam',\n",
    "              loss=tf.keras.losses.categorical_crossentropy,\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d3d64ebf-833b-425f-a994-6b33c2d1b930",
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n",
    "    filepath='best_DO_model.keras',  # 保存模型的文件路径\n",
    "    monitor='val_accuracy',    # 监控的指标，可以是'val_loss'或'val_accuracy'\n",
    "    save_best_only=True,       # 仅保存最好的模型\n",
    "    mode='max',                # 对于准确率，使用'max'模式\n",
    "    verbose=1                  # 输出详细日志信息\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "bdbf26ea-58a1-4ac1-b561-b5982ec4dcc2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "\u001b[1m243/244\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 68ms/step - accuracy: 0.6859 - loss: 4.0533\n",
      "Epoch 1: val_accuracy improved from -inf to 0.98304, saving model to best_DO_model.keras\n",
      "\u001b[1m244/244\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 72ms/step - accuracy: 0.6869 - loss: 4.0297 - val_accuracy: 0.9830 - val_loss: 0.0868\n",
      "Epoch 2/2\n",
      "\u001b[1m243/244\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 68ms/step - accuracy: 0.9656 - loss: 0.1090\n",
      "Epoch 2: val_accuracy improved from 0.98304 to 0.98921, saving model to best_DO_model.keras\n",
      "\u001b[1m244/244\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 72ms/step - accuracy: 0.9656 - loss: 0.1087 - val_accuracy: 0.9892 - val_loss: 0.0251\n"
     ]
    }
   ],
   "source": [
    "result = model.fit(train_dataset, \n",
    "                   validation_data=validation_dataset, \n",
    "                   epochs=2,verbose=1, \n",
    "                   callbacks=[checkpoint_callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d76e0816-e69b-4979-a278-476f53b0ffc3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(result.history['accuracy'], label='accuracy')\n",
    "plt.plot(result.history['val_accuracy'], label = 'val_accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.ylim([0, 1])\n",
    "plt.legend(loc='lower right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6b14ee1f-9751-4a02-9c76-f351b55b5853",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n"
     ]
    }
   ],
   "source": [
    "# from time import datetime\n",
    "# model_name = \"model\" + datetime.now().strftime(\"%Y-%m-%d\") + \".h5\"\n",
    "model_name = \"DO_model.h5\"\n",
    "model.save(model_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "362bbd20-4f25-4e4f-952d-31b35f433141",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.models.load_model(model_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "9bae1800-391d-4658-9dba-39906a80f26b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m20/20\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step\n",
      "Confusion Matrix:\n",
      "[[  0   0   0]\n",
      " [ 77   2 546]\n",
      " [  0   0   0]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "# 使用model預測\n",
    "predictions = model.predict(test_dataset)\n",
    "# 轉換成class index\n",
    "predicted_classes_index = np.argmax(predictions, axis=1)\n",
    "true_classes_index = np.argmax([label.numpy() for label in oct_label_one_hot], axis=1)\n",
    "\n",
    "# 計算confusion matrix\n",
    "conf_matrix = confusion_matrix(true_classes_index, predicted_classes_index)\n",
    "\n",
    "print(\"Confusion Matrix:\")\n",
    "print(conf_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e3c3235-997a-4c2c-a326-dd254a12d9f7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98c59e03-b791-42a3-a15f-561c754f7edd",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}