{"cells":[{"metadata":{},"cell_type":"markdown","source":""},{"metadata":{},"cell_type":"markdown","source":"<center><img src=\"https://raw.githubusercontent.com/dimitreOliveira/MachineLearning/master/Kaggle/Flower%20Classification%20with%20TPUs/banner.png\" width=\"1000\"></center>\n<br>\n<center><h1>Flower Classification with TPUs - EDA and Baseline</h1></center>\n<br>\n\n\n> Tham khảo từ [work of](https://www.kaggle.com/mgornergoogle/getting-started-with-100-flowers-on-tpu) Martin Görner"},{"metadata":{},"cell_type":"markdown","source":"## Mô tả dữ liệu đầu vào"},{"metadata":{},"cell_type":"markdown","source":"Bộ data bao gồm hình ảnh của nhiều bông hoa. Nhiệm vụ là xây dựng một bộ phân loại hình ảnh bông hoa này thuộc loài hoa nào.\n\nCác file hình ảnh được lưu dưới dạng tfrecord. Định dạng TFRecord là định dạng vùng chứa thường được sử dụng trong Tensorflow để nhóm và phân đoạn các tệp dữ liệu dữ liệu nhằm đạt được tốc độ đào tạo tối ưu. Mỗi file gồm id, label ( class của sample,dành cho dữ liệu train và img cho nhiều hình ảnh.\n\n    - train/*.tfrec: các training sample, bao gồm các nhãn \n    - val/*.tfrec: các pre-split training samples với các nhãn  nhằm kiểm tra hiệu suất model trên TPU.\n    - test/*.tfrec: các sample không có nhãn  - dùng để dự đoán hoa trong hình thuộc loại nào\n    - sample_submission.csv: file kết quả với định dạng như sau\n        - id: ID duy nhất cho mỗi sample\n        -label( training data) loại hoa được đại diện bởi mẫu"},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"_kg_hide-input":true,"_kg_hide-output":true},"cell_type":"code","source":"!pip install --quiet efficientnet\n\nimport math, os, re, warnings, random\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nfrom matplotlib import pyplot as plt\nfrom kaggle_datasets import KaggleDatasets\nfrom sklearn.utils import class_weight\nfrom sklearn.metrics import classification_report, confusion_matrix\nimport tensorflow as tf\n\nimport tensorflow.keras.layers as L\nfrom tensorflow import keras\nfrom tensorflow.keras import optimizers, applications, Sequential, losses\nfrom tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, LearningRateScheduler\nimport efficientnet.tfkeras as efn\n\ndef seed_everything(seed=0):\n    random.seed(seed)\n    np.random.seed(seed)\n    tf.random.set_seed(seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    os.environ['TF_DETERMINISTIC_OPS'] = '1'\n\nseed = 0\nseed_everything(seed)\nwarnings.filterwarnings(\"ignore\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Cấu hình TPU "},{"metadata":{"trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"# Phát hiện  TPU hoặc GPU \n# Phát hiện phần cứng, return distribution strategy phù hợp\ntry:\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()\n    print(f'Running on TPU {tpu.master()}')\nexcept ValueError:\n    tpu = None\n\nif tpu:\n    tf.config.experimental_connect_to_cluster(tpu)\n    tf.tpu.experimental.initialize_tpu_system(tpu)\n    strategy = tf.distribute.experimental.TPUStrategy(tpu)\nelse:\n    strategy = tf.distribute.get_strategy()\n\nAUTO = tf.data.experimental.AUTOTUNE\nREPLICAS = strategy.num_replicas_in_sync\nprint(f'REPLICAS: {REPLICAS}')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Model parameters"},{"metadata":{"trusted":true},"cell_type":"code","source":"BATCH_SIZE = 16 * REPLICAS\nWARMUP_EPOCHS = 3\nWARMUP_LEARNING_RATE = 1e-4 * REPLICAS\nEPOCHS = 20\nLEARNING_RATE = 3e-5 * REPLICAS\nHEIGHT = 512\nWIDTH = 512\nCHANNELS = 3\nN_CLASSES = 104\nES_PATIENCE = 5","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model_path = f'model_{HEIGHT}x{WIDTH}.h5'\n\nGCS_PATH = KaggleDatasets().get_gcs_path('tpu-getting-started') + f'/tfrecords-jpeg-{HEIGHT}x{WIDTH}'\n\nTRAINING_FILENAMES = tf.io.gfile.glob(GCS_PATH + '/train/*.tfrec')\nVALIDATION_FILENAMES = tf.io.gfile.glob(GCS_PATH + '/val/*.tfrec')\nTEST_FILENAMES = tf.io.gfile.glob(GCS_PATH + '/test/*.tfrec')\n\nCLASSES = [\n    'pink primrose', 'hard-leaved pocket orchid', 'canterbury bells', 'sweet pea', \n    'wild geranium', 'tiger lily', 'moon orchid', 'bird of paradise', 'monkshood', \n    'globe thistle', 'snapdragon', \"colt's foot\", 'king protea', 'spear thistle', \n    'yellow iris', 'globe-flower', 'purple coneflower', 'peruvian lily', \n    'balloon flower', 'giant white arum lily', 'fire lily', 'pincushion flower', \n    'fritillary', 'red ginger', 'grape hyacinth', 'corn poppy', \n    'prince of wales feathers', 'stemless gentian', 'artichoke', 'sweet william', \n    'carnation', 'garden phlox', 'love in the mist', 'cosmos',  'alpine sea holly', \n    'ruby-lipped cattleya', 'cape flower', 'great masterwort',  'siam tulip', \n    'lenten rose', 'barberton daisy', 'daffodil',  'sword lily', 'poinsettia', \n    'bolero deep blue',  'wallflower', 'marigold', 'buttercup', 'daisy', \n    'common dandelion', 'petunia', 'wild pansy', 'primula',  'sunflower', \n    'lilac hibiscus', 'bishop of llandaff', 'gaura',  'geranium', 'orange dahlia', \n    'pink-yellow dahlia', 'cautleya spicata',  'japanese anemone', \n    'black-eyed susan', 'silverbush', 'californian poppy',  'osteospermum', \n    'spring crocus', 'iris', 'windflower',  'tree poppy', 'gazania', 'azalea', \n    'water lily',  'rose', 'thorn apple', 'morning glory', 'passion flower',  \n    'lotus', 'toad lily', 'anthurium', 'frangipani',  'clematis', 'hibiscus', \n    'columbine', 'desert-rose', 'tree mallow', 'magnolia', 'cyclamen ', \n    'watercress',  'canna lily', 'hippeastrum ', 'bee balm', 'pink quill',  \n    'foxglove', 'bougainvillea', 'camellia', 'mallow',  'mexican petunia',  \n    'bromelia', 'blanket flower', 'trumpet creeper',  'blackberry lily', \n    'common tulip', 'wild rose']","execution_count":null,"outputs":[]},{"metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"# Một số hàm sử dụng cho tập dữ liệu\nAUTO = tf.data.experimental.AUTOTUNE # Đọc API từ nhiều tệp nếu có\n\ndef decode_image(image_data):\n    image = tf.image.decode_jpeg(image_data, channels=3)\n    image = tf.cast(image, tf.float32) / 255.0\n    image = tf.reshape(image, [HEIGHT, WIDTH, 3])\n    return image\n\n#đọc data có nhãn (Train và val)\ndef read_labeled_tfrecord(example):\n    LABELED_TFREC_FORMAT = {\n        \"image\": tf.io.FixedLenFeature([], tf.string), # tf.string means bytestring\n        \"class\": tf.io.FixedLenFeature([], tf.int64),  # shape [] means single element\n    }\n    example = tf.io.parse_single_example(example, LABELED_TFREC_FORMAT)\n    image = decode_image(example['image'])\n    label = tf.cast(example['class'], tf.int32)\n    return image, label\n\n#đọc data không nhãn (test)\ndef read_unlabeled_tfrecord(example):\n    UNLABELED_TFREC_FORMAT = {\n        \"image\": tf.io.FixedLenFeature([], tf.string), # tf.string means bytestring\n        \"id\": tf.io.FixedLenFeature([], tf.string),  # shape [] means single element\n        \n    }\n    example = tf.io.parse_single_example(example, UNLABELED_TFREC_FORMAT)\n    image = decode_image(example['image'])\n    idnum = example['id']\n    return image, idnum # trả về tập dữ liệu các hình ảnh\n\ndef load_dataset(filenames, labeled=True, ordered=False):\n    ignore_order = tf.data.Options()\n    if not ordered:\n        ignore_order.experimental_deterministic = False \n\n    dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTO) # Tự động xen kẽ các lần đọc từ nhiều file\n    dataset = dataset.with_options(ignore_order) \n    dataset = dataset.map(read_labeled_tfrecord if labeled else read_unlabeled_tfrecord, num_parallel_calls=AUTO)\n    # Trả về dataset của các cặp (image, label) nếu được gắn nhãn = True hoặc các cặp (image, id)  nếu được gắn nhãn = False\n    return dataset\n\ndef data_augment(image, label):\n    crop_size = tf.random.uniform([], int(HEIGHT*.7), HEIGHT, dtype=tf.int32)\n        \n    image = tf.image.random_flip_left_right(image)\n    image = tf.image.random_flip_up_down(image)\n    image = tf.image.random_saturation(image, lower=0, upper=2)\n    image = tf.image.random_crop(image, size=[crop_size, crop_size, CHANNELS])\n    image = tf.image.resize(image, size=[HEIGHT, WIDTH])\n\n    return image, label\n\ndef get_training_dataset():\n    dataset = load_dataset(TRAINING_FILENAMES, labeled=True)\n    dataset = dataset.map(data_augment, num_parallel_calls=AUTO)\n    dataset = dataset.repeat() \n    dataset = dataset.shuffle(2048)\n    dataset = dataset.batch(BATCH_SIZE)\n    dataset = dataset.prefetch(AUTO)\n    return dataset\n\ndef get_training_dataset_preview(ordered=True):\n    dataset = load_dataset(TRAINING_FILENAMES, labeled=True, ordered=ordered)\n    dataset = dataset.batch(BATCH_SIZE)\n    dataset = dataset.cache()\n    dataset = dataset.prefetch(AUTO)\n    return dataset\n\ndef get_validation_dataset(ordered=False):\n    dataset = load_dataset(VALIDATION_FILENAMES, labeled=True, ordered=ordered)\n    dataset = dataset.batch(BATCH_SIZE)\n    dataset = dataset.cache()\n    dataset = dataset.prefetch(AUTO)\n    return dataset\n\ndef get_test_dataset(ordered=False):\n    dataset = load_dataset(TEST_FILENAMES, labeled=False, ordered=ordered)\n    dataset = dataset.batch(BATCH_SIZE)\n    dataset = dataset.prefetch(AUTO)\n    return dataset\n\ndef count_data_items(filenames):\n    # số lượng mục dữ liệu được viết dưới tên .tfrec files, tức là flowers00-230.tfrec = 230 mục dữ liệu\n    n = [int(re.compile(r\"-([0-9]*)\\.\").search(filename).group(1)) for filename in filenames]\n    return np.sum(n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"# Các hàm trực quan hóa \nnp.set_printoptions(threshold=15, linewidth=80)\n\ndef batch_to_numpy_images_and_labels(data):\n    images, labels = data\n    numpy_images = images.numpy()\n    numpy_labels = labels.numpy()\n    if numpy_labels.dtype == object: \n        numpy_labels = [None for _ in enumerate(numpy_images)]\n    \n    return numpy_images, numpy_labels\n\ndef title_from_label_and_target(label, correct_label):\n    if correct_label is None:\n        return CLASSES[label], True\n    correct = (label == correct_label)\n    return \"{} [{}{}{}]\".format(CLASSES[label], 'OK' if correct else 'NO', u\"\\u2192\" if not correct else '',\n                                CLASSES[correct_label] if not correct else ''), correct\n\ndef display_one_flower(image, title, subplot, red=False, titlesize=16):\n    plt.subplot(*subplot)\n    plt.axis('off')\n    plt.imshow(image)\n    if len(title) > 0:\n        plt.title(title, fontsize=int(titlesize) if not red else int(titlesize/1.2), color='red' if red else 'black', fontdict={'verticalalignment':'center'}, pad=int(titlesize/1.5))\n    return (subplot[0], subplot[1], subplot[2]+1)\n\ndef display_batch_of_images(databatch, predictions=None):\n    \"\"\"This will work with:\n    display_batch_of_images(images)\n    display_batch_of_images(images, predictions)\n    display_batch_of_images((images, labels))\n    display_batch_of_images((images, labels), predictions)\n    \"\"\"\n    # data\n    images, labels = batch_to_numpy_images_and_labels(databatch)\n    if labels is None:\n        labels = [None for _ in enumerate(images)]\n        \n   \n    rows = int(math.sqrt(len(images)))\n    cols = len(images)//rows\n        \n    # size , spacing\n    FIGSIZE = 13.0\n    SPACING = 0.1\n    subplot=(rows,cols,1)\n    if rows < cols:\n        plt.figure(figsize=(FIGSIZE,FIGSIZE/cols*rows))\n    else:\n        plt.figure(figsize=(FIGSIZE/rows*cols,FIGSIZE))\n    \n    # display\n    for i, (image, label) in enumerate(zip(images[:rows*cols], labels[:rows*cols])):\n        title = '' if label is None else CLASSES[label]\n        correct = True\n        if predictions is not None:\n            title, correct = title_from_label_and_target(predictions[i], label)\n        dynamic_titlesize = FIGSIZE*SPACING/max(rows,cols)*40+3 # magic formula tested to work from 1x1 to 10x10 images\n        subplot = display_one_flower(image, title, subplot, not correct, titlesize=dynamic_titlesize)\n    \n    #layout\n    plt.tight_layout()\n    if label is None and predictions is None:\n        plt.subplots_adjust(wspace=0, hspace=0)\n    else:\n        plt.subplots_adjust(wspace=SPACING, hspace=SPACING)\n    plt.show()\n    \n# Trực quan hóa các dự đoán mô hình\ndef dataset_to_numpy_util(dataset, N):\n    dataset = dataset.unbatch().batch(N)\n    for images, labels in dataset:\n        numpy_images = images.numpy()\n        numpy_labels = labels.numpy()\n        break;  \n    return numpy_images, numpy_labels\n\ndef title_from_label_and_target(label, correct_label):\n    label = np.argmax(label, axis=-1)\n    correct = (label == correct_label)\n    return \"{} [{}{}{}]\".format(CLASSES[label], str(correct), ', shoud be ' if not correct else '',\n                                CLASSES[correct_label] if not correct else ''), correct\n\ndef display_one_flower_eval(image, title, subplot, red=False):\n    plt.subplot(subplot)\n    plt.axis('off')\n    plt.imshow(image)\n    plt.title(title, fontsize=14, color='red' if red else 'black')\n    return subplot+1\n\ndef display_9_images_with_predictions(images, predictions, labels):\n    subplot=331\n    plt.figure(figsize=(13,13))\n    for i, image in enumerate(images):\n        title, correct = title_from_label_and_target(predictions[i], labels[i])\n        subplot = display_one_flower_eval(image, title, subplot, not correct)\n        if i >= 8:\n            break;\n              \n    plt.tight_layout()\n    plt.subplots_adjust(wspace=0.1, hspace=0.1)\n    plt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# EDA\n\n## Sơ lược về datasets"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"# Train data\nNUM_TRAINING_IMAGES = count_data_items(TRAINING_FILENAMES)\ntrain_dataset = get_training_dataset_preview(ordered=True)\ny_train = next(iter(train_dataset.unbatch().map(lambda image, label: label).batch(NUM_TRAINING_IMAGES))).numpy()\nprint(f'Number of training images {NUM_TRAINING_IMAGES}')\n\n# Validation data\nNUM_VALIDATION_IMAGES = count_data_items(VALIDATION_FILENAMES)\nvalid_dataset = get_validation_dataset(ordered=True)\ny_valid = next(iter(valid_dataset.unbatch().map(lambda image, label: label).batch(NUM_VALIDATION_IMAGES))).numpy()\nprint(f'Number of validation images {NUM_VALIDATION_IMAGES}')\n\n# Test data\nNUM_TEST_IMAGES = count_data_items(TEST_FILENAMES)\nprint(f'Number of test images {NUM_TEST_IMAGES}')\ntest_dataset = get_test_dataset(ordered=True)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Một số mẫu từ dataset\n\n### Train samples"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"display_batch_of_images(next(iter(train_dataset.unbatch().batch(20))))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Validation samples"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"display_batch_of_images(next(iter(valid_dataset.unbatch().batch(20))))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Test samples"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"display_batch_of_images(next(iter(test_dataset.unbatch().batch(20))))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Nhận xét ban đầu khi xem qua các mẫu: chất lượng hình ảnh trong dataset có vẻ rất nhất quán trên toàn bộ tập dữ liệu. Điều này sẽ giúp mô hình dễ dàng tổng quát hóa hơn, tập dữ liệu cũng có vẻ khá đa dạng về loại hoa, nhưng chúng ta sẽ xem xét điều này một cách chi tiết hơn ."},{"metadata":{},"cell_type":"markdown","source":"## Phân phối nhãn"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"train_agg = np.asarray([[label, (y_train == index).sum()] for index, label in enumerate(CLASSES)])\nvalid_agg = np.asarray([[label, (y_valid == index).sum()] for index, label in enumerate(CLASSES)])\n\nfig, (ax1, ax2) = plt.subplots(2, 1, figsize=(24, 64))\n\nax1 = sns.barplot(x=train_agg[...,1], y=train_agg[...,0], order=CLASSES, ax=ax1)\nax1.set_title('Train', fontsize=30)\nax1.tick_params(labelsize=16)\n\nax2 = sns.barplot(x=valid_agg[...,1], y=valid_agg[...,0], order=CLASSES, ax=ax2)\nax2.set_title('Validation', fontsize=30)\nax2.tick_params(labelsize=16)\n\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Như chúng ta có thể thấy các bộ dữ liệu phần lớn không cân bằng, nhưng bộ xác thực và bộ xác nhận có sự phân phối tương tự."},{"metadata":{"trusted":true},"cell_type":"code","source":"for img, label in train_dataset.take(1):\n    data = [img[0:32,:,:,:].numpy(),label[0:32].numpy()]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"data[0].shape[1:4]","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Model"},{"metadata":{},"cell_type":"markdown","source":"Mô hình sử dụng trong bài toán này là mạng neuron tích chập (CNN) - một trong những mô hình Deep Learning tiên tiến giúp cho chúng ta xây dựng được những hệ thống thông minh với độ chính xác cao hơn hiện nay. Trong đó, xác định đối tượng và nhận dạng khuôn mặt là 1 trong số những lĩnh vực mà CNN được sử dụng rộng rãi. CNN phân loại hình ảnh bằng cách lấy 1 hình ảnh đầu vào, xử lý và phân loại nó theo các hạng mục nhất định. Dựa trên độ phân giải hình ảnh, máy tính sẽ thấy H x W x D.","attachments":{}},{"metadata":{},"cell_type":"markdown","source":"## Convulution là gì?\nTích chập được sử dụng đầu tiên trong xử lý tín hiệu số (Signal processing). Nhờ vào nguyên lý biến đổi thông tin, các nhà khoa học đã áp dụng kỹ thuật này vào xử lý ảnh và video số.\n\nĐể dễ hình dung, ta có thể xem tích chập như một của sổ trượt (sliding window) áp đặt lên một ma trận. Bạn có thể theo dõi cơ chế của tích chập qua hình minh họa bên dưới.\n![image.png](attachment:image.png)\n\nMa trận bên trái là một bức ảnh đen trắng. Mỗi giá trị của ma trận tương đương với một điểm ảnh (pixel), 0 là màu đen, 1 là màu trắng (nếu là ảnh grayscale thì giá trị biến thiên từ 0 đến 255).\n\nSliding window còn có tên gọi là kernel, filter hay feature detector. Ở đây, ta dùng một ma trận filter 3×3 nhân từng thành phần tương ứng (element-wise) với ma trận ảnh bên trái. Gía trị đầu ra do tích của các thành phần này cộng lại.\n\nKết quả của tích chập là một ma trận (convoled feature) sinh ra từ việc trượt ma  trận filter và thực hiện tích chập cùng lúc lên toàn bộ ma trận ảnh bên trái.\n\n\n","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{},"cell_type":"markdown","source":"## Mô hình mạng neuron tích chập\n\nBây giờ, Chúng ta đã biết thế nào là convolution. Vậy CNNs là gì? CNNs chỉ đơn giản gồm một vài layer của convolution kết hợp với các hàm kích hoạt phi tuyến (nonlinear activation function) như ReLU hay tanh để tạo ra thông tin trừu tượng hơn (abstract/higher-level) cho các layer tiếp theo.\n\nTrong mô hình Feedforward Neural Network (mạng nơ-ron truyền thẳng), các layer kết nối trực tiếp với nhau thông qua một trọng số w (weighted vector). Các layer này còn được gọi là có kết nối đầy đủ (fully connected layer) hay affine layer.\n\nTrong mô hình CNNs thì ngược lại. Các layer liên kết được với nhau thông qua cơ chế convolution. Layer tiếp theo là kết quả convolution từ layer trước đó, nhờ vậy mà ta có được các kết nối cục bộ. Nghĩa là mỗi nơ-ron ở layer tiếp theo sinh ra từ filter áp đặt lên một vùng ảnh cục bộ của nơ-ron layer trước đó.\n\nMỗi layer như vậy được  áp đặt các filter khác nhau, thông thường có vài trăm đến vài nghìn filter như vậy. Một số layer khác như pooling/subsampling layer dùng để chắt lọc lại các thông tin hữu ích hơn (loại bỏ các thông tin nhiễu).\nTuy nhiên, ta sẽ không đi sâu vào khái niệm của các layer này.\n\n![image.png](attachment:image.png)\n\nCNNs có tính bất biến và tính kết hợp cục bộ (Location Invariance and Compositionality). Với cùng một đối tượng, nếu đối tượng này được chiếu theo các gốc độ khác nhau (translation, rotation, scaling) thì độ chính xác của thuật toán sẽ bị ảnh hưởng đáng kể. Pooling layer sẽ cho bạn tính bất biến đối với phép dịch chuyển (translation), phép quay (rotation) và phép co giãn (scaling). \t\n\nTính kết hợp cục bộ cho ta các cấp độ biểu diễn thông tin từ mức độ thấp đến mức độ cao và trừu tượng hơn thông qua convolution từ các filter. Đó là lý do tại sao CNNs cho ra mô hình với độ chính xác rất cao. Cũng giống như cách con người nhận biết các vật thể trong tự nhiên. Ta phân biệt được một con chó với một con mèo nhờ vào các đặc trưng từ mức độ thấp (có 4 chân, có đuôi) đến mức độ cao (dáng đi, hình thể, màu lông)\n","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{},"cell_type":"markdown","source":"## Sử dụng trong bài toán nhận diện\n\nMạng tích chập sử dụng 3 ý tưởng cơ bản: các trường tiếp nhận cục bộ (local receptive field), trọng số chia sẻ (shared weights) và tổng hợp (pooling). Chúng ta hãy xem xét lần lượt từng ý tưởng. Trường tiếp nhận cục bộ (Local receptive fields): Trong các tầng kết nối đầy đủ được chỉ ra trước đây, đầu vào đã được mô tả là một đường thẳng đứng chứa các nơron. Trong mạng tích chập, ta sẽ thay thế các đầu vào là 28 × 28 nơron, giá trị tương ứng với 28 x28 cường độ điểm ảnh mà chúng ta sử dụng:\n\n![image.png](attachment:image.png)\nNhư thường lệ chúng ta sẽ kết nối các điểm ảnh đầu vào cho các nơron ở tầng ẩn. Nhưng chúng ta sẽ không kết nối mỗi điểm ảnh đầu vào cho mỗi neuron ẩn. Thay vào đó, chúng ta chỉ kết nối trong phạm vi nhỏ, các vùng cục bộ của bức ảnh.\n\nĐể được chính xác hơn, mỗi nơron trong lớp ẩn đầu tiên sẽ được kết nối với một vùng nhỏ của các nơron đầu vào, ví dụ, một vùng 5 × 5, tương ứng với 25 điểm ảnh đầu vào. \n\nVùng đó trong bức ảnh đầu vào được gọi là vùng tiếp nhận cục bộ cho nơron ẩn. Đó là một cửa sổ nhỏ trên các điểm ảnh đầu vào. Mỗi kết nối sẽ học một trọng số. Và nơron ẩn cũng sẽ học một độ lệch (overall bias). Bạn có thể hiểu rằng nơron lớp ẩn cụ thể là học để phân tích trường tiếp nhận cục bộ cụ thể của nó.\n\nSau đó chúng ta trượt trường tiếp nhận cục bộ trên toàn bộ bức ảnh. Đối với mỗi trường tiếp nhận cục bộ, có một nơron ẩn khác trong tầng ẩn đầu tiên. Để minh họa điều này một cách cụ thể, chúng ta hãy bắt đầu với một trường tiếp nhận cục bộ ở góc trên bên trái\n\n![image.png](attachment:image.png)\n\nSau đó dịch filter qua bên phải một cột sẽ tạo được neuron ẩn thứ 2.\n\n![image.png](attachment:image.png)\n\nĐối với bài toán nhận dạng ảnh người ta thường gọi ma trận lớp đầu vào là feature map, trọng số xác định các đặc trương là shared weight và độ lệch xác định một feature map là shared bias. Như vậy đơn giản nhất là qua các bước trên chúng ta chỉ có 1 feature map. Tuy nhiên trong nhận dạng ảnh chúng ta cần nhiều hơn một feature map.\n\n![image.png](attachment:image.png)\n\nNhư vậy, local receptive field thích hợp cho việc phân tách dữ liệu ảnh, giúp chọn ra những vùng ảnh có giá trị nhất cho việc đánh giá phân lớp.\n\nTrọng số chia sẻ (shared weight and bias)\n\nĐầu tiên, các trọng số cho mỗi filter (kernel) phải giống nhau. Tất cả các nơ-ron trong lớp ẩn đầu sẽ phát hiện chính xác feature tương tự chỉ ở các vị trí khác nhau trong hình ảnh đầu vào. Chúng ta gọi việc map từ input layer sang hidden layer là một feature map. Vậy mối quan hệ giữa số lượng Feature map với số lượng tham số là gì?\n\nChúng ta thấy mỗi fearture map cần 25 = 5x5 shared weight và 1 shared bias. Như vậy mỗi feature map cần 5x5+1 = 26 tham số. Như vậy nếu có 10 feature map thì có 10x26 = 260 tham số. Chúng ta xét lại nếu layer đầu tiên có kết nối đầy đủ nghĩa là chúng ta có 28x28=784 neuron đầu vào như vậy ta chỉ có 30 neuron ẩn. Như vậy ta cần 28x28x30 shared weight và 30 shared bias. Tổng số tham số là 28x28x30+30 tham số lớn hơn nhiều so với CNN. Ví dụ vừa rồi chỉ mô tả để thấy được sự ước lượng số lượng tham số chứ chúng ta không so sánh được trực tiếp vì 2 mô hình khác nhau. Nhưng điều chắc chắn là nếu mô hình có số lượng tham số ít hơn thì nó sẽ chạy nhanh hơn.\n\nTóm lại, một convolutional layer bao gồm các feature map khác nhau. Mỗi một feature map giúp detect một vài feature trong bức ảnh. Lợi ích lớn nhất của trọng số chia sẻ là giảm tối đa số lượng tham số trong mạng CNN.\n\nLớp pooling thường được sử dụng ngay sau lớp convulational để đơn giản hóa thông tin đầu ra để giảm bớt số lượng neuron. Thủ tục pooling phổ biến là max-pooling, thủ tục này chọn giá trị lớn nhất trong vùng đầu vào 2x2.\n\n![image.png](attachment:image.png)\n\nNhư vậy qua lớp Max Pooling thì số lượng neuron giảm đi phân nửa. Trong một mạng CNN có nhiều Feature Map nên mỗi Feature Map chúng ta sẽ cho mỗi Max Pooling khác nhau. Chúng ta có thể thấy rằng Max Pooling là cách hỏi xem trong các đặc trưng này thì đặc trưng nào là đặc trưng nhất. Ngoài Max Pooling còn có L2 Pooling.\n\nCuối cùng ta đặt tất cả các lớp lại với nhau thành một CNN với đầu ra gồm các neuron với số lượng tùy bài toán. 2 lớp cuối cùng của các kết nối trong mạng là một lớp đầy đủ kết nối (fully connected layer) . Lớp này nối mọi nơron từ lớp max pooled tới mọi nơron của tầng ra.\n\n![image.png](attachment:image.png)\n\n\n\n","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"trusted":true},"cell_type":"code","source":"# def create_model(input_shape, N_CLASSES):\n#     base_model = efn.EfficientNetB6(weights='/kaggle/input/efficientnet/efficientnet-b6_noisy-student_notop.h5', \n#                                     include_top=False,\n#                                     input_shape=input_shape)\n\n#     base_model.trainable = False # Freeze layers\n#     model = tf.keras.Sequential([\n#         base_model,\n#         L.GlobalAveragePooling2D(),\n#         L.Dense(N_CLASSES, activation='softmax')\n#     ])\n    \n#     return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#cusstom\ndef create_model(input_shape, N_CLASSES):\n    base_model =tf.keras.applications.VGG16(weights = 'imagenet', \n                                    include_top=False,\n                                    input_shape=input_shape)\n\n    base_model.trainable = False # Freeze layers\n    model = tf.keras.Sequential([\n        base_model,\n        L.GlobalAveragePooling2D(),\n        L.Dense(N_CLASSES, activation='softmax')\n    ])\n    \n    return model","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Warmup top layers"},{"metadata":{"trusted":true},"cell_type":"code","source":"with strategy.scope():\n    model = create_model((None, None, CHANNELS), N_CLASSES)\n    \nmetric_list = ['sparse_categorical_accuracy']\n\noptimizer = optimizers.Adam(lr=WARMUP_LEARNING_RATE)\nmodel.compile(optimizer=optimizer, \n              loss=losses.SparseCategoricalCrossentropy(), \n              metrics=metric_list)\nmodel.summary()","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-output":true,"trusted":true,"_kg_hide-input":false},"cell_type":"code","source":"STEPS_PER_EPOCH = NUM_TRAINING_IMAGES // BATCH_SIZE\nwarmup_history = model.fit(x=get_training_dataset(), \n                           steps_per_epoch=STEPS_PER_EPOCH, \n                           validation_data=get_validation_dataset(),\n                           epochs=WARMUP_EPOCHS, \n                           verbose=2).history","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Learning rate schedule"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"LR_START = 0.00000001\nLR_MIN = 0.000001\nLR_MAX = LEARNING_RATE\nLR_RAMPUP_EPOCHS = 3\nLR_SUSTAIN_EPOCHS = 0\nLR_EXP_DECAY = .8\n\ndef lrfn(epoch):\n    if epoch < LR_RAMPUP_EPOCHS:\n        lr = (LR_MAX - LR_START) / LR_RAMPUP_EPOCHS * epoch + LR_START\n    elif epoch < LR_RAMPUP_EPOCHS + LR_SUSTAIN_EPOCHS:\n        lr = LR_MAX\n    else:\n        lr = (LR_MAX - LR_MIN) * LR_EXP_DECAY**(epoch - LR_RAMPUP_EPOCHS - LR_SUSTAIN_EPOCHS) + LR_MIN\n    return lr\n    \nrng = [i for i in range(EPOCHS)]\ny = [lrfn(x) for x in rng]\n\nsns.set(style='whitegrid')\nfig, ax = plt.subplots(figsize=(20, 6))\nplt.plot(rng, y)\n\nprint(f'{EPOCHS} total epochs and {NUM_TRAINING_IMAGES//BATCH_SIZE} steps per epoch')\nprint(f'Learning rate schedule: {y[0]:.3g} to {max(y):.3g} to {y[-1]:.3g}')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Tinh chỉnh tất cả các lớp"},{"metadata":{"trusted":true},"cell_type":"code","source":"for layer in model.layers:\n    layer.trainable = True # Unfreeze layers\n\ncheckpoint = ModelCheckpoint(model_path, monitor='val_loss', mode='min', save_best_only=True)\nes = EarlyStopping(monitor='val_loss', mode='min', patience=ES_PATIENCE, \n                   restore_best_weights=True, verbose=1)\nlr_callback = LearningRateScheduler(lrfn, verbose=0)\n\ncallback_list = [checkpoint, es, lr_callback]\n\noptimizer = optimizers.Adam(lr=LEARNING_RATE)\nmodel.compile(optimizer=optimizer, \n              loss='sparse_categorical_crossentropy', \n              metrics=metric_list)\nmodel.summary()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true,"_kg_hide-input":false,"_kg_hide-output":true},"cell_type":"code","source":"history = model.fit(x=get_training_dataset(), \n                    steps_per_epoch=STEPS_PER_EPOCH, \n                    validation_data=get_validation_dataset(), \n                    callbacks=callback_list, \n                    epochs=20, \n                    verbose=2).history","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Model loss graph"},{"metadata":{"trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"def plot_metrics(history, metric_list):\n    fig, axes = plt.subplots(len(metric_list), 1, sharex='col', figsize=(24, 12))\n    axes = axes.flatten()\n    \n    for index, metric in enumerate(metric_list):\n        axes[index].plot(history[metric], label=f'Train {metric}')\n        axes[index].plot(history[f'val_{metric}'], label=f'Validation {metric}')\n        axes[index].legend(loc='best', fontsize=16)\n        axes[index].set_title(metric)\n\n    plt.xlabel('Epochs', fontsize=16)\n    sns.despine()\n    plt.show()\n\nplot_metrics(history, metric_list=['loss', 'sparse_categorical_accuracy'])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Đánh giá mô hình\n\n## Train set"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"x_train = train_dataset.map(lambda image, label: image)\ntrain_preds = model.predict(x_train)\ntrain_preds = np.argmax(train_preds, axis=-1)\n\nprint(classification_report(y_train, train_preds, target_names=CLASSES))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Validation set"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"x_valid = valid_dataset.map(lambda image, label: image)\nvalid_preds = model.predict(x_valid)\nvalid_preds = np.argmax(valid_preds, axis=-1)\n\nprint(classification_report(y_valid, valid_preds, target_names=CLASSES))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Confusion matrix\n\n## Train\nChia các confusion matrix thành 3 phần để rõ ràng hơn, ô thứ nhất có các lớp 1 từ 34, ô thứ hai 35 đến 69 và ô thứ ba có các lớp còn lại."},{"metadata":{"trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"fig, ax = plt.subplots(1, 1, figsize=(20, 45))\ntrain_cfn_matrix = confusion_matrix(y_train, train_preds, labels=range(len(CLASSES)))\ntrain_cfn_matrix = (train_cfn_matrix.T / train_cfn_matrix.sum(axis=1)).T\ntrain_df_cm = pd.DataFrame(train_cfn_matrix, index=CLASSES, columns=CLASSES)\nax = sns.heatmap(train_df_cm, cmap='Blues').set_title('Train', fontsize=30)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Validation"},{"metadata":{"trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"fig, ax = plt.subplots(1, 1, figsize=(20, 45))\nvalid_cfn_matrix = confusion_matrix(y_valid, valid_preds, labels=range(len(CLASSES)))\nvalid_cfn_matrix = (valid_cfn_matrix.T / valid_cfn_matrix.sum(axis=1)).T\nvalid_df_cm = pd.DataFrame(valid_cfn_matrix, index=CLASSES, columns=CLASSES)\nax = sns.heatmap(valid_df_cm, cmap=sns.cubehelix_palette(8)).set_title('Validation', fontsize=30)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Hình dung các dự đoán\n\n## Train set"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"x_train_samp, y_train_samp = dataset_to_numpy_util(train_dataset, 12)\ntrain_samp_preds = model.predict(x_train_samp, batch_size=12)\ndisplay_9_images_with_predictions(x_train_samp, train_samp_preds, y_train_samp)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Validation set"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"x_valid_samp, y_valid_samp = dataset_to_numpy_util(valid_dataset, 9)\nvalid_samp_preds = model.predict(x_valid_samp, batch_size=9)\ndisplay_9_images_with_predictions(x_valid_samp, valid_samp_preds, y_valid_samp)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Kiểm tra các dự đoán"},{"metadata":{"trusted":true},"cell_type":"code","source":"x_test = test_dataset.map(lambda image, idnum: image)\ntest_preds = model.predict(x_test)\ntest_preds = np.argmax(test_preds, axis=-1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"test_ids_ds = test_dataset.map(lambda image, idnum: idnum).unbatch()\ntest_ids = next(iter(test_ids_ds.batch(NUM_TEST_IMAGES))).numpy().astype('U')\n\nsubmission = pd.DataFrame(test_ids, columns=['id'])\nsubmission['label'] = test_preds\nsubmission.to_csv('submission.csv', index=False)\ndisplay(submission.head(10))","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}