{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Protect Title: Deep learning classification of malignant vs non-malignant melanoma from photographs of the lesion.\n\n*Machine Learning Report by Georgina Wager*\n\nNote: The [Authors’ Github](https://github.com/georginaanna/C7082-Assesment) contains the raw script and the report, the data used can be obtained from [here](https://www.kaggle.com/c/siim-isic-melanoma-classification/data). \n"},{"metadata":{},"cell_type":"markdown","source":"## **Project Outline**\n\nThis project is part of the assessment for the module C7082 Techniques in Machine Learning and AI, that is ran at Harper Adams University College by Ed Harris for the MSc Course: Data Science for Global Agriculture, Food and Environment. The project is proposed to use a deep learning algorithm to classify images of lesions as either malignant or non-malignant melanoma. For the analysis, the data was not collected by myself, and instead was obtained from Kaggle, a website that contains many data sets for keen data science learners to enter competitions and practice predictive modelling and analytics (Shaikh, R, not dated).\n\nThis project is to use images of lesions and meta data surrounding the circumstances of the image (this is the sex and age of the patient, and the location of the lesion on the body), to carry out a deep learning classification problem to identify if the lesion within the photograph is malignant or a non-malignant melanoma. The prediction is the classification, with an associated probability for each possible class, the scale is 0-1 and it is the probability of the lesion being classified as malignant or non-malignant (benign).\n\nMelanoma is a common skin cancer type, with the World Health Organisation documenting that in 2015 more than 3.1 million people globally were diagnosed with melanoma and for 60,000 people resulted in death (Gálvez and Iglesias, 2020). Melanoma is particularly aggressive as if left undetected it can begin to invade nearby tissues and spread to other parts of the body (e.g., liver, bone, lung, or brain). In addition, data suggests that the number of cases will continue to increase significantly in the coming years (Gálvez and Iglesias, 2020). The first part of melanoma diagnosis is to classify the skin lesion as either benign or malignant, this is a process that first begins by image segmentation. Image segmentation is where the lesion in an image has filters applied to bring more focus to the lesion (the area of interest). These images are then passed to dermatologists who analyse a multiple lesion from the same patient and aim to identify any outliers that could likely be melanoma (Green et al., 2020). The current approach is not a fully digital experience and still relies heavily on dermatologists, therefore this project will aim to use the data set to build a model with the highest accuracy to be able to accurately predict if a lesion is malignant or non-malignant (benign) (Gálvez and Iglesias, 2020). The quicker the ability to detect accurately where a lesion is malignant will aid in providing fast and effective treatment. When detected early, the 5-year survival rate ranges between 89 and 95% for stages I and II with peaks of 99% for stage 0, while it decreases to 25–70% for stage III and only 7–20% for stage IV. In this regard, early diagnosis is particularly important as early-stage melanoma can usually be removed with minor surgery (Gálvez and Iglesias, 2020). \n\nMachine learning will be utilised fully for this project through initially building a Convolutional Neural Network (CNN) model. CNNs are preferred over traditional neural networks called the multilayer perceptron’s (MLPs) for image classification tasks, largely because they transfer image information into a readable format for a model whilst maintaining spatial information.\n"},{"metadata":{},"cell_type":"markdown","source":"**Objectives:**\n\n* To find a deep learning model that classifies an image of a lesion as either malignant or a non-malignant melanoma\n* Adapt the model to allow for optimum accuracy\n"},{"metadata":{},"cell_type":"markdown","source":"## **Method**"},{"metadata":{},"cell_type":"markdown","source":"The exact source of the data is: https://www.kaggle.com/c/siim-isic-melanoma-classification/overview, due to the volume of data within the dataset and the limited resources to download and reupload the data  the analysis was carried out in a Kaggle kernel. [Here](https://youtu.be/RU2pIzSftsg) is a video made by the author to demonstrate how data was added to the kernel, in Kaggle, sadly the sound was not working. The kernel in the case of this analysis is a python script that runs in the Kaggle docker. The data was collected by The International Skin Imaging Collaboration (ISIC), as part of a global plan to maximise the efficiency of melanoma diagnosis. The data contained information such as the age of the patient, the patient sex, the location of the lesion, the patient ID and whether the lesion was malignent or non-malignent, each image has a row within the data. \n\nThe images that have been used for this analysis are jpeg images and these are in a separate location to the meta data. The train data set contains 33,126 observations and the test set contains 10,982 observations. All images used were jpeg files in red, green and blue (RGB) format and a variety of different sizes, the final size chosen was dependent on accuracy results of the model. \n\nTo be able to test the accuracy of the model the training data set was further diced, removing 20% of the data and classifying this as the validation set. A training data set is required to fir the model, and a validation set can provide an unbiased evaluation of a model fit on the training dataset while tuning model hyperparameters. The evaluation becomes more biased as skill on the validation dataset is incorporated into the model configuration. Whereas the test data can provide a final unbiased evaluation of a final model fit on the training dataset (James et al., 2013).\n\nFirstly the data was added to this notebook, this was done via the \"+ Add data\" on the right hand column of the kernal notebook. Competition data was selected from the top bar, then \"SIIM-ISIC Melanoma Classification\" was searched for in the search box. When the option came up the button \" Add\" was pressed to add it to the kernal, for step by step instructions please refer to the [authors video](https://youtu.be/RU2pIzSftsg). The first step was to ensure that the work done in this model was reproducible using the random.seed () function. "},{"metadata":{"trusted":true},"cell_type":"code","source":"## Reproducibility\n## Random seed given\nimport random ## import the random library\nrandom.seed(10) ## Setting the seed to get the same answer no matter how many times and who runs the model","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Next models were downloaded that would carry out a variety of functions this included downloading the numpy library to enable linear functions, the pandas library for data processing, the glob library for producing arrays of images, the cv2 library for adding labels to specific images, the matplotlib.pyplot library for producing plots. A key package utilised was the “keras.preprocessing.image” that utilised the library’s ImageDataGenerator, load_img, img_to_array, array_to_img which all aid in image pre-processing. The ImageDataGenerator is of specific importance as this converts the RGB format that is a numeric figure between 0 and 255 for each red, green and blue component. These numbers must be changed to a grid of pixels and turned into tensors for the CNN to read and understand the image and the image components, these tensor values are also rescaled to a number between 0 and 1. "},{"metadata":{"trusted":true},"cell_type":"code","source":"## Downloading specific libraries\nimport numpy as np ## Library that enables linear functions \nimport pandas as pd ##  # Enables data processing\nimport glob ## returns an array of filenames that match a pattern\nimport cv2 ## helps add labels to image classifications\nimport matplotlib.pyplot as plt ## library for producing figures\nfrom keras.preprocessing.image import ImageDataGenerator, load_img, img_to_array, array_to_img ## importing image processing packages from \n## keras\nfrom keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout ## Import libraries for model building ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Next the images were read and the location of images was added to this data, as this was in a seperate location. The meta data also contained the class of the image, for exsample identified it as malignent or non malignent.  "},{"metadata":{"trusted":true},"cell_type":"code","source":"## Read the train csv file\ntrain_dir='/kaggle/input/siim-isic-melanoma-classification/jpeg/train/' ## assigning a name to the location of the train images\ntrain=pd.read_csv('/kaggle/input/siim-isic-melanoma-classification/train.csv') ## assigning a name to the location of the CSV file\n\n## Read the test csv file\ntest_dir='/kaggle/input/siim-isic-melanoma-classification/jpeg/test/' ## assigning a name to the location of the test images\ntest=pd.read_csv('/kaggle/input/siim-isic-melanoma-classification/test.csv') ## assigning a name to the location of the CSV file ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train['path'] = train_dir + train.image_name + \".jpg\" ## adding the location of the image to the row for the train data set\ntrain.head() ## showing the first 5 lines of the train data set, note the \"path\" coloumn \n\ntest['path'] = test_dir + test.image_name + \".jpg\"  ## adding the location of the image to the row for the test data set\ntest.head()  ## showing the first 5 lines of the test data set, note the \"path\" coloumn ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The next step was to understand the distribution of the classes within the data set. This told us the 32,542 images were classed as \"0\" hence non malignent and only 584 were malignent, this is a very uneven distribution of classes. "},{"metadata":{"trusted":true},"cell_type":"code","source":"## Class Distribution\ntrain.target.value_counts() ## Count the number of images that were classified as malignent or non malignent","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Based on the uneven distribution of the classes within the data set the train data set was set to only include 1000 of class 0 and 584 of class 1.  "},{"metadata":{"trusted":true},"cell_type":"code","source":"df_0=train[train['target']==0].sample(1000) ## produce a data frame using 1000 images from the train data set where the target equals zero\ndf_1=train[train['target']==1] ## produce a data frame using all the images from the test data set where the target equals 584\ntrain=pd.concat([df_0,df_1]) ## create a new dataset using the smaller training data set\ntrain=train.reset_index() ## making sure the new \"train\" data set is being used for the model","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"To check that the new training set was made up of 1584 samples the train.shape function was used. "},{"metadata":{"trusted":true},"cell_type":"code","source":"train.shape ## how many observations and variables are in the training set being used for the model ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train.head() ## First 5 rows of the new train set with the path information","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The final model chosen will be shown below but first here is an overview of the other models. All model were ran using GPUs. \n\n[Model 1](https://www.kaggle.com/georginawager/cnn-model-1):- Model one was a basic CNN with no image argumentation, this model had a validation loss of 2.4 and a validation accuracy of 73%, these figures are often a result of overfitting. This model had image sizes at 150 x 150 and epoch at 30. \n\n[Model 2](https://www.kaggle.com/georginawager/cnn-model-2):- In an attempt to reduce overfitting because of the small training data set image augumentation was utilised. The image size has increased to 200 x 200 and the epoch was increased to 75. This model resulted in an improvement in the validation loss to 0.4993 and the validation accuracy increased to 77%.\n\nNext the model that had the best validation accuracy in comparison to the previous three models is explained below, the difference between this model and the other was the image size decreased to 120 x 120 but the epochs remaind the same as model to at 75."},{"metadata":{"trusted":true},"cell_type":"code","source":"# we will resize the given images to 120 x 120 size images for faster processing\nIMG_DIM = (120, 120) ## changing the image dimensions ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.model_selection import train_test_split ## importing the train test split function \nX_train, X_val, y_train, y_val = train_test_split(train, train.target, test_size=0.2, random_state=42) ## taking 20% of the training data set ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The pathway for the images for both the train and validation set were established, and the images in these files were changed to arrays with labels for each image. Arrays are essential for any machine learning problem as they can be used to represent images. "},{"metadata":{"trusted":true},"cell_type":"code","source":"train_files = X_train.path ## Image path for the training data set\nval_files = X_val.path ## Image path for the validation data set\n\ntrain_imgs = [img_to_array(load_img(img, target_size=IMG_DIM)) for img in train_files] ## load images using load_img function from keras \n## preprocessing using the target_size function \nvalidation_imgs = [img_to_array(load_img(img, target_size=IMG_DIM)) for img in val_files] ## using the img_to_array will tranform the loaded image to an array\n\ntrain_imgs = np.array(train_imgs) ## converting the list of arrays to array for the training dataset \ntrain_labels = y_train\n\nvalidation_imgs = np.array(validation_imgs) ## converting the list of arrays to array for the validation dataset \nval_labels = y_val\n\n\nprint('Train dataset shape:', train_imgs.shape, \n      '\\tValidation dataset shape:', validation_imgs.shape) ## asking for the number of observations in the data set after image argumentations ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Next the images were scaled and converted into an RGB format, this is a numeric figure between 0 and 255 for each red, green and blue component. These numbers must be changed to a grid of pixels and turned into tensors for the CNN to read and understand the image components, these tensor values are also rescaled to a number between 0 and 1. "},{"metadata":{"trusted":true},"cell_type":"code","source":"## Scaling the images\n\ntrain_imgs_scaled = train_imgs.astype('float32') ## scale each image with pixel values between (0, 255) \nvalidation_imgs_scaled  = validation_imgs.astype('float32') ## do the same for the validation images\n\n# divide the pixels by 255 to scale the pixels between 0 and 1\ntrain_imgs_scaled /= 255\nvalidation_imgs_scaled /= 255\n\nprint(train_imgs[0].shape) ## print the shape of the images\n\narray_to_img(train_imgs[0]) ## using the array_to_img function will convert the given array to image","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# setup basic configuration\nbatch_size = 30 ## indicating the total number of images passed to the model per iteration\nnum_classes = 2 \nepochs = 75 ## establishing the training time \ninput_shape = (120, 120, 3)\n\nfrom keras.models import Sequential ## importing the sequential library\nfrom keras import optimizers ## importing optimizers","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Image augumentation was used in the chosen model as the first model used had no image augumentation and could not generalise well which resulted in overfitting. Image augmentation is a process of altering a single image and turning it into multiple images for a bigger training set. Image augmentation is a process of altering orginal images and applying transformations to them to produce a new image that is based on the existing image. These images were then fed into the model (Chollet, 2018). "},{"metadata":{"trusted":true},"cell_type":"code","source":"train_datagen = ImageDataGenerator(rescale=1./255, zoom_range=0.3, rotation_range=70,\n                                   width_shift_range=0.3, height_shift_range=0.3, shear_range=0.3, \n                                   horizontal_flip=True, fill_mode='nearest')\n\nval_datagen = ImageDataGenerator(rescale=1./255)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The ImageDataGenerator from the \"Keras\" libray was utilised to transform the raw images and produce new images that we can add to the model. The images were zoomed randomly by a factor of 0.3 using the zoom_range parameter, rotated by 70 degrees using the rotation_range parameter and translation of the images randomly horizontally or vertically by a 0.3 factor of the image’s width or height using the width_shift_range and the height_shift_range parameters. The images have undergone random shear-based transformations through the shear_range parameter and randomly flipping half the image from a horizonatal perspective using the horizontal_flip parameter. Next the fill_mode() function was used to provide pixel values for new images from the nearest pixel values, this is an improtant step when creating new images. "},{"metadata":{"trusted":true},"cell_type":"code","source":"## Viewing a random image and see how a transformated image looks\nimg_id = 1\n\nimg_generator = train_datagen.flow(train_imgs[img_id:img_id+1], train_labels[img_id:img_id+1],\n                                   batch_size=1)\n\nimg = [next(img_generator) for i in range(0,5)]\n\nfig, ax = plt.subplots(1,5, figsize=(16, 6))\nprint('Labels:', [item[1][0] for item in img])\nl = [ax[i].imshow(img[i][0][0]) for i in range(0,5)]","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Each new image has been assigned a label so it can be identified by the model. The new images are only in the training data set and not in the validation data set,this is because we want to test the model on the orginal data (validation set) without any image augmentation."},{"metadata":{},"cell_type":"markdown","source":"The train_generator function was utilised for training the batch size for the training set, which has been set at 30 and the val_generator function utilised for training the batch size for the validation set which has been set at 20. Next the sequential function was used for the basic structure of the model. Before defining the basic convent, which is made up of layers of Conv2D and Maxpooling to understand the images such as the edges, these layers pull through information from the feature map into the final layers (Chollet, 2018). There are multiple Conv2 and Maxpooling layers for this model and this is to reduce the size of the feature map prior to reaching the flatten layer. A flatten layer is used for converting the data into a 1-dimensional array for inputting it into the next layer. We flatten the output of the convolutional layers to create a single long feature vector, this is connected to the final classification model.                                                                                                       Next two dense components were used with 512 dense layers all layers are fully connected, meaning all the neurons in a layer are connected to those in the next layer. A drop out layer has been used for regulation. A final dense layer has been used establishing one layer here to encode the probability of one class or another (Chollet, 2018).\n\nNext the model is compiled using the model.compile function, here the loss function, optimiser and metric is defined. The loss function is defined first, for this model it is binary classification therefore binary_crossentropy is used to define this function (Chollet, 2018).  The optimiser utilised here is the RmsProp that utilizes the magnitude of recent gradients to normalize the gradients. A moving average is utilised over the root mean squared (RMS). An optimiser is also defined as this provides the stochastic gradient descent this has been set at 0.0001. Finally the metric that the model needs to be assessed by is “accuracy” as this will allow us to determine how effective the model is, this metric is given for both the training and validation set. \n\nThe fit_generator() function from the keras package has been used to train the model by defining the steps_per_epoch at 32 and the standard epoch at 75. Epoch is the number of passes of the entire training dataset into the model.\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"## Random seed given\nimport random ## import the random library\nrandom.seed(10) ## Setting the seed to get the same answer no matter how many times and who runs the model\n\nfrom keras.models import Sequential ## importing the sequential library\nfrom keras import optimizers ## importing optimizers\n\ntrain_generator = train_datagen.flow(train_imgs, train_labels, batch_size=30) ## defining the batch size\nval_generator = val_datagen.flow(validation_imgs, val_labels, batch_size=20) ## defining the batch size\n\ninput_shape = input_shape\n\nmodel = Sequential()  ## creating the model structure with one input tensor and one output tensor.\n## add Conv2D layer,filter size,kernel size,activation and padding are the parameters used\n## to create a feature map for each filter used\n## feature maps created here are then taken through the activation function(relu), which decides whether a certain feature is present \n## at a given point in the image.\n\nmodel.add(Conv2D(16, kernel_size=(3, 3), activation='relu', \n                 input_shape=input_shape))\n## Pooling layer used here will select the largest values on the feature maps and use these as inputs to subsequent layers\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\n\n## another set of Convolutional & Max Pooling layers\nmodel.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\n\nmodel.add(Flatten())\n## The Dense part with 512 layers\nmodel.add(Dense(512, activation='relu'))\nmodel.add(Dropout(0.3))\nmodel.add(Dense(512, activation='relu'))\nmodel.add(Dropout(0.3))\n## sigmoid function here will help perform binary classification\nmodel.add(Dense(1, activation='sigmoid')) ## establishing one layer here to encode the probability of one class or another\n\nmodel.compile(loss='binary_crossentropy', ## defining the loss function\n              optimizer=optimizers.RMSprop(lr=1e-4), ## defining the optimiser \n              metrics=['accuracy']) ## defining the measure in this case it is the accuracy\n              \nhistory = model.fit_generator(train_generator, steps_per_epoch=32, epochs=75,\n                              validation_data=val_generator, validation_steps=12, \n                              verbose=1) ## fitting the model ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true,"_kg_hide-input":false},"cell_type":"code","source":"f, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) ## determing the size of the plot \nt = f.suptitle('CNN Model 3- with image argumentation', fontsize=12) ## plot title\nf.subplots_adjust(top=0.85, wspace=0.3) ## padding\n\n## Creating a graph for the training data accuracy and loss results\nepoch_list = list(range(1,76)) ## number of epochs on the x axis\nax1.plot(epoch_list, history.history['accuracy'], label='Train Accuracy') ## adding labels \n## and plotting the data \nax1.plot(epoch_list, history.history['val_accuracy'], label='Validation Accuracy') ## adding labels \n## and plotting the data \nax1.set_xticks(np.arange(0, 76, 5)) \nax1.set_ylabel('Accuracy Value')\nax1.set_xlabel('Epoch')\nax1.set_title('Accuracy')\nl1 = ax1.legend(loc=\"best\")\n\n## same again for the validation data \nax2.plot(epoch_list, history.history['loss'], label='Train Loss')\nax2.plot(epoch_list, history.history['val_loss'], label='Validation Loss')\nax2.set_xticks(np.arange(0, 76, 5))\nax2.set_ylabel('Loss Value')\nax2.set_xlabel('Epoch')\nax2.set_title('Loss')\nl2 = ax2.legend(loc=\"best\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## **Results**"},{"metadata":{},"cell_type":"markdown","source":"![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{},"cell_type":"markdown","source":"The model has a training accuracy of 72% and a validation accuracy of 80%, where as loss went from 0.49 in the training set to 0.41 in the validation set. "},{"metadata":{},"cell_type":"markdown","source":"## **Discussion**"},{"metadata":{},"cell_type":"markdown","source":"The model produced, successfully classifies an image as malignant or non-malignant, with an accuracy of 80% and a loss of 0.41. However, there is both room and need for improvement, especially when classifying images as malignant or non-malignant. The incorrect classification of a lesion could have devastating impacts on the patient who has received the classification and the general health care system. The effects could result in a cancerous lesion developing into a state that can increase the chance of fatalities, in turn leaving patients impacted both mentally and physically. For health care systems it could result in people having a lack of trust in the health care system.  Therefore, it is important that a model is produced that can be extremely accurate and reliable for both the patient and the health care system. A further point to consider when weighing up the use of this model for medical imaging is the accuracy of dermatologists detecting lesions as malignant or non-malignant, as that accuracy could be considerably more or less than a basic CNN model. \n\nIt is also important to mention that a basic CNN model was chosen for this analysis, further improvements could have been made by using transfer learning where a previously trained network convolutional base could have been used for the new data, with a specific classifier layer that is specific to the lesion classification problem. Pretrained CNNs are more complicated than basic CNNs but this does allow for higher accuracy percentages. Some examples that could have been utilised are; VGG19, ResNet50 and Xception. Further to this a Region Based Convolutional Neural Network could have been used to focus more on the object within the image – in this case this would be the lesion. \n\nFuture areas of improvement would be to try and get an equal data set of both malignant and non- malignant images. The current model tried to achieve this through data argumentation techniques, however more images would possibly provide a better training data set to then train the model and improve accuracy. A further option to tackle the uneven distribution of the two classes throughout the data set would have been to use a K-cross validation as an alternative to splitting the training data set into a train and validation data set. \n\nThe quality of the images was relatively good but some of the images had hairs that overlapped the lesion, this could have impacted the accuracy of the model. The model also did not take into consideration patient information, as one patient could have very similar lesions, instead the model saw the lesions as all independent from each other if this were included in the model this could have influenced the model accuracy. \n\nOverall, the model successfully classifies the image, but the accuracy could be improved through different image augmentation techniques, using k fold cross validation and the use of a pretrain convent. However, the results are still better compared to if using an MLP. In addition to pretrained CNNs a Region Based Convolutional Neural Network (R-CNN) could have been utilised as this focuses more on the object within an image- the lesion. However due to the limited experience of the author in coding in python this was not explored. To go a step further in model improvement more images of malignant lesions would allow a more even distribution of the classes. \n"},{"metadata":{},"cell_type":"markdown","source":"## **References**"},{"metadata":{},"cell_type":"markdown","source":"Chollet, F. 2018. *Deep Learning with python*. Shelter Island: Manning.\n\nGálvez, A. and Iglesias, A. 2020. *Memetic improved cuckoo search algorithm for automatic B-spline border approximation of cutaneous melanoma from macroscopic medical images. *Advanced Engineering Informatics, 43, p.101005.\n\nJames, G., Witten, D., Hastie, T. and Tibshirani, R. 2013. *An introduction to statistical learning *(Vol. 112). New York: springer.\n\nGoodfellow, I., Bengio, Y., Courville, A. 2016. *Deep learning* (Vol. 1, No. 2). Cambridge: MIT press.\n\nGreen, A.C., Pandeya, N., Morton, S., Simonidis, J. and Whiteman, D.C. 2020. *Early detection of melanoma in specialised primary care practice in Australia*. Cancer Epidemiology, 70, p.101872.\n\nShaikh, R. not dated. *To Kaggle Or Not*. [Online]. KDNuggets. Available from: https://www.kdnuggets.com/2018/05/to-kaggle-or-not.html [Accessed 17 January 2021]. \n[](http://)"}],"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}