{"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"},"kaggle":{"accelerator":"tpu1vmV38","dataSources":[{"sourceId":21154,"databundleVersionId":1243559,"sourceType":"competition"}],"dockerImageVersionId":30617,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"!pip install -q efficientnet","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#предварительно обученные модели\nfrom tensorflow.keras.applications.vgg16 import VGG16\nfrom tensorflow.keras.applications.vgg19 import VGG19\nfrom tensorflow.keras.applications.inception_v3 import InceptionV3\nfrom tensorflow.keras.applications.inception_resnet_v2 import InceptionResNetV2\nfrom tensorflow.keras.applications.densenet import DenseNet121, DenseNet169, DenseNet201 \nfrom tensorflow.keras.applications.xception import Xception\nfrom tensorflow.keras.applications.resnet50 import ResNet50\nfrom tensorflow.keras.applications.resnet_v2 import ResNet50V2, ResNet101V2, ResNet152V2\nfrom tensorflow.keras.applications.nasnet import NASNetLarge\nfrom efficientnet.tfkeras import EfficientNetB7, EfficientNetL2, EfficientNetB0, EfficientNetB1","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import tensorflow as tf\nfrom tensorflow.keras.models import Model\nfrom tensorflow.keras import layers\nfrom tensorflow.keras.layers import Dense, Flatten\nfrom tensorflow.keras.layers import Dropout, BatchNormalization, GaussianDropout\nfrom tensorflow.keras.layers import GlobalAveragePooling2D\nfrom tensorflow.keras.callbacks import ModelCheckpoint\n#  библиотека для работы с наборами данных на Kaggle\nfrom kaggle_datasets import KaggleDatasets\nimport re\nimport numpy as np\nimport random\nimport matplotlib.pyplot as plt\n%matplotlib inline \nprint(\"Tensorflow version \" + tf.__version__)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"AUTO = tf.data.experimental.AUTOTUNE\n# Обнаружение оборудования, возврат соответствующей стратегии распространения: TPU, GPU, CPU\ntry:\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()  # Обнаружение TPU. Параметры среды не требуются, если задана переменная среды TPU_NAME. На Kaggle это всегда так.\n    print('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() # стратегия распространения по умолчанию в Tensorflow. Работает на CPU и одном GPU.\nprint(\"REPLICAS: \", strategy.num_replicas_in_sync)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"GCS_DS_PATH = KaggleDatasets().get_gcs_path() #получаем путь к наборам данных","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"IMAGE_SIZE = [512, 512] # при таком размере графическому процессору не хватит памяти. Используйте TPU\nEPOCHS = 30\nBATCH_SIZE = 16 * strategy.num_replicas_in_sync\n\nGCS_PATH_SELECT = { # available image sizes\n    192: GCS_DS_PATH + '/tfrecords-jpeg-192x192',\n    224: GCS_DS_PATH + '/tfrecords-jpeg-224x224',\n    331: GCS_DS_PATH + '/tfrecords-jpeg-331x331',\n    512: GCS_DS_PATH + '/tfrecords-jpeg-512x512'\n}\nGCS_PATH = GCS_PATH_SELECT[IMAGE_SIZE[0]]\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\nSEED = 2020","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def decode_image(image_data):\n    \"\"\"Декодирует изображение в vyjujvthye. vfnhbwe (тензор)\n    Нормализует данные и преобразовывает изображения к указанному размеру\"\"\"\n    image = tf.image.decode_jpeg(image_data, channels=3) # Декодирование изображения в формате JPEG в тензор uint8.\n    image = tf.cast(image, tf.float32) / 255.0  # преобразовать изображение в плавающее в диапазоне [0, 1]\n    image = tf.reshape(image, [*IMAGE_SIZE, 3]) # явный размер, необходимый для TPU\n#     image = tf.keras.applications.inception_resnet_v2.preprocess_input(image)\n    return image\n\ndef read_labeled_tfrecord(example):\n    LABELED_TFREC_FORMAT = {\n        \"image\": tf.io.FixedLenFeature([], tf.string), # tf.string означает байтовую строку\n        \"class\": tf.io.FixedLenFeature([], tf.int64),  # [] означает отдельный элемент\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\ndef read_unlabeled_tfrecord(example):\n    UNLABELED_TFREC_FORMAT = {\n        \"image\": tf.io.FixedLenFeature([], tf.string), # tf.string означает байтовую строку\n        \"id\": tf.io.FixedLenFeature([], tf.string),  # [] означает отдельный элемент\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 # returns a dataset of image(s)\n\ndef load_dataset(filenames, labeled=True, ordered=False):\n    \"\"\"Читает из TFRecords. Для оптимальной производительности одновременное чтение из нескольких\n    файлов без учета порядка данных. Порядок не имеет значения, поскольку мы все равно будем перетасовывать данные\"\"\"\n\n    ignore_order = tf.data.Options() # Представляет параметры для tf.data.Dataset.\n    if not ordered:\n        ignore_order.experimental_deterministic = False # отключить порядок, увеличить скорость\n\n    dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTO) # автоматически чередует чтение из нескольких файлов\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    # возвращает набор данных пар (изображение, метка), если метка = Истина, или пар (изображение, идентификатор), если метка = Ложь\n    return dataset\n\ndef data_augment(image, label):\n    # data augmentation. Thanks to the dataset.prefetch(AUTO) statement in the next function (below),\n    # this happens essentially for free on TPU. Data pipeline code is executed on the \"CPU\" part\n    # of the TPU while the TPU itself is computing gradients.\n    flag = random.randint(1,3)\n    coef_1 = random.randint(70, 90) * 0.01\n    coef_2 = random.randint(70, 90) * 0.01\n    if flag == 1:\n        image = tf.image.random_flip_left_right(image, seed=SEED)\n    elif flag == 2:\n        image = tf.image.random_flip_up_down(image, seed=SEED)\n    else:\n        image = tf.image.random_crop(image, [int(IMAGE_SIZE[0]*coef_1), int(IMAGE_SIZE[0]*coef_2), 3],seed=SEED)\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_validation_dataset():\n    dataset = load_dataset(VALIDATION_FILENAMES, labeled=True, ordered=False)\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    # the number of data items is written in the name of the .tfrec files, i.e. flowers00-230.tfrec = 230 data items\n    n = [int(re.compile(r\"-([0-9]*)\\.\").search(filename).group(1)) for filename in filenames]\n    return np.sum(n)\n\n# training_dataset = get_training_dataset()\n# validation_dataset = get_validation_dataset()\n\nNUM_TRAINING_IMAGES = count_data_items(TRAINING_FILENAMES)\nNUM_VALIDATION_IMAGES = count_data_items(VALIDATION_FILENAMES)\nNUM_TEST_IMAGES = count_data_items(TEST_FILENAMES)\nSTEPS_PER_EPOCH = NUM_TRAINING_IMAGES // BATCH_SIZE\nprint('Dataset: {} training images, {} validation images, {} unlabeled test images'.format(NUM_TRAINING_IMAGES, NUM_VALIDATION_IMAGES, NUM_TEST_IMAGES))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# функция управляющая изменениями шага обучения в процессе тренировки нейронной сети\nLR_START = 0.00001\nLR_MAX = 0.00005 * strategy.num_replicas_in_sync#0.0001\nLR_MIN = 0.00001\nLR_RAMPUP_EPOCHS = 5\nLR_SUSTAIN_EPOCHS = 0\nLR_EXP_DECAY = .75\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    \nlr_callback = tf.keras.callbacks.LearningRateScheduler(lrfn, verbose=True)\n\n# построим график изменения шага обучение в зависимости от эпох\nrng = [i for i in range(EPOCHS)]\ny = [lrfn(x) for x in rng]\nplt.plot(rng, y)\nprint(\"Learning rate schedule: {:.3g} to {:.3g} to {:.3g}\".format(y[0], max(y), y[-1]))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def get_model(use_model):\n    # noisy-student\n    base_model = use_model(weights='noisy-student', \n                      include_top=False, pooling='avg',\n                      input_shape=(*IMAGE_SIZE, 3))\n#     base_model.trainable = False\n    x = base_model.output\n    predictions = Dense(104, activation='softmax')(x)\n    return Model(inputs=base_model.input, outputs=predictions)\n\n\nwith strategy.scope():    \n    model = get_model(EfficientNetB7) # тут подставить свою модель\n        \nmodel.compile(\n    optimizer='nadam',\n    loss = 'sparse_categorical_crossentropy',\n    metrics=['sparse_categorical_accuracy']\n)\n# Визуализируем архитектуру модели\n# tf.keras.utils.plot_model(\n#     model, to_file='model.png', show_shapes=True, show_layer_names=True,\n# )","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"history = model.fit(get_training_dataset(), \n          steps_per_epoch=STEPS_PER_EPOCH, \n          epochs=EPOCHS, \n          callbacks=[lr_callback, ModelCheckpoint(filepath='weights.h5', monitor='val_loss',\n                                  save_best_only=True)],\n          validation_data=get_validation_dataset(),\n          workers = 3)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.plot(history.history['sparse_categorical_accuracy'], \n         label='Оценка точности на обучающем наборе')\nplt.plot(history.history['val_sparse_categorical_accuracy'], \n         label='Оценка точности на проверочном наборе')\nplt.xlabel('Эпоха обучения')\nplt.ylabel('Оценка точности')\nplt.legend()\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.plot(history.history['loss'], \n         label='Оценка потерь на обучающем наборе')\nplt.plot(history.history['val_loss'], \n         label='Оценка потерь на проверочном наборе')\nplt.xlabel('Эпоха обучения')\nplt.ylabel('Оценка потерь')\nplt.legend()\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model = tf.keras.models.load_model('weights.h5')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Поскольку мы разделяем набор данных и выполняем итерацию отдельно для изображений и идентификаторов, порядок имеет значение.\ntest_ds = get_test_dataset(ordered=True) \n\nprint('Вычисляем предсказания...')\ntest_images_ds = test_ds.map(lambda image, idnum: image)\nprobabilities = model.predict(test_images_ds)\npredictions = np.argmax(probabilities, axis=-1)\nprint(predictions)\n\nprint('Создание файла submission.csv...')\ntest_ids_ds = test_ds.map(lambda image, idnum: idnum).unbatch()\ntest_ids = next(iter(test_ids_ds.batch(NUM_TEST_IMAGES))).numpy().astype('U') # все в одной партии\nnp.savetxt('submission.csv', np.rec.fromarrays([test_ids, predictions]), fmt=['%s', '%d'], delimiter=',', header='id,label', comments='')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Были протестированы 3 модели:\n* EfficientB7\n* VGG19\n* Xception","metadata":{}},{"cell_type":"markdown","source":"![image.png](attachment:9937368d-d7d1-455b-9555-fc58b0967dc6.png)","metadata":{},"attachments":{"9937368d-d7d1-455b-9555-fc58b0967dc6.png":{"image/png":"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"}}}]}