7. Ensemble.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"7. Ensemble.ipynb","provenance":[],"collapsed_sections":[]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"},"accelerator":"GPU"},"cells":[{"cell_type":"markdown","source":["# Ensemble"],"metadata":{"id":"Xqs3j8ZqZmvQ"}},{"cell_type":"markdown","source":["## Import Libraries\n","First of all, let's import all the libraries we will need later."],"metadata":{"id":"l5s-N9DXYZDC"}},{"cell_type":"code","source":["from google.colab import drive\n","import os\n","import shutil\n","import numpy as np\n","import random as rn\n","import tensorflow as tf\n","from tensorflow import keras\n","from tensorflow.keras.utils import image_dataset_from_directory\n","from tensorflow.keras import layers, models, optimizers\n","from tensorflow.keras.models import Sequential\n","from tensorflow.keras.applications import VGG16\n","import matplotlib.pyplot as plt\n","from sklearn import metrics"],"metadata":{"id":"790GcOInQ_yw"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Load Dataset from Google Drive"],"metadata":{"id":"KgRDfmWDVmfY"}},{"cell_type":"code","source":["drive.mount('/content/drive', force_remount=True)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"hHlfyia7Vqfq","executionInfo":{"status":"ok","timestamp":1641896508055,"user_tz":-60,"elapsed":18413,"user":{"displayName":"FEDERICA BALDI","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"16281055805233431487"}},"outputId":"7a8b5a1d-74ee-4533-e2fd-fb44176d6522"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n"]}]},{"cell_type":"code","source":["!unzip -q \"/content/drive/My Drive/Baldi_Cioffo/SplittedDataset.zip\" -d \"/content\""],"metadata":{"id":"nRLlgzJ5lJt0"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Set Parameters"],"metadata":{"id":"Yxzg2PnmCPQN"}},{"cell_type":"code","source":["DATASET_PATH = \"/content/SplittedDataset\"\n","VALIDATION_PATH = DATASET_PATH + '/validation_set'\n","TEST_PATH = DATASET_PATH + '/test_set'\n","\n","LOCAL_MODELS_FOLDER = \"/content/models\"\n","if not os.path.exists(LOCAL_MODELS_FOLDER):\n","  os.makedirs(LOCAL_MODELS_FOLDER)\n","GLOBAL_MODELS_FOLDER = \"/content/drive/My Drive/Baldi_Cioffo/models\"\n","if not os.path.exists(GLOBAL_MODELS_FOLDER):\n","  os.makedirs(GLOBAL_MODELS_FOLDER)\n","\n","# Default values to load the dataset\n","BATCH_SIZE = 32\n","IMAGE_HEIGHT = 224\n","IMAGE_WIDTH = 224"],"metadata":{"id":"4g8Gw3SoCW2-"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Utility Functions"],"metadata":{"id":"NaDMLtupmIEk"}},{"cell_type":"code","source":["def set_seed ():\n","  ''' \n","  set_seed is used to obtain reproducible results using keras during the development phase\n","  '''\n","  seed = 24\n","  # The below is necessary for reproducible results of certain Python hash-based operations.\n","  os.environ[\"PYTHONHASHSEED\"]=\"0\"\n","  # The below is necessary for starting Numpy generated random numbers in a well-defined initial state.\n","  np.random.seed(seed)\n","  # The below is necessary for starting core Python generated random numbers in a well-defined state.\n","  rn.seed(seed)\n","  # The below tf.random.set_seed will make random number generation in TensorFlow have a well-defined initial state.\n","  tf.random.set_seed(seed)\n","\n","def load_validation_set (image_height, image_width, batch_size):\n","  '''\n","  load_validation_set loads the validation set from the \"validation_set\" folder. The images are resized to height x width\n","  :param image_height: standard height of the images\n","  :param image_width: standard width of the images\n","  :param batch_size: size of each batch\n","  :return the validation set\n","  '''\n","  return image_dataset_from_directory(\n","    VALIDATION_PATH,\n","    image_size = (image_height, image_width),\n","    batch_size = batch_size,\n","    shuffle = False,\n","    class_names = ['hem', 'all']) # explicit ordering of the labels, 0 for hem, 1 for all\n","\n","def load_test_set (image_height, image_width, batch_size):\n","  '''\n","  load_test_set loads the test set from the \"test_set\" folder. The images are resized to height x width\n","  :param image_height: standard height of the images\n","  :param image_width: standard width of the images\n","  :param batch_size: size of each batch\n","  :return the test set\n","  '''\n","  return image_dataset_from_directory(\n","    TEST_PATH,\n","    image_size = (image_height, image_width),\n","    batch_size = batch_size,\n","    shuffle = False,\n","    class_names = ['hem', 'all']) # explicit ordering of the labels, 0 for hem, 1 for all\n","\n","def evaluate_model(y_score, y_pred):\n","  '''\n","  evaluate_model is used to plot some statistics about the performance on the test set\n","  :param model: model to consider\n","  '''\n","  y_true = tf.concat([labels_batch for data_batch, labels_batch in test_dataset], axis = 0)\n","  print(\"Classification report: \")\n","  print(metrics.classification_report(y_true,y_pred,digits = 4))\n","  metrics.ConfusionMatrixDisplay.from_predictions(y_true, y_pred)\n","\n","  # ROC curve\n","  fpr,tpr,th = metrics.roc_curve(y_true,y_score)\n","  roc_auc = metrics.roc_auc_score(y_true,y_score)\n","\n","  plt.figure()\n","  plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc)\n","  plt.plot([0, 1], [0, 1], color='navy', linestyle='--')\n","  plt.xlim([0.0, 1.0])\n","  plt.ylim([0.0, 1.0])\n","  plt.xlabel('False Positive Rate')\n","  plt.ylabel('True Positive Rate')\n","  plt.title('ROC curve')\n","  plt.legend(loc=\"lower right\")\n","  plt.show()"],"metadata":{"id":"fSX3ug4Cgwww"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Load Dataset"],"metadata":{"id":"C884lZO-YiB2"}},{"cell_type":"code","source":["set_seed()"],"metadata":{"id":"Geqbk8VwPP3v"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Since the sizes of the images used for the CNN from scratch and the pre-trained networks are different, we load two different versions of the validation and test sets."],"metadata":{"id":"X0Etoj8xAouy"}},{"cell_type":"code","source":["validation_dataset = load_validation_set(IMAGE_HEIGHT, IMAGE_WIDTH, BATCH_SIZE)\n","test_dataset = load_test_set(IMAGE_HEIGHT, IMAGE_WIDTH, BATCH_SIZE)"],"metadata":{"id":"0poDX9f3XRaK","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1641736295826,"user_tz":-60,"elapsed":558,"user":{"displayName":"FEDERICA BALDI","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"16281055805233431487"}},"outputId":"9716ce4b-1a3e-4400-fb47-bfbb2500660f"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Found 2132 files belonging to 2 classes.\n","Found 2133 files belonging to 2 classes.\n"]}]},{"cell_type":"code","source":["scratch_validation_dataset = load_validation_set(300, 300, BATCH_SIZE)\n","scratch_test_dataset = load_test_set(300, 300, BATCH_SIZE)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"KvpQCnVUfA6M","executionInfo":{"status":"ok","timestamp":1641736296236,"user_tz":-60,"elapsed":417,"user":{"displayName":"FEDERICA BALDI","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"16281055805233431487"}},"outputId":"45a7beae-16bb-4878-9f3d-f8077cd6a860"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Found 2132 files belonging to 2 classes.\n","Found 2133 files belonging to 2 classes.\n"]}]},{"cell_type":"markdown","source":["## Load models\n","With the purpose of creating an ensemble model, we load the best performing models."],"metadata":{"id":"6CwLPuqiam1H"}},{"cell_type":"code","source":["vgg_model = tf.keras.models.load_model(GLOBAL_MODELS_FOLDER + '/vgg16/eperiment12_cut_ft_3_blocks.h5')"],"metadata":{"id":"8yaGKxwXa1FS"},"execution_count":null,"outputs":[]},{"cell_type":"code","execution_count":null,"metadata":{"id":"lIL3cb_7ZlA9"},"outputs":[],"source":["resnet_model = tf.keras.models.load_model(GLOBAL_MODELS_FOLDER + '/resnet-50/Experiment10_remove_blocks_fine_tuning.h5')"]},{"cell_type":"code","source":["from_scratch = tf.keras.models.load_model(GLOBAL_MODELS_FOLDER + '/from_scratch/OneDense256_2dropout.h5')"],"metadata":{"id":"kgBfIOoIdZ4D"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["resnet_model_2 = tf.keras.models.load_model(GLOBAL_MODELS_FOLDER + '/resnet-50/Experiment11_remove_blocks_fine_tuning.h5')"],"metadata":{"id":"YIlkAMYXhRVG"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Scores on Test Set"],"metadata":{"id":"hPBJN9lACs8K"}},{"cell_type":"code","source":["# vgg_model\n","vgg_test_scores = vgg_model.predict(test_dataset)\n","# resnet_model\n","resnet_test_scores = resnet_model.predict(test_dataset)\n","# from_scratch\n","from_scratch_test_scores = from_scratch.predict(scratch_test_dataset)\n","# resnet_model_2\n","resnet_2_test_scores = resnet_model_2.predict(test_dataset)"],"metadata":{"id":"RFpT2aVdCspN"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["TRUE_TEST_LABELS = tf.concat([labels_batch for data_batch, labels_batch in test_dataset], axis = 0)"],"metadata":{"id":"mb82G7l2DOKV"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["MODEL_TEST_SCORES = [vgg_test_scores, resnet_test_scores, from_scratch_test_scores, resnet_2_test_scores]"],"metadata":{"id":"jIX_QqgpDX2k"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Scores on Validation Set"],"metadata":{"id":"35M47gEzMLU6"}},{"cell_type":"code","source":["# vgg_model\n","vgg_validation_scores = vgg_model.predict(validation_dataset)\n","# resnet_model\n","resnet_validation_scores = resnet_model.predict(validation_dataset)\n","# from_scratch\n","from_scratch_validation_scores = from_scratch.predict(scratch_validation_dataset)\n","# resnet_model_2\n","resnet_2_validation_scores = resnet_model_2.predict(validation_dataset)"],"metadata":{"id":"jyi8nG-OMk1r"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["TRUE_VALIDATION_LABELS = tf.concat([labels_batch for data_batch, labels_batch in validation_dataset], axis = 0)"],"metadata":{"id":"bK-EQDxzNpD9"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["MODEL_VALIDATION_SCORES = [vgg_validation_scores, resnet_validation_scores, from_scratch_validation_scores, resnet_2_validation_scores]"],"metadata":{"id":"UI9x1YyaORSK"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Average Model\n","The easiest way to pool the predictions of a set of classifiers is to average their predictions at inference time. Having four different models, this results in \n","\n","```\n","ensemble_prediction = 0.25 * (prediction_a + prediction_b + prediction_c + prediction_d)\n","```"],"metadata":{"id":"qqpKnjEZBowi"}},{"cell_type":"code","source":["ensemble_scores = []\n","n_models = len(MODEL_TEST_SCORES)\n","for i in range(len(TRUE_TEST_LABELS)):\n","  ensemble_scores.append(np.sum([1/n_models*model_score[i] for model_score in MODEL_TEST_SCORES]))\n","\n","ensemble_predictions = np.rint(ensemble_scores)"],"metadata":{"id":"GQEa1ZIGDrRT"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["evaluate_model(ensemble_scores, ensemble_predictions)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":744},"id":"l9A1P49Qfeoi","executionInfo":{"status":"ok","timestamp":1641578693264,"user_tz":-60,"elapsed":2715,"user":{"displayName":"Federica Baldi","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj0eALl9wD-GJPtSTMAFK0DvDlcGWh5ZTpdGFtwCIo=s64","userId":"15726835528723494588"}},"outputId":"8a841130-1e32-4617-bae4-fe796adb307e"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Classification report: \n","              precision    recall  f1-score   support\n","\n","           0     0.9567    0.8894    0.9218       696\n","           1     0.9482    0.9805    0.9641      1437\n","\n","    accuracy                         0.9508      2133\n","   macro avg     0.9525    0.9349    0.9429      2133\n","weighted avg     0.9510    0.9508    0.9503      2133\n","\n"]},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 432x288 with 2 Axes>"]},"metadata":{"needs_background":"light"}},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","source":["## Weighted Average Model\n","All classifiers are more or less equally good but, in order to make the most of the ensemble technique, it is smarter to take a weighted average of the predictions so that the best classifiers have higher weights than the worst classifiers. \n","\n","The following function will allow us to calculate the weighted average of the predictions of the classifiers. "],"metadata":{"id":"ZYws8mVEpvQe"}},{"cell_type":"code","source":["def weighted_average_scores(models_scores, weights):\n","  if len(weights) != len(models_scores):\n","    return\n","  weighted_scores = []\n","  for i in range(len(models_scores[0])):\n","    weighted_score = [weight*model_score[i] for weight,model_score in zip(weights, models_scores)]\n","    weighted_average = np.sum(weighted_score, axis = 0)\n","    weighted_scores.append(weighted_average)\n","  return weighted_scores"],"metadata":{"id":"YHa7BEacOAUT"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Learning the best weights through a Genetic Algorithm\n","In general, a good set of ensembling weights should be learned from the validation data. There are many possible techniques, but we decided to implement a Genetic Algorithm that can find an optimal solution to the problem. \n","\n","Since the validation set is unbalanced, the optimization of the weights will be performed by considering the weighted F-measure and not the accuracy. The following function allows us to obtain this metric for a set of weights. "],"metadata":{"id":"dOORybMQGVsB"}},{"cell_type":"code","source":["def get_f1_measure(weights):\n","  weighted_scores = weighted_average_scores(MODEL_VALIDATION_SCORES, weights)\n","  predictions = np.rint(weighted_scores)\n","  return metrics.f1_score(TRUE_VALIDATION_LABELS, predictions, average=\"weighted\")"],"metadata":{"id":"MwoJ3KzFTmGV"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Genetic Algorithm\n","We defined the problem of finding the best set of weights as follows.\n","* Each chromosome is composed of four genes (real encoding) that represent the\n","weights associated with the four models that make up the ensemble.\n","* The initial population of candidate solutions is randomly generated, ensuring that the sum of the different genes for each chromosome is equal to 1 (constraint imposed by being weights).\n","* As fitness function, the weighted F-measure on the validation set is used. The goal is then to maximize this function.\n","*   The parameters of the genetic algorithm, namely population size, number of generations, and crossover and mutation probabilities are chosen experimentally. \n","\n","\n"],"metadata":{"id":"geROQcFWMRjD"}},{"cell_type":"code","source":["# tournament selection\n","def selection(population, scores, k=5):\n","  selection_indexes = [rn.randrange(0, len(population), 1) for i in range(k)]\n","  selected_index = selection_indexes[0]\n","  for i in selection_indexes[1:]:\n","    # perform the tournament, i.e. check if new selection is better than last one\n","    if scores[i] > scores[selected_index]:\n","      selected_index = i\n","  return population[selected_index]"],"metadata":{"id":"Oyfhxw0quc16"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# average crossover\n","def crossover(parent_1, parent_2, r_genes):\n","  children_1, children_2 = parent_1.copy(), parent_2.copy()\n","  random_genes_indexes = [rn.randrange(0, len(parent_1), 1) for i in range(r_genes)]\n","  for i in random_genes_indexes:\n","    average = (parent_1[i] + parent_2[i])/2\n","    children_1[i] = average\n","    children_2[i] = average\n","  return [[float(i)/sum(children_1) for i in children_1], \n","          [float(i)/sum(children_2) for i in children_2]] # normalization is needed because the sum of weights must be one"],"metadata":{"id":"oTt6ot6Jvd33"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# all-positions mutation\n","def mutation(chromosome):\n","  index = rn.randint(0, len(chromosome)-1)\n","  chromosome[index] = rn.random()\n","  return [float(i)/sum(chromosome) for i in chromosome]"],"metadata":{"id":"uaJWULQ1wrOX"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# weighted f1-measure on validation set\n","def fitness(chromosome):\n","  return get_f1_measure(chromosome)"],"metadata":{"id":"gBNeyyAS-XWS"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["def genetic_algorithm(fitness, number_of_models, population_size, number_of_generations, p_crossover, p_mutation):\n","  # initial population of random chromosomes\n","  population = []\n","  for i in range(population_size):\n","    chromosome = [rn.random() for _ in range(number_of_models)]\n","    chromosome = [float(i)/sum(chromosome) for i in chromosome]\n","    population.insert(i, chromosome)\n","  # keep track of best solution\n","  best_chromosome, best_fitness = 0, fitness(population[0])\n","  # enumerate generations\n","  for generation in range(number_of_generations):\n","    # evaluate all candidates in the population\n","    scores = [fitness(chromosome) for chromosome in population]\n","    # check for new best solution\n","    new_best = False\n","    for i in range(population_size):\n","      if scores[i] > best_fitness:\n","        new_best = True\n","        best_chromosome, best_fitness = population[i], scores[i]\n","    if new_best:\n","      print(\">Generation %d, new best f(%s) = %.4f\" % (generation+1,  best_chromosome, best_fitness))\n","    # select parents\n","    selected = [selection(population, scores) for _ in range(population_size)]\n","    # create the next generation\n","    children = []\n","    for i in range(0, population_size, 2):\n","      # get selected parents in pairs\n","      p1, p2 = selected[i], selected[i+1]\n","      # crossover and mutation\n","      if rn.random() < p_crossover:\n","        for c in crossover(p1, p2, r_genes=2):\n","          if rn.random() < p_mutation:\n","            # mutation\n","            mutation(c)\n","          # store for next generation\n","          children.append(c)\n","      else:\n","        children.append(p1)\n","        children.append(p2)\n","    # replace population\n","    population = children\n","  return [best_chromosome, best_fitness]"],"metadata":{"id":"XZunosUYqg1b"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["weights = None\n","fmeasure = -10\n","for i in range(10):\n","  print(\"Iteration \", i)\n","  cw, cfm = genetic_algorithm(fitness, 4, 100, 100, 0.4, 0.005)\n","  if cfm > fmeasure:\n","    fmeasure = cfm\n","    weights = cw\n","  print(\"------------\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"1U8aJGVTrCi6","executionInfo":{"status":"ok","timestamp":1641583524407,"user_tz":-60,"elapsed":4602704,"user":{"displayName":"Federica Baldi","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj0eALl9wD-GJPtSTMAFK0DvDlcGWh5ZTpdGFtwCIo=s64","userId":"15726835528723494588"}},"outputId":"6dea037f-3951-4e0f-a757-b1cf2bf3fc37"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Iteration  0\n",">Generation 1, new best f([0.263480639094814, 0.22221303752331642, 0.15928040816940814, 0.35502591521246146]) = 0.9462\n",">Generation 2, new best f([0.3196496105258499, 0.20252669323839914, 0.15425031177863283, 0.32357338445711814]) = 0.9472\n",">Generation 4, new best f([0.3853892925618668, 0.02341571811571648, 0.13979764560174257, 0.45139734372067414]) = 0.9477\n",">Generation 6, new best f([0.36179720093492695, 0.024031982448189763, 0.1508934151788453, 0.463277401438038]) = 0.9482\n",">Generation 7, new best f([0.3645005258805319, 0.024211547844153716, 0.14454894649226388, 0.46673897978305046]) = 0.9487\n","------------\n","Iteration  1\n",">Generation 1, new best f([0.17826443342197676, 0.08900115558707504, 0.2563026862058052, 0.47643172478514306]) = 0.9468\n",">Generation 2, new best f([0.35697810969080374, 0.031021685621809163, 0.14578029282129926, 0.4662199118660879]) = 0.9487\n","------------\n","Iteration  2\n",">Generation 1, new best f([0.16441895864318076, 0.11455541558069993, 0.2244050612146944, 0.49662056456142484]) = 0.9468\n",">Generation 2, new best f([0.25751668801188465, 0.12045486973062217, 0.1581229381272207, 0.46390550413027254]) = 0.9473\n",">Generation 3, new best f([0.3282175119810893, 0.0058215222841952715, 0.12993240469419373, 0.5360285610405218]) = 0.9473\n",">Generation 4, new best f([0.33558915111103255, 0.005952271436508885, 0.14726247753655144, 0.5111960999159072]) = 0.9477\n",">Generation 6, new best f([0.34625873976974547, 0.0061415155989089495, 0.1350174240934297, 0.5125823205379159]) = 0.9482\n","------------\n","Iteration  3\n",">Generation 1, new best f([0.3194911224037258, 0.011264970373989075, 0.18960729369467677, 0.47963661352760845]) = 0.9477\n",">Generation 4, new best f([0.31323940600720535, 0.01672124401836583, 0.19978813676280482, 0.47025121321162416]) = 0.9482\n",">Generation 8, new best f([0.3169744336550182, 0.014039391192936124, 0.19603780974451548, 0.4729483654075302]) = 0.9487\n","------------\n","Iteration  4\n",">Generation 1, new best f([0.3720189516932955, 0.007031699945882363, 0.15988512231391402, 0.4610642260469081]) = 0.9482\n",">Generation 3, new best f([0.16318732252707094, 0.11112818195627402, 0.2472519435945985, 0.4784325519220566]) = 0.9482\n",">Generation 5, new best f([0.3750420083326639, 0.0071962658288550144, 0.14590701640199902, 0.47185470943648206]) = 0.9487\n",">Generation 6, new best f([0.3770764267926167, 0.007235302032052722, 0.14669849021295828, 0.4689897809623723]) = 0.9491\n",">Generation 23, new best f([0.36857568310278194, 0.0069563149916040306, 0.15587371527649352, 0.447800069311696]) = 0.9492\n","------------\n","Iteration  5\n",">Generation 1, new best f([0.3552510255309278, 0.09776674748635049, 0.15798955823105942, 0.38899266875166233]) = 0.9463\n",">Generation 2, new best f([0.367338321987036, 0.06706856504087343, 0.16336509972162758, 0.4022280132504629]) = 0.9467\n",">Generation 3, new best f([0.3915088036445938, 0.03134260640126024, 0.1410106691270583, 0.4361379208270875]) = 0.9477\n",">Generation 4, new best f([0.22610895449214952, 0.07012451671043382, 0.2562030770185081, 0.44756345177890855]) = 0.9477\n",">Generation 6, new best f([0.3581614295471114, 0.03306028716166109, 0.14873853037350074, 0.4600397529177267]) = 0.9482\n",">Generation 9, new best f([0.23398493604735654, 0.04197721646635081, 0.2556263075245746, 0.468411539961718]) = 0.9482\n","------------\n","Iteration  6\n",">Generation 1, new best f([0.31193676386459634, 0.03134710586152013, 0.19450234025353913, 0.46221379002034435]) = 0.9482\n",">Generation 6, new best f([0.30842261825570055, 0.02390850143017762, 0.19231116042448052, 0.4753577198896412]) = 0.9482\n","------------\n","Iteration  7\n",">Generation 1, new best f([0.2797596453950957, 0.023383432632643128, 0.166768599022618, 0.5300883229496431]) = 0.9464\n",">Generation 2, new best f([0.3426414027082562, 0.023311610324294976, 0.16625636859306717, 0.46779061837438174]) = 0.9477\n",">Generation 3, new best f([0.3935840229994251, 0.04686797615709878, 0.10648976293531996, 0.4530582379081562]) = 0.9481\n",">Generation 4, new best f([0.3557906575436637, 0.02339705753388375, 0.16686577062814814, 0.4539465142943045]) = 0.9482\n",">Generation 5, new best f([0.3455072394544535, 0.023434164521364775, 0.1675255313325675, 0.4635330646916142]) = 0.9482\n",">Generation 6, new best f([0.3615665078724758, 0.022897056373018844, 0.16329980602333138, 0.45223662973117396]) = 0.9487\n",">Generation 8, new best f([0.3474214949005414, 0.02356399965052263, 0.16803926466055735, 0.3998830919477069]) = 0.9487\n","------------\n","Iteration  8\n",">Generation 1, new best f([0.2548252783371312, 0.17428375858431333, 0.21204632652512215, 0.35884463655343324]) = 0.9467\n",">Generation 4, new best f([0.31882931605358494, 0.2091621342990619, 0.1474573703040502, 0.32455117934330285]) = 0.9472\n","------------\n","Iteration  9\n",">Generation 1, new best f([0.36783584751979936, 0.023204102914979922, 0.12973434204666426, 0.4792257075185564]) = 0.9477\n",">Generation 4, new best f([0.3629802640590582, 0.022897799276835336, 0.1412222042648289, 0.47289973239927763]) = 0.9482\n",">Generation 5, new best f([0.35678737289946694, 0.022766781082790462, 0.15561436652951607, 0.46483147948822656]) = 0.9487\n",">Generation 74, new best f([0.35681823587506767, 0.022860884802331494, 0.155292871462345, 0.4554438078745807]) = 0.9487\n","------------\n"]}]},{"cell_type":"code","source":["print(weights)\n","print(fmeasure)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"znwBnBamB_Pl","executionInfo":{"status":"ok","timestamp":1641584047282,"user_tz":-60,"elapsed":1037,"user":{"displayName":"Federica Baldi","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj0eALl9wD-GJPtSTMAFK0DvDlcGWh5ZTpdGFtwCIo=s64","userId":"15726835528723494588"}},"outputId":"c27151f5-c96b-414d-819c-1a0eb775bd8b"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["[0.36857568310278194, 0.0069563149916040306, 0.15587371527649352, 0.447800069311696]\n","0.9491523390316557\n"]}]},{"cell_type":"code","source":["ensemble_scores = weighted_average_scores(MODEL_TEST_SCORES, weights)\n","ensemble_predictions = np.rint(ensemble_scores)\n","evaluate_model(ensemble_scores, ensemble_predictions)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":745},"id":"4k3giTorBfr0","executionInfo":{"status":"ok","timestamp":1641583910455,"user_tz":-60,"elapsed":2894,"user":{"displayName":"Federica Baldi","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj0eALl9wD-GJPtSTMAFK0DvDlcGWh5ZTpdGFtwCIo=s64","userId":"15726835528723494588"}},"outputId":"aad854a3-c701-4764-a331-677da631722c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Classification report: \n","              precision    recall  f1-score   support\n","\n","           0     0.9478    0.9138    0.9305       696\n","           1     0.9590    0.9756    0.9672      1437\n","\n","    accuracy                         0.9555      2133\n","   macro avg     0.9534    0.9447    0.9489      2133\n","weighted avg     0.9553    0.9555    0.9552      2133\n","\n"]},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 432x288 with 2 Axes>"]},"metadata":{"needs_background":"light"}},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"}}]}]}