Upload 6 files

training commit

.gitignore

@@ -0,0 +1,165 @@
+#Inserted by me
+digit_model.h5
+digit_model.keras
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

app.py

@@ -0,0 +1,408 @@
+# import system libs
+import os
+import time
+import shutil
+import itertools
+
+# import data handling tools
+import cv2
+import numpy as np
+import pandas as pd
+import seaborn as sns
+sns.set_style('darkgrid')
+import matplotlib.pyplot as plt
+import gradio as gr
+
+# import Deep learning Libraries
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Activation, Dropout, BatchNormalization
+from tensorflow.keras.models import Model, load_model, Sequential
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from sklearn.metrics import confusion_matrix, classification_report
+from sklearn.model_selection import train_test_split
+from tensorflow.keras.optimizers import Adam, Adamax
+from tensorflow.keras import regularizers
+from tensorflow.keras.metrics import categorical_crossentropy
+from tensorflow.keras.utils import to_categorical
+from PIL import Image
+from sklearn.model_selection import train_test_split
+
+
+# Ignore Warnings
+import warnings
+warnings.filterwarnings("ignore")
+print ('modules loaded')
+#---Training-----------------------------
+#  ! pip install -q kaggle
+# from google.colab import files
+
+# files.upload()
+# ! mkdir ~/.kaggle
+
+# ! cp kaggle.json ~/.kaggle/
+# ! chmod 600 ~/.kaggle/kaggle.json
+# ! kaggle datasets list
+# !kaggle datasets download -d kmader/skin-cancer-mnist-ham10000
+# ! mkdir kaggle
+# ! unzip skin-cancer-mnist-ham10000.zip -d kaggle
+# data_dir = '/content/kaggle/hmnist_28_28_RGB.csv'
+# data = pd.read_csv(data_dir)
+# print(data.shape)
+# data.head()
+
+# Label = data["label"]
+# Data = data.drop(columns=["label"])
+# print(data.shape)
+# Data.head()
+
+# from imblearn.over_sampling import RandomOverSampler
+
+# oversample = RandomOverSampler()
+# Data, Label  = oversample.fit_resample(Data, Label)
+# print(Data.shape)
+# Data = np.array(Data).reshape(-1,28, 28,3)
+# print('Shape of Data :', Data.shape)
+
+# Label = np.array(Label)
+# Label
+# classes = {4: ('nv', ' melanocytic nevi'),
+#            6: ('mel', 'melanoma'),
+#            2 :('bkl', 'benign keratosis-like lesions'),
+#            1:('bcc' , ' basal cell carcinoma'),
+#            5: ('vasc', ' pyogenic granulomas and hemorrhage'),
+#            0: ('akiec', 'Actinic keratoses and intraepithelial carcinomae'),
+#            3: ('df', 'dermatofibroma')}
+
+
+
+# X_train , X_test , y_train , y_test = train_test_split(Data , Label , test_size = 0.25 , random_state = 49)
+
+# print(f'X_train shape: {X_train.shape}\nX_test shape: {X_test.shape}')
+# print(f'y_train shape: {y_train.shape}\ny_test shape: {y_test.shape}')
+
+# y_train = to_categorical(y_train)
+# y_test = to_categorical(y_test)
+
+# datagen = ImageDataGenerator(rescale=(1./255)
+#                              ,rotation_range=10
+#                              ,zoom_range = 0.1
+#                              ,width_shift_range=0.1
+#                              ,height_shift_range=0.1)
+
+# testgen = ImageDataGenerator(rescale=(1./255))
+
+# from keras.callbacks import ReduceLROnPlateau
+
+# learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy'
+#                                             , patience = 2
+#                                             , verbose=1
+#                                             ,factor=0.5
+#                                             , min_lr=0.00001)
+
+# model = keras.models.Sequential()
+
+# # Create Model Structure
+# model.add(keras.layers.Input(shape=[28, 28, 3]))
+# model.add(keras.layers.Conv2D(32, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal'))
+# model.add(keras.layers.MaxPooling2D())
+# model.add(keras.layers.BatchNormalization())
+
+# model.add(keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal'))
+# model.add(keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal'))
+# model.add(keras.layers.MaxPooling2D())
+# model.add(keras.layers.BatchNormalization())
+
+# model.add(keras.layers.Conv2D(128, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal'))
+# model.add(keras.layers.Conv2D(128, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal'))
+# model.add(keras.layers.MaxPooling2D())
+# model.add(keras.layers.BatchNormalization())
+
+# model.add(keras.layers.Conv2D(256, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal'))
+# model.add(keras.layers.Conv2D(256, (3, 3), activation='relu', padding='same', kernel_initializer='he_normal'))
+# model.add(keras.layers.MaxPooling2D())
+
+# model.add(keras.layers.Flatten())
+
+# model.add(keras.layers.Dropout(rate=0.2))
+# model.add(keras.layers.Dense(units=256, activation='relu', kernel_initializer='he_normal'))
+# model.add(keras.layers.BatchNormalization())
+
+# model.add(keras.layers.Dense(units=128, activation='relu', kernel_initializer='he_normal'))
+# model.add(keras.layers.BatchNormalization())
+
+# model.add(keras.layers.Dense(units=64, activation='relu', kernel_initializer='he_normal'))
+# model.add(keras.layers.BatchNormalization())
+
+# model.add(keras.layers.Dense(units=32, activation='relu', kernel_initializer='he_normal', kernel_regularizer=keras.regularizers.L1L2()))
+# model.add(keras.layers.BatchNormalization())
+
+# model.add(keras.layers.Dense(units=7, activation='softmax', kernel_initializer='glorot_uniform', name='classifier'))
+
+# model.compile(Adamax(learning_rate= 0.001), loss= 'categorical_crossentropy', metrics= ['accuracy'])
+
+# model.summary()
+
+# history = model.fit(X_train ,
+#                     y_train ,
+#                     epochs=25 ,
+#                     batch_size=128,
+#                     validation_data=(X_test , y_test) ,
+#                     callbacks=[learning_rate_reduction])
+
+# def plot_training(hist):
+#     tr_acc = hist.history['accuracy']
+#     tr_loss = hist.history['loss']
+#     val_acc = hist.history['val_accuracy']
+#     val_loss = hist.history['val_loss']
+#     index_loss = np.argmin(val_loss)
+#     val_lowest = val_loss[index_loss]
+#     index_acc = np.argmax(val_acc)
+#     acc_highest = val_acc[index_acc]
+
+#     plt.figure(figsize= (20, 8))
+#     plt.style.use('fivethirtyeight')
+#     Epochs = [i+1 for i in range(len(tr_acc))]
+#     loss_label = f'best epoch= {str(index_loss + 1)}'
+#     acc_label = f'best epoch= {str(index_acc + 1)}'
+
+#     plt.subplot(1, 2, 1)
+#     plt.plot(Epochs, tr_loss, 'r', label= 'Training loss')
+#     plt.plot(Epochs, val_loss, 'g', label= 'Validation loss')
+#     plt.scatter(index_loss + 1, val_lowest, s= 150, c= 'blue', label= loss_label)
+#     plt.title('Training and Validation Loss')
+#     plt.xlabel('Epochs')
+#     plt.ylabel('Loss')
+#     plt.legend()
+
+#     plt.subplot(1, 2, 2)
+#     plt.plot(Epochs, tr_acc, 'r', label= 'Training Accuracy')
+#     plt.plot(Epochs, val_acc, 'g', label= 'Validation Accuracy')
+#     plt.scatter(index_acc + 1 , acc_highest, s= 150, c= 'blue', label= acc_label)
+#     plt.title('Training and Validation Accuracy')
+#     plt.xlabel('Epochs')
+#     plt.ylabel('Accuracy')
+#     plt.legend()
+
+#     plt.tight_layout
+#     plt.show()
+
+#     plot_training(history)
+
+#     train_score = model.evaluate(X_train, y_train, verbose= 1)
+# test_score = model.evaluate(X_test, y_test, verbose= 1)
+
+# print("Train Loss: ", train_score[0])
+# print("Train Accuracy: ", train_score[1])
+# print('-' * 20)
+# print("Test Loss: ", test_score[0])
+# print("Test Accuracy: ", test_score[1])
+
+# y_true = np.array(y_test)
+# y_pred = model.predict(X_test)
+
+# y_pred = np.argmax(y_pred , axis=1)
+# y_true = np.argmax(y_true , axis=1)
+
+# classes_labels = []
+# for key in classes.keys():
+#     classes_labels.append(key)
+
+# print(classes_labels)
+
+# # Confusion matrix
+# cm = cm = confusion_matrix(y_true, y_pred, labels=classes_labels)
+
+# plt.figure(figsize= (10, 10))
+# plt.imshow(cm, interpolation= 'nearest', cmap= plt.cm.Blues)
+# plt.title('Confusion Matrix')
+# plt.colorbar()
+
+# tick_marks = np.arange(len(classes))
+# plt.xticks(tick_marks, classes, rotation= 45)
+# plt.yticks(tick_marks, classes)
+
+
+# thresh = cm.max() / 2.
+# for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
+#     plt.text(j, i, cm[i, j], horizontalalignment= 'center', color= 'white' if cm[i, j] > thresh else 'black')
+
+# plt.tight_layout()
+# plt.ylabel('True Label')
+# plt.xlabel('Predicted Label')
+
+# plt.show()
+
+# #Save the model
+# model.save('skin_cancer_model.h5')
+
+# converter = tf.lite.TFLiteConverter.from_keras_model(model)
+# tflite_model = converter.convert()
+
+# print("model converted")
+
+# # Save the model.
+# with open('skin_cancer_model.tflite', 'wb') as f:
+#     f.write(tflite_model)
+
+#Training End------------------------------------------
+
+skin_classes = {4: ('nv', ' melanocytic nevi'),
+           6: ('mel', 'melanoma'),
+           2 :('bkl', 'benign keratosis-like lesions'), 
+           1:('bcc' , ' basal cell carcinoma'),
+           5: ('vasc', ' pyogenic granulomas and hemorrhage'),
+           0: ('akiec', 'Actinic keratoses and intraepithelial carcinomae'),
+           3: ('df', 'dermatofibroma')}
+
+#Use saved model
+loaded_model = tf.keras.models.load_model('skin_cancer_model.h5', compile=False)
+loaded_model.compile(Adamax(learning_rate= 0.001), loss= 'categorical_crossentropy', metrics= ['accuracy'])
+
+def predict_digit(image):
+    if image is not None:
+        
+        #Use saved model
+        loaded_model = tf.keras.models.load_model('skin_cancer_model.h5', compile=False)
+        loaded_model.compile(Adamax(learning_rate= 0.001), loss= 'categorical_crossentropy', metrics= ['accuracy'])
+        img = image.resize((28, 28))
+        img_array = tf.keras.preprocessing.image.img_to_array(img)
+        img_array = tf.expand_dims(img_array, 0)
+        print(img_array)
+
+       
+
+        predictions = loaded_model.predict(img_array)
+        print(predictions)
+        #class_labels = [] # data classes
+        score = tf.nn.softmax(predictions[0])*100
+
+
+        print(score)
+        print(skin_classes[np.argmax(score)])
+        simple = pd.DataFrame(
+        {
+        "skin condition": ["akiec", "bcc", "bkl", "df", "nv", "vasc", "mel"],
+        "probability": score, 
+        "full skin condition": [ 'Actinic keratoses', 
+              ' basal cell carcinoma',
+              'benign keratosis-like lesions',
+              'dermatofibroma',
+              ' melanocytic nevi',
+              ' pyogenic granulomas and hemorrhage',
+              'melanoma'],
+        }
+        )
+
+
+
+
+        predicted_skin_condition=skin_classes[np.argmax(score)][1]+"   ("+ skin_classes[np.argmax(score)][0]+")"
+        return  predicted_skin_condition, gr.BarPlot.update(
+            simple,
+            x="skin condition",
+            y="probability",
+            x_title="Skin Condition",
+            y_title="Classification Probabilities",
+            title="Skin Cancer Classification Probability",
+            tooltip=["full skin condition", "probability"],
+            vertical=False,
+            y_lim=[0, 100],
+            color="full skin condition"
+        )
+        
+    else:
+        simple_empty = pd.DataFrame(
+        {
+        "skin condition": ["akiec", "bcc", "bkl", "df", "nv", "vasc", "mel"],
+        "probability": [0,0,0,0,0,0,0],
+        "full skin condition": [ 'Actinic keratoses', 
+              ' basal cell carcinoma',
+              'benign keratosis-like lesions',
+              'dermatofibroma',
+              ' melanocytic nevi',
+              ' pyogenic granulomas and hemorrhage',
+              'melanoma'],
+        }
+        )
+
+        return " ", gr.BarPlot.update(
+            simple_empty,
+            x="skin condition",
+            y="probability",
+            x_title="Digits",
+            y_title="Identification Probabilities",
+            title="Identification Probability",
+            tooltip=["full skin condition", "probability"],
+            vertical=False,
+            y_lim=[0, 100],
+            
+        )
+    
+skin_images = [
+    ("skin_image/mel.jpg",'mel'),
+    ("skin_image/nv3.jpg",'nv'),
+    ("skin_image/bkl.jpg",'bkl'),
+    ("skin_image/df.jpg",'df'),
+    ("skin_image/akiec.jpg",'akiec'),
+    ("skin_image/bcc.jpg",'bcc'),
+    ("skin_image/vasc.jpg",'vasc'),
+    ("skin_image/nv2.jpg",'nv'),
+    ("skin_image/akiec2.jpg",'akiec'),
+    ("skin_image/bkl2.jpg",'bkl'),
+    ("skin_image/nv.jpg",'nv'),
+    
+    ] 
+
+def image_from_gallary(evt: gr.SelectData):
+    print(evt.index)
+    return skin_images[evt.index][0]
+
+
+
+css='''
+#title_head{
+text-align: center;
+text-weight: bold;
+text-size:30px;
+}
+#name_head{
+text-align: center;
+}
+'''
+
+with gr.Blocks(css=css) as demo:
+   
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("<h1>Skin Cancer Classifier</h1>", elem_id='title_head')
+            gr.Markdown("<h2>By Alok</h2>", elem_id="name_head")
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("<h3>Browse or Select from given Image</h3>", elem_id='info')
+            with gr.Row():
+                img_upload=gr.Image(type="pil")
+            with gr.Row():
+                with gr.Column():
+                    clear=gr.ClearButton(img_upload)
+                with gr.Column():
+                    btn=gr.Button("Identify")
+                    gry=gr.Gallery(value=skin_images, columns=3, rows=2, show_label=True)
+                    
+        with gr.Column():
+            gr.Markdown("Most probable skin condition")
+            label=gr.Label("")
+            gr.Markdown("Other possible values")
+            bar = gr.BarPlot()
+    
+            
+    btn.click(predict_digit,inputs=[img_upload],outputs=[label,bar])
+    gry.select(image_from_gallary, outputs=img_upload)
+
+           
+        
+    
+demo.launch(debug=True)
+    
+

requirements.txt

@@ -0,0 +1,16 @@
+tensorflow
+keras
+
+scikit_learn<1.3.0
+seaborn==0.12.2
+
+
+gradio
+
+
+
+
+
+
+
+

skin_cancer_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9679368b2f6da9e936c2b9306044d7b90e887189ee279d643c86aede2b844f75
+size 15456152