{"cells":[{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"import tensorflow as tf\nimport tensorflow.keras as keras\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nfrom sklearn.utils import shuffle\nfrom sklearn.model_selection import train_test_split\nimport json\nfrom keras.preprocessing.image import ImageDataGenerator\nimport os.path\nimport math\nfrom copy import deepcopy\nimport matplotlib.pyplot as plt","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def draw_grpah(history):\n    loss = history.history['loss']\n    val_loss = history.history['val_loss']\n    epochs = range(1, len(loss) + 1)\n    plt.plot(epochs, loss, 'bo', label='Training loss', markersize=1)\n    plt.plot(epochs, val_loss, 'b', label='Validation loss', markersize=1)\n    plt.legend()\n    plt.show()\n","execution_count":null,"outputs":[]},{"metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true},"cell_type":"code","source":"def stratifying_data(data):\n    data.head()\n    orderby_label = []\n    sample_rate=[2.0,1.5,1.5,0.3,1.5]\n    for i in range(5):\n        orderby_label.append(data[data['label']==i].sample(frac=sample_rate[i],replace=True))\n    \n    stratified_data = pd.concat(orderby_label)\n    return stratified_data","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def get_count_by_class(data):\n    Count=[]\n    for i in range(5):\n        Count.append((i,data[data['label']==i].shape))\n    return Count","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"PATH = '../input/cassava-leaf-disease-classification/'\ndata= pd.read_csv(PATH+'train.csv')\n#print(data.head())\nf = open(PATH + 'label_num_to_disease_map.json')\nreal_labels = json.load(f)\nreal_labels = {int(k):v for k,v in real_labels.items()}\ndata['class_name'] = data.label.map(real_labels)\nstratified_data = stratifying_data(data)\nprint(get_count_by_class(stratified_data))\ntrain, val = train_test_split(stratified_data, test_size=0.05,stratify=stratified_data['class_name'])\n#print(train.head())\n#print_count_by_class(train)\n\ndatagen_train = ImageDataGenerator(\n                    rotation_range = 45,\n                    width_shift_range = 0.2,\n                    height_shift_range = 0.2,\n                    shear_range = 0.2,\n                    zoom_range = 0.2,\n                    horizontal_flip = True,\n                    vertical_flip = True,\n                    fill_mode = 'nearest')\n\ndatagen_val = ImageDataGenerator(\n                    rotation_range = 45,\n                    width_shift_range = 0.2,\n                    height_shift_range = 0.2,\n                    shear_range = 0.2,\n                    zoom_range = 0.2,\n                    horizontal_flip = True,\n                    vertical_flip = True,\n                    fill_mode = 'nearest')\n\ntrain_set = datagen_train.flow_from_dataframe(train,\n                             directory = PATH+'train_images',\n                             x_col = 'image_id',\n                             y_col = 'class_name',\n                             target_size = (512,512),\n                             #color_mode=\"rgb\",\n                             class_mode = 'categorical',\n                             interpolation = 'nearest',\n                             batch_size = 6,shuffle=False)\n\nval_set = datagen_val.flow_from_dataframe(val,\n                             directory = PATH+'train_images',\n                             x_col = 'image_id',\n                             y_col = 'class_name',\n                             target_size = (512,512),\n                             #color_mode=\"rgb\",\n                             class_mode = 'categorical',\n                             interpolation = 'nearest',\n                             batch_size = 6,shuffle=False)\nprint(len(train_set))\nprint(len(val_set))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class SEUnit(keras.layers.Layer):\n    def __init__(self, feature_map_len, se_ratio, **kwargs):\n        super().__init__(**kwargs)\n        self.feature_map_len = feature_map_len\n        self.se_ratio = se_ratio\n        self.global_avg_pool = keras.layers.GlobalAvgPool2D()\n        self.reshape = keras.layers.Reshape((1,1,feature_map_len))\n        self.squeeze = keras.layers.Conv2D(max(1,feature_map_len*se_ratio), kernel_size=1, activation='relu')\n        self.excitation = keras.layers.Conv2D(feature_map_len, kernel_size=1, activation='sigmoid')\n    \n    def call(self, inputs):\n        Z = inputs\n        Z = self.global_avg_pool(Z)\n        Z = self.reshape(Z)\n        Z = self.squeeze(Z)\n        excitation_vector = self.excitation(Z)\n        excitation_vector = tf.reshape(excitation_vector, [-1,1,1,self.feature_map_len])\n        \n        #print(self.global_avg_pool.name, self.global_avg_pool.input_shape, self.global_avg_pool.output_shape, self.global_avg_pool.count_params())\n        #print(self.reshape.name, self.reshape.input_shape, self.reshape.output_shape, self.reshape.count_params())\n        #print(self.squeeze.name, self.squeeze.input_shape, self.squeeze.output_shape, self.squeeze.count_params())\n        #print(self.excitation.name, self.excitation.input_shape, self.excitation.output_shape, self.excitation.count_params())\n        return inputs*excitation_vector\n    \n    def get_config(self):\n        base_config = super().get_config()\n        return {**base_config,\"feature_map_len\":self.feature_map_len}","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def SiLU(x):\n    return x*tf.keras.backend.sigmoid(x)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class MBConv_v2(keras.layers.Layer):\n    def __init__(self, in_channel, out_channel, kernel_size, multiplier, strides, name, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.in_channel = in_channel\n        self.out_channel = out_channel\n        self.kernel_size = kernel_size\n        self.multiplier = multiplier\n        self.strides = strides\n        self.dropout = dropout\n        \n        self.Name = name\n        \n        self.expansion_layers = []\n        self.activation = keras.layers.Activation(SiLU)\n        bn_axis=3\n        if multiplier != 1:\n            self.expansion_layers = [keras.layers.Conv2D(filters=in_channel*multiplier,\n                                                         kernel_size=1, padding='same', use_bias=False),\n                                     keras.layers.BatchNormalization(axis=bn_axis),\n                                     keras.layers.Activation(SiLU)]\n        \n        self.depthwise_layers = [keras.layers.DepthwiseConv2D(kernel_size=kernel_size, strides=strides,\n                                                            padding='same', use_bias=False),\n                                 keras.layers.BatchNormalization(axis=bn_axis),\n                                 keras.layers.Activation(SiLU)]\n        se_ratio = 0.25 / multiplier\n        self.se_unit = SEUnit(in_channel*multiplier, se_ratio)\n        \n        self.reduction_layers = [keras.layers.Conv2D(filters=out_channel, kernel_size=1,\n                                                  padding='same', use_bias=False),\n                                 keras.layers.BatchNormalization(axis=bn_axis)]\n        if dropout>0:\n            self.reduction_layers.append(keras.layers.Dropout(dropout, noise_shape=(None,1,1,1)))\n    def call(self, inputs):\n        Z = inputs\n        #print(self.Name)\n        #print('expansion')\n        for layer in self.expansion_layers:\n            Z = layer(Z)\n        #    print(layer.name, layer.input_shape, layer.output_shape, layer.count_params())\n        #print('depthwise')\n        for layer in self.depthwise_layers:\n            Z = layer(Z)\n            #print(layer.name, layer.input_shape, layer.output_shape, layer.count_params())\n        #print('se')\n        Z = self.se_unit(Z)\n        #print(self.se_unit.input_shape, self.se_unit.output_shape, layer.count_params())\n        #print('reduction')\n        for layer in self.reduction_layers:\n            Z = layer(Z)\n            #print(layer.name, layer.input_shape, layer.output_shape, layer.count_params())\n        \n        if self.strides==1 and self.in_channel==self.out_channel:\n            Z=Z+inputs\n        return Z #일부러 activation 없는거임\n                  \n    def get_config(self):\n        base_config = super().get_config()\n        return {**base_config,\n                \"in_channel\": self.in_channel, \"out_channel\": self.out_channel,\n                \"kernel_size\": self.kernel_size, \"multiplier\": self.multiplier, \n                \"strides\": self.strides, \"dropout\":self.dropout}","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"default_efficient = [\n    {'in_channel':32, 'out_channel':16, 'kernel_size':3, 'multiplier':1, 'strides':1, 'n_repeat':1},\n    {'in_channel':16, 'out_channel':24, 'kernel_size':3, 'multiplier':6, 'strides':2, 'n_repeat':2},\n    {'in_channel':24, 'out_channel':40, 'kernel_size':5, 'multiplier':6, 'strides':2, 'n_repeat':2},\n    {'in_channel':40, 'out_channel':80, 'kernel_size':3, 'multiplier':6, 'strides':2, 'n_repeat':3},\n    {'in_channel':80, 'out_channel':112, 'kernel_size':5, 'multiplier':6, 'strides':1, 'n_repeat':3},\n    {'in_channel':112, 'out_channel':192, 'kernel_size':5, 'multiplier':6, 'strides':2, 'n_repeat':4},\n    {'in_channel':192, 'out_channel':320, 'kernel_size':3, 'multiplier':6, 'strides':1, 'n_repeat':1}\n]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def rf(filters, width_coef):\n    \"\"\"Round number of filters based on width multiplier.\"\"\"\n    depth_divisor=8\n    filters *= width_coef\n    new_filters = int(filters + depth_divisor / 2) // depth_divisor * depth_divisor\n    new_filters = max(depth_divisor, new_filters)\n    # Make sure that round down does not go down by more than 10%.\n    if new_filters < 0.9 * filters:\n        new_filters += depth_divisor\n    return int(new_filters)\n\ndef rd(repeat, depth_coef):\n    return int(math.ceil(repeat*depth_coef))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#a = tf.constant([[1,0,0],[0,0,1]])\n#b = tf.argmax(a,axis=-1)\n#c = tf.constant([[0,0,1],[0,1,0]])\n#t = (b==0) | (b==2)\n#d = tf.argmax(c,axis=-1)==2\n#e = tf.cast(b&d,dtype=tf.float32)\n#f = tf.constant([1,2],dtype=tf.float32)\n#print(f*e*15)\n#print(t)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def condition_tensor(y, target_class):\n    return tf.argmax(y, axis=-1)==target_class","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class condition_penalty_loss(tf.keras.losses.Loss):\n    def __init__(self, condition_penalty, **kwargs):\n        self.condition_penalty=condition_penalty\n        super().__init__(**kwargs)\n    def call(self, y_true, y_pred):\n        loss = tf.keras.losses.categorical_crossentropy(y_true,y_pred)\n    \n        class4 = condition_tensor(y_true, 4)\n        predict0 = condition_tensor(y_pred, 0)\n        predict4_0 = tf.cast(class4 & predict0, dtype=tf.float32)\n        loss4_0 = loss * predict4_0 * 5\n        \n        class0123 = class4==False\n        predict4 = condition_tensor(y_pred, 4)\n        predict0123_4 = tf.cast(class0123 & predict4, dtype=tf.float32)\n        loss0123_4 = loss * predict0123_4 * 2\n        \n        class0 = condition_tensor(y_true, 0)\n        predict0_4 = tf.cast(class0 & predict4, dtype=tf.float32)\n        loss0_4 = loss * predict0_4 * 10 #loss0123_4에 이미 loss0_4에 대해 2배 로스가 더해져있음\n        \n        return loss + loss0123_4 + loss4_0 + loss0_4\n    def get_config(self):\n        base_config = super().get_config()\n        return {**base_config, 'condition_penalty':self.condition_penalty}","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class EfficientNet(keras.models.Model):\n    def __init__(self, default_efficient, width_coef, depth_coef, resolution, dropout, dropout_connect=0.2, **kwargs):\n        super().__init__(**kwargs)\n        #for i in default_efficient:\n        #    print(i)\n        default_efficient = deepcopy(default_efficient)\n        self.default_efficient=default_efficient\n        self.width_coef = width_coef\n        self.depth_coef = depth_coef\n        self.resolution = resolution\n        self.dropout = dropout\n        self.dropout_connect = dropout_connect\n        self.activation=keras.layers.Activation(SiLU)\n        bn_axis=3\n        \n        self.first_conv = [keras.layers.Conv2D(rf(32, width_coef), kernel_size=3, strides=2, padding='same', use_bias=False),\n                           keras.layers.BatchNormalization(axis=bn_axis),\n                           keras.layers.Activation(SiLU)]  #*rd(1,depth_coef)\n        \n        self.MB_layers=[]\n        total_n_repeat = sum([block['n_repeat'] for block in default_efficient])\n        block_num=0\n        name = 'a'\n        for block in default_efficient:\n            block['in_channel']=rf(block['in_channel'],width_coef)\n            block['out_channel']=rf(block['out_channel'],width_coef)\n            block['n_repeat']=rd(block['n_repeat'],depth_coef)\n            block_args = dict(block)\n            block_args.pop('n_repeat')\n            \n            drop_rate = dropout_connect * float(block_num) / total_n_repeat\n            block_num+=1\n            \n            self.MB_layers.append(MBConv_v2(**block_args,dropout=drop_rate,name=name))\n            name=chr(ord(name)+1)\n            if block['n_repeat']>1:\n                block_args['in_channel']=block_args['out_channel']\n                block_args['strides']=1\n                for i in range(block['n_repeat']-1):\n                    drop_rate = dropout_connect * float(block_num) / total_n_repeat #흠.. 나중에 1보다 커짐..\n                    self.MB_layers.append(MBConv_v2(**block_args,dropout=drop_rate,name=name))\n                    block_num+=1\n                    name=chr(ord(name)+1)\n        self.last_conv = [keras.layers.Conv2D(rf(1280,width_coef), kernel_size=1, strides=1, padding='same', use_bias=False),\n                          keras.layers.BatchNormalization(axis=bn_axis),\n                          keras.layers.Activation(SiLU)] #*rd(1, depth_coef)\n        \n        self.top = [keras.layers.GlobalAveragePooling2D(),\n                    keras.layers.Dropout(dropout),\n                    keras.layers.Dense(5,activation='softmax')]\n        \n        #for i in default_efficient:\n        #    print(i)\n        \n        \n    def call(self, inputs):\n        Z = inputs\n        for layer in self.first_conv:\n            Z = layer(Z)\n        for layer in self.MB_layers:\n            Z = layer(Z)\n        for layer in self.last_conv:\n            Z = layer(Z)\n        for layer in self.top:\n            Z = layer(Z)\n        return Z\n    \n    def get_config(self):\n        basic_config = super().get_config()\n        return {**basic_config,\n                'default_efficient':self.default_efficient,\n                'width_coef':self.width_coef,\n                'depth_coef':self.depth_coef,\n                'resolution':self.resolution,\n                'dropout':self.dropout,\n                'dropout_connect':self.dropout_connect}\n    \n    def model(self):\n        x = tf.keras.layers.Input(shape=(self.resolution, self.resolution, 3))\n        model = keras.models.Model(inputs=x, outputs=self.call(x))\n        model.compile(optimizer=keras.optimizers.RMSprop(),\n                      loss=condition_penalty_loss(1),\n                      metrics=keras.metrics.CategoricalAccuracy())\n        return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"callbacks = [\n    keras.callbacks.EarlyStopping(monitor='val_categorical_accuracy',\n                                  mode='max',\n                                  patience=4,\n                                  # restore_best_weights=True,\n                                  verbose=1),\n\n    keras.callbacks.ModelCheckpoint('EfficientNet_best.h5',\n                                    save_best_only=True,\n                                    monitor='val_loss',\n                                    mode='min'),\n\n    keras.callbacks.ReduceLROnPlateau(monitor='val_loss',\n                                      factor=0.1,\n                                      patience=2,\n                                      min_lr=1e-6,\n                                      verbose=1)\n]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class_weights = {}\ncount_by_class = get_count_by_class(train)\n\nprint(count_by_class)\nmi=987654321\nfor i in range(len(count_by_class)):\n    class_weights[i]= (1/count_by_class[i][1][0]) * len(train) / 2.0\n    mi = min(mi, class_weights[i])\nprint(mi)\nfor k,v in class_weights.items():\n    class_weights[k]/=mi\n    class_weights[k]*=1.5\nclass_weights[4]*=4\nprint(class_weights)\n\n#hard coding\n#class_weights = {0: 5.171670702179177 , 1: 5.136844636844637, 2: 4.710851345390384, 3: 0.8543600000000001, 4: 4.362540849673203}","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\nmodel = keras.Sequential()\nmodel.add(tf.keras.applications.EfficientNetB3(include_top=False, weights='imagenet', input_tensor=None,\n                                               input_shape=None, pooling=None, classes=5))\nmodel.add(keras.layers.GlobalAveragePooling2D())\nmodel.add(keras.layers.Dropout(0.3))\nmodel.add(keras.layers.Dense(5,activation='softmax'))\nmodel.compile(optimizer=keras.optimizers.RMSprop(0.001),\n                      loss=keras.losses.CategoricalCrossentropy(),\n                      metrics=keras.metrics.CategoricalAccuracy())\nprint(model.summary(line_length=150))\n#model.fit(train_set, validation_data=val_set,\n#                              epochs=5, callbacks=callbacks, class_weight=class_weights)  \n#model.save('tf_efficientB3_5epochs.h5')\n'''","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#tf.keras.applications.EfficientNetB3(include_top=False, weights='imagenet', input_tensor=None,\n#                                               input_shape=None, pooling=None, classes=5).summary(line_length=150)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"MODEL_PATH = '../input/efficientnet-day7/EfficientNet_day7.h5'\nefficientNet_B3 = None\nif os.path.isfile(MODEL_PATH):\n    efficientNet_B3 = keras.models.load_model(MODEL_PATH, custom_objects={\n                                                                          'condition_penalty_loss':condition_penalty_loss})\n    #efficientNet_B3.compile(optimizer=keras.optimizers.RMSprop(0.0005),\n    #              loss=condition_penalty_loss(5),\n    #              metrics=keras.metrics.CategoricalAccuracy())\n    print(\"Using previous Model\")\nelse:\n    efficientNet_B3 = EfficientNet(default_efficient, 1.2, 1.4, 512, 0.3).model()\n    print(\"Using New Model\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class ResidualUnit(keras.layers.Layer):\n    def __init__(self, filters, strides=1, activation='relu', use_se=False, **kwargs):\n        super().__init__(**kwargs)\n        self.filters = filters\n        self.strides = strides\n        self.activation = activation\n        self.use_se=use_se\n        self.activation=keras.activations.get(activation)\n        self.main_layer = [keras.layers.Conv2D(filters, 3, strides=strides, padding='same',\n                                                use_bias=False),\n                           keras.layers.BatchNormalization(),\n                           self.activation,\n                           keras.layers.Conv2D(filters, 3, strides=1, padding='same',use_bias=False),\n                           keras.layers.BatchNormalization()]\n        if use_se==True:\n            self.main_layer.append(SEUnit(filters))\n        self.skip_layer=[]\n        if strides>1:\n            self.skip_layer = [keras.layers.Conv2D(filters, 1, strides=strides, padding='same',\n                                                    use_bias=False),\n                          keras.layers.BatchNormalization()]\n    \n    def call(self, inputs):\n        Z = inputs\n        for layer in self.main_layer:\n            Z = layer(Z)\n        skip_Z = inputs\n        for layer in self.skip_layer:\n            skip_Z = layer(skip_Z)\n        return self.activation(Z+skip_Z)\n    \n    def get_config(self):\n        base_config = super().get_config()\n        return {**base_config, \n                \"filters\": self.filters, \"strides\":self.strides, \n                \"activation\":self.activation, \"use_se\":self.use_se}\n    \nclass SEUnit(keras.layers.Layer):\n    def __init__(self, feature_map_len, **kwargs):\n        super().__init__(**kwargs)\n        self.feature_map_len = feature_map_len\n        self.global_avg_pool = keras.layers.GlobalAvgPool2D()\n        self.squeeze = keras.layers.Dense(feature_map_len//16, activation='relu')\n        self.excitation = keras.layers.Dense(feature_map_len,activation='sigmoid')\n    \n    def call(self, inputs):\n        Z = inputs\n        Z = self.global_avg_pool(Z)\n        Z = self.squeeze(Z)\n        excitation_vector = self.excitation(Z)\n        excitation_vector = tf.reshape(excitation_vector, [-1,1,1,self.feature_map_len])\n        return inputs*excitation_vector\n    \n    def get_config(self):\n        base_config = super().get_config()\n        return {**base_config,\"feature_map_len\":self.feature_map_len}\n        ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"use_se=True\nresnet=None\nMODEL_PATH = '../input/weighted-se-resnet-16epochs/weighted_se_resent_16epochs.h5'\nresnet = keras.models.load_model(MODEL_PATH,custom_objects={'ResidualUnit':ResidualUnit})\nprint(\"Using previous Model\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"import tensorflow.keras as tfk\ntest_csv = pd.read_csv(PATH+'sample_submission.csv')\npreds_efficient = []\npreds_resnet = []\ntest_images = []\nfor image_id in test_csv.image_id:\n    image = tfk.preprocessing.image.load_img(PATH+\"test_images/\"+image_id)\n    image = tfk.preprocessing.image.img_to_array(image)\n    image = np.array([image])\n    preds_efficient.append(efficientNet_B3.predict(image,batch_size=1))\n    preds_resnet.append(resnet.predict(image,batch_size=1))\n\ntest_csv['label']=np.argmax(np.array(preds_efficient)*0.7 + np.array(preds_resnet)*0.3,axis=-1)\ntest_csv.to_csv('submission.csv',index=False)\nprint(test_csv)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#print(efficientNet_B3.summary())\n#history = efficientNet_B3.fit(train_set, validation_data=val_set,\n#                              epochs=10, callbacks=callbacks, class_weight=class_weights)\n#efficientNet_B3.save('EfficientNet.h5')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#y_pred = efficientNet_B3.predict(val_set)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#y=val['label']","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#import numpy as np\n#class_y_pred = [np.argmax(i) for i in y_pred]\n#print(len(class_y_pred))\n#print(len(y))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#from sklearn.metrics import confusion_matrix\n#cm = confusion_matrix(y,class_y_pred)\n#print(cm)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\ncm = [[ 81,   3,   2,   1,  22],\n [ 15, 133,   4,   4,   8],\n [  5,   2, 151,   9,  12],\n [  1,   5,   7, 180,   5],\n [ 28,   9,  11,   7, 138]]\ncm=np.array(cm)\n'''","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\nrow_sums = cm.sum(axis=1,keepdims=True)\ncm=cm/row_sums\ndia_cm = deepcopy(cm)\nnp.fill_diagonal(dia_cm,0)\nprint(cm)\nplt.figure(figsize=(2,1))\nplt.matshow(cm, cmap=plt.cm.gray)\nplt.matshow(dia_cm, cmap=plt.cm.gray)\nplt.show()\n'''","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\nfor i in range(len(y)):\n    if class_y_pred[i] != y[i]:\n        bi = i//6\n        bj = i%6\n        val_set[bi][0][bj]\n'''","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#print(history.keys())\n#draw_grpah(history)\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#tf.shape(train_set[0])","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}