top of page

Medicina e intelligenza artificiale - Un caso d’uso a scopo didattico Previsione dei Melanomi con l'IA


Molti degli argomenti che sembrano tenere banco nell’ambito della divulgazione delle informazioni canalizzate attraverso i social midia, sono indubbiamente legati alle potenzialità d’uso della tecnologia hardware e software, inerente applicazioni di quella che quasi tutti chiamano “Intelligenza artificiale”. 



Medicina e intelligenza artificiale - Un caso d’uso a scopo didattico Previsione dei Melanomi con l'IA
Medicina e intelligenza artificiale - Un caso d’uso a scopo didattico Previsione dei Melanomi con l'IA


Da parte mia, preferirei chiamare questi strumenti con l’appellativo di “macchine inferenziali” , in quanto, mi sembrerebbe più appropriato, ma poco importa, quello che conta, il fatto che le potenzialità date dall’uso di queste opere dell’ingegno umano, siano impiegate in modo etico e sicuramente, uno degli ambiti d’uso di queste macchine, dove si spera, siano in grado di fornire delle agevolazioni utili alla risoluzione di varie problematiche, è il campo medico.


Sono sicuramente molte le applicazioni possibili, in questo settore, sia per quanto riguarda  

l’hardware (robot che potranno essere ad esempio impiegati in chirurgia, per interventi sempre più specifici), sia per quanto riguarda il software, come ad esempio, in ambito diagnostico, per l’individuazione precoce di determinate patologie. 



Negli studi che sto conducendo, in questo ambito, vorrei portare, nelle pagine di questo articolo, un esempio pratico relativo ad un potenziale impiego di un algoritmo per la classificazione di nei e melanomi. 

 

Usare l'IA per analizzare Nei e Melanomi 

Come molti sapranno, nei e melanomi, a livello visivo, sono delle irregolarità presenti nel derma: macchioline più o meno scure, in rilievo o meno, solitamente presenti in modo più accentuato in alcune parti del corpo, come la schiena. 


La differenza fondamentale tra un neo ed un melanoma, consiste nel fatto che, se il primo non ha una potenziale incidenza sulla salute della persona, il secondo invece, potrebbe risultare estremamente pericoloso, porche potrebbe risultare essere una espressione cancerosa di cellule epidermiche. 


Tipicamente la differenza visiva tra un neo (nevo) e un potenziale melanoma, potrebbe essere riassunta in queste immagini: 




Se chiediamo ad una “intelligenza artificiale di fornirci una descrizione di nei e melanomi, 

probabilmente ci darà una risposta simile a questa: 


mi puoi fornire una descrizione su nei e melanomi? 

Chat GPT: Certo, posso darti una breve descrizione su nei e melanomi. 

Nei (o nei melanocitici): I nei, o nevi, sono accumuli di cellule pigmentate chiamate melanociti, che sono responsabili della produzione del pigmento melanina. Questi nevi possono essere presenti sulla pelle fin dalla nascita o svilupparsi nel corso della vita a causa dell'esposizione al sole. La maggior parte dei nevi è benigna e non causa problemi. Essi possono apparire di colore marrone, nero o rosa e possono variare in forma e dimensione. 


È importante monitorare i cambiamenti nei nei, come la forma, il colore e la dimensione, poiché modifiche insolite possono essere segnali di possibili problemi. 


Melanoma: Il melanoma è un tipo di cancro della pelle che origina dai melanociti. È meno comune rispetto ad altri tipi di cancro della pelle, ma è più aggressivo e può diffondersi ad altri organi se non trattato precocemente. Il melanoma può svilupparsi in modo indipendente o derivare da un nevo esistente. I fattori di rischio includono l'esposizione eccessiva ai raggi UV, la predisposizione genetica e la presenza di molti nevi atipici (nevi che presentano caratteristiche insolite). I segni di melanoma includono cambiamenti nei bordi del nevo, nella forma, nel colore e nella dimensione, nonché la comparsa di prurito o sanguinamento. 



La prevenzione del melanoma include pratiche di protezione solare, come l'uso di creme solari e l'evitare l'esposizione prolungata al sole. In caso di sospetto melanoma, è fondamentale consultare un medico per una valutazione approfondita e, se necessario, per la rimozione e il trattamento precoce. La diagnosi precoce è cruciale per migliorare le prospettive di guarigione nel caso del melanoma. 


Quindi, dopo aver consultato il parere dell’intelligenza artificiale possiamo dire che, ovviamente, spetta ad un medico con specializzazione in dermatologia, effettuare una analisi diagnostica accurata e valutare, caso per caso, le azioni da intraprendere, in questo contesto, ma, per il nostro caso d’uso della intelligenza artificiale in questo ambito, sarebbe già un buon risultato far si che, con l’utilizzo di un algoritmo operante come classificatore di immagini,  riuscissimo a far distinguere, con un buon grado di probabilità, un nevo da un potenziale melanoma. 


Per noi è semplice, siamo abituati e predisposti per distinguere, categorizzare, concettualizzare e classificare la maggior parte delle immagini che i nostri occhi vedono, ma per una macchina inferenziale potrebbe essere complesso, l’apprendimento, in questo caso, si basa su degli algoritmi che vanno addestrati su dei “set di immagini”.

 

La difficoltà che potremmo incontrare, nell’operare con un algoritmo di classificazione, potremmo immaginarla come dover decidere se, quello che viene percepito, assomiglia di più ad una categoria, piuttosto che ad un’altra, tanto per rendere l’idea, con una immagine, avvienequalcosa di simile a quello che percepiamo noi guardando questa immagine: 



Forse qualcuno in questa immagine percepisce il volto di una vecchia, ma altri invece potrebbero percepire il volto di una ragazza, vista di profilo, ma tutti riescono a percepire il collo di pelliccia. 

Algoritmi di classificazione, come aiutano la medicina a fare previsioni

Un algoritmo di classificazione è uno strumento software che utilizza tecniche di deep learning per attribuire un attributo di proprietà, basato su un calcolo statistico ad un elemento analizzato, quale ad esempio una immagine. 


Uno dei sistemi per poter fare in modo che una rete neurale impari a classificare delle immagini, in relazione al contenuto, è quello di fornire una certa quantità di esempi, pre-classificati per categorie, ad esempio, a titolo didattico, viene solitamente proposto un esercizio per classificare le lettere dell’alfabeto, scritte in corsivo manualmente, oppure i numeri, da 0 a 9, scritti manualmente. 


Un mio consiglio che posso dare, per approfondire questo specifico esercizio, è quello di seguire le pagine Youtube dedicate da Piero Savastano, proprio su questo argomento: 





Nel nostro caso, per poter distinguere nei o nevi, da melanomi, o potenziali melanomi, bisognerà disporre di un minimo quantitativo di immagini per le due classi di figure. 


Quindi, prima di tutto, si dovranno ricercare e clusterizzare le immagini separandole in due cartelle distinte, il mio suggerimento, in questo caso è fare una cartella denominandola “train_set”, che al suo interno dovrà contenere le due directory, una con le immagini dei melanomi e l’altra con quelle dei nevi. 

 

 

La prima parte delle attività, sarà quella di addestrare il classificatore proprio su queste figure. L’addestramento consiste nel “plasmare un modello neurale”, facendolo ripassare i dati di ogni immagine, per un numero sufficiente di volte, (definite epoche), attraverso una rete costituita da diversi  layer (strati) di neuroni,  che potrà rilevare le caratteristiche distintive di ogni immagine, tali da stabilire un criterio inferenziale tale da stabilire con un certo grado di precisione, la differenza tra le immagini appartenenti all’una o all’altra directory. 


Ad ogni passaggio, verrà eseguita una operazione, definita backpropagation, o retropropagazione dell'errore, atta ad abbassare, di volta in volta, l’errore predittivo, riferito alla classificazione delle immagini, in base statistica. 


Generato il modello, lo si fa “validare”, con un altro set di immagini conosciute, raccolte in un altra cartellina, di test che a sia volta disporrà di due directory più corpose, una per i nei e una per i melanomi. 


Quando il modello itererà su queste immagini, per lui sconosciute, ma simili, per costituzione, alle immagini che ha imparato a classificare, otterrà un errore predittivo, inizialmente randomizzato, ma attraverso la procedura di controllo della funzione di backpropagation, questo errore sarà via via sempre minore, controllato da una “loss function” e, per contro, l’accuratezza (accuracy) predittiva, diverrà via via sempre maggiore. 


Quando si trova un buon compromesso di riconoscimento che sia superiore ad un valore di 

underfitting, ma inferiore di poco ad un valore di overfitting, ovvero superiore ad una sottostima di classificazione, ma inferiore ad una pura memorizzazione dei dati, come rappresentat dalla seguente immagine: 

 


il che significa ottenere un buon grado di accuratezza predittiva, si è in grado di sottoporre il nostro modello al riconoscimento di immagini nuove, e perfettamente incognite, sulle quali si dovrà inferire una classificazione, in questo caso, binaria; o nevo o melanoma. 

 

Una definizione “artificilale di algoritmo classificatore: Questa volta lo chiedo a Bard: 

 

Una definizione per l'algoritmo classificatore di tensorflow 

 

Un classificatore TensorFlow è un algoritmo di machine learning che viene utilizzato per 

identificare o categorizzare entità in base a un insieme di dati. I classificatori TensorFlow sono ampiamente utilizzati in una varietà di applicazioni, tra cui la visione artificiale, l'analisi del linguaggio naturale e il riconoscimento delle sequenze. 


TensorFlow fornisce una vasta gamma di classificatori predefiniti, tra cui: 


DNN (Deep Neural Networks): Le reti neurali profonde sono classificatori potenti ed 

efficaci che possono modellizzare relazioni complesse tra input e output. Sono 

particolarmente adatti per problemi di classificazione multiclasse. 


SVM (Support Vector Machines): Le macchine a vettori di supporto sono classificatori 

efficienti e robusti che possono gestire dati non lineari. Sono particolarmente adatti per 

problemi di classificazione binaria. 


Random Forests: Le foreste casuali sono classificatori ensemble che combinano la 

previsione di diversi alberi decisionali. Sono robusti al rumore nei dati e possono gestire dati 

multidimensionali. 


K-NN (K-Nearest Neighbors): Il K-NN è un classificatore basato sulla distanza che 

classifica un nuovo punto dati in base alla sua vicinanza ai punti dati etichettati nel training 

set. È semplice da implementare ma può essere sensibile al rumore nei dati. 


TensorFlow consente agli utenti di creare classificatori personalizzati combinando diversi tipi di modelli e di definire funzioni di perdita e ottimizzatori personalizzati. 

L'apprendimento automatico supervisionato è una tecnica di machine learning che utilizza un insieme di dati etichettati per addestrare un classificatore. L'insieme di dati etichettato contiene esempi di input e le corrispondenti etichette di output. Il classificatore apprende le relazioni tra input e output durante l'addestramento e utilizza queste informazioni per classificare nuovi punti dati. 


I classificatori TensorFlow sono potenti strumenti per l'analisi dei dati e possono essere utilizzati per risolvere una varietà di problemi. Sono ampiamente utilizzati in applicazioni reali, tra cui: 


Visone artificiale: I classificatori TensorFlow sono utilizzati per identificare e classificare 

oggetti in immagini e video. Ad esempio, possono essere utilizzati per analizzare video di 

sorveglianza, riconoscere volti e identificare oggetti in immagini. 


Analisi del linguaggio naturale: I classificatori TensorFlow sono utilizzati per analizzare 

testi e classificare i contenuti. Ad esempio, possono essere utilizzati per classificare email 

come spam o non spam, analizzare recensioni di prodotti e identificare argomenti di 

conversazione. 


Riconoscimento delle sequenze: I classificatori TensorFlow sono utilizzati per analizzare 

sequenze di dati, come sequenze di DNA o sequenze di tempo. Ad esempio, possono essere utilizzati per identificare modelli genetici, prevedere tendenze del mercato azionario e 

diagnosticare malattie. 

 

 

 

Il software necessario per creare un IA a casa

Le procedure software, per poter mettere in pratica un algoritmo di classificazione, possono essere ottenute con vari linguaggi, ma quello che, a mio parere, è il più indicato per questo tipo di elaborazioni e Python, anche perché supportato da delle librerie di notevole interesse ed utilità, sviluppate da giganti dell’informatica moderna e, cosa da non trascurare, “Open Source”, che considero una filosofia sociale moderna, altamente etica e all’avanguardia, per le potenzialità che implica, in quanto a potenziali sinergie di collaborazione globale. 


A tal proposito, suggerisco la lettura di questo libro, che ho scritto poco tempo fa, e credo molto attuale, viste le inclinazioni politiche che riguardano il futuro delle produzioni software a livello mondiale, soprattutto riferite all’utilizzo dell’intelligenza artificiale. 

  



Questo testo è acquistabile su www.amazon.it


Quindi, il software necessario, in python viene reso disponibile nel programma “classificatore”, per mezzo delle funzioni di importazione. 


Per questo esercizio didattico, è stato utilizzato un file con estensione . ipynb è un file Jupyter Notebook che contiene l'intero contenuto di Notebook creato con la sessione dell'applicazione web Jupyter Notebook. Jupyter Notebook è un'applicazione web interattiva utilizzata per creare e condividere documenti computazionali per l'analisi utilizzando Python. 

In particolare, in questo caso si è utilizzato una libreria: “Scipy”, che è un software open source per matematica, scienza e ingegneria, ovvero, una raccolta di algoritmi matematici e funzioni di convenienza costruite su Numpy, che aggiunge una potenza significativa a Python fornendo all'utente comandi e classi di alto livello per manipolare e visualizzare i dati. 

La base operativa di python, utilizzata in questo caso, per lo sviluppo degli algoritmi di deeplearning è Tensorflow: un framework open source, sviluppato da Google, specificatamente per il riconoscimento dei numeri, degli oggetti e dei simboli in una foto che utilizza delle funzioni di  algebra lineare denominate tensori


Questa immagine, potrebbe dare l’idea di che cosa si tratta: 

 


 I tensori sono usati, ad esempio in geometria differenziale per definire su una varietà differenziabile le nozioni geometriche di distanza, angolo e volume, sembrano fatti apposta per gestire, interpretare, le relazioni tra i pixel colorati delle immagini utilizzate in questi casi. 

In particolare, per Tensorflow, è stata sviluppata Keras che è una interfaccia per l'apprendimento automatico e le reti neurali, scritta in Python, Questa interfaccia pensata per un livello di astrazione superiore ad altre librerie simili di più basso livello, supporta come back-end le librerie TensorFlow  e permettere una rapida prototipazione di reti neurali profonde, caratterizzandosi sulla facilità d'uso, la modularità e l'estensibilità. 


Per le funzionalità grafiche di rappresentazione delle immagini e degli elaborati, si è utilizzata la libreria Matplotlib molto efficacie per la creazione di grafici per il linguaggio di programmazione Python. 


Questo software viene utilizzato per creare una vasta gamma di visualizzazioni statiche, animate e interattive, come grafici di linea, grafici a dispersione, grafici a barre e istogrammi. 

Fornisce una vasta gamma di opzioni di personalizzazione, come stili di linea, stili di marcatore e mappe dei colori, che possono essere utilizzate per creare grafici professionali e pronti per la pubblicazione di alta qualità; oppure all’occorrenza, una serie di funzioni di animazione. 

L’ambiente di sviluppo, in questo caso, è una partizione virtuale gestita da Visual Studio Code: che è un editor di codice sorgente sviluppato da Microsoft per Windows, Linux e macOS. VS code, include il supporto per debugging, un controllo per Git integrato, syntax highlighting, IntelliSense, snippet e refactoring del codice. 



Lo sviluppo del programma: 

inizializzazione per l’installazione di librerie 

#!nvidia-smi # non utilizzata in questo caso 

!python -m pip install scipy 

## -- DEFINIZIONE VARIABILI 

import os 

# dichiariamo la posizione dei nostri file di addestramento e validazione 

base_dir = '../tf/notebooks/data' 

os.getcwd() 

print(os.getcwd()) 

train_dir = os.path.join(base_dir, 'train_set') 

os.listdir(path='./train_set') 

validation_dir = os.path.join(base_dir, 'test_set') 

# punto alle cartelle di melanomi e Nevi per il training 

train_Melanomi_dir = os.path.join(train_dir, 'Melanomi') 

print("train_dir = ", train_dir) 

print(train_Melanomi_dir) 

trainNevi_dir = os.path.join(train_dir, 'Nevi') 

dir_Melanomi = os.listdir(path='./train_set/Melanomi') 

print("directory melanomi", dir_Melanomi[0]) 

dir_Nevi= os.listdir(path='./train_set/Nevi') 

print(dir_Nevi[0]) 

# punto alle cartelle di melanomi e Nevi per la validazione 

validation_melanomi_dir = os.path.join(validation_dir, 'Melanomi') 

print (validation_melanomi_dir) 

validation_nevi_dir = os.path.join(validation_dir, 'Nevi') 

print (validation_melanomi_dir) 

dir__val_melanomi = os.listdir(path = './test_set/Melanomi') 

print(dir__val_melanomi[0]) 

dir__val_nevi = os.listdir(path = './test_set/Nevi') 

print(dir__val_nevi[0]) 

import tensorflow as tf 

from tensorflow import keras 

from keras.models import Sequential 

import scipy 

from keras.preprocessing.image import ImageDataGenerator 

model = tf.keras.models.Sequential([ 

    # poiché Conv2D è il primo strato della rete neurale, dovremmo specificare 

anche la dimensione dell'input 

    tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(150, 150, 

3)), 

    # applichiamo uno strato di aggregazione 2D 

    tf.keras.layers.MaxPooling2D(2,2), 

    # ripetiamo il processo 

    tf.keras.layers.Conv2D(32, (3,3), activation='relu'), 

    tf.keras.layers.MaxPooling2D(2,2), 

    tf.keras.layers.Conv2D(64, (3,3), activation='relu'), 

    tf.keras.layers.MaxPooling2D(2,2), 

    # appiattiamo il risultato per fornirlo allo strato denso per la 

classificazione 

    tf.keras.layers.Flatten(), 

    # e definiamo 512 neuroni per l'elaborazione dell'output processato dagli 

strati precedenti 

    tf.keras.layers.Dense(512, activation='relu'), 

    # un singolo neurone di output. Il risultato sarà 0 se l'immagine è un 

melanoma, 1 se è un nevo 

    tf.keras.layers.Dense(1, activation='sigmoid')   

]) 

model.summary() 

 

model.compile(optimizer="adam", 

              loss='binary_crossentropy', 

              metrics = ['accuracy']) 

model = tf.keras.models.Sequential([ 

    # poiché Conv2D è il primo strato della rete neurale, dovremmo specificare 

anche la dimensione dell'input 

    tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(150, 150, 

3)), 

    # applichiamo uno strato di aggregazione 2D 

    tf.keras.layers.MaxPooling2D(2,2), 

    # e ripetiamo il processo 

    tf.keras.layers.Conv2D(32, (3,3), activation='relu'), 

    tf.keras.layers.MaxPooling2D(2,2), 

    tf.keras.layers.Conv2D(64, (3,3), activation='relu'), 

    tf.keras.layers.MaxPooling2D(2,2), 

    # appiattiamo il risultato per fornirlo allo strato denso per la 

classificazione 

    tf.keras.layers.Flatten(), 

    # e definiamo 512 neuroni per l'elaborazione dell'output processato dagli 

strati precedenti 

    tf.keras.layers.Dense(512, activation='relu'), 

    # un singolo neurone di output. Il risultato sarà 0 se l'immagine è un 

melanoma, 1 se è un nevo 

    tf.keras.layers.Dense(1, activation='sigmoid')   

]) 

from keras.preprocessing.image import ImageDataGenerator 

train_dir ='./train_set' 

validation_dir = './test_set' 

print(train_dir) 

print(validation_dir) 

 

# riscaliamo tutte le nostre immagini con il parametro rescale 

train_datagen = ImageDataGenerator(rescale = 1.0/255) 

test_datagen  = ImageDataGenerator(rescale = 1.0/255) 

 

# utilizziamo flow_from_directory per creare un generatore per il training 

train_generator = train_datagen.flow_from_directory(train_dir, 

                                                    batch_size=20, 

                                                    class_mode='binary', 

                                                    target_size=(150, 150)) 

 

# utilizziamo flow_from_directory per creare un generatore per la validazione 

validation_generator =  test_datagen.flow_from_directory(validation_dir, 

                                                         batch_size=20, 

                                                         class_mode='binary', 

                                                         target_size=(150, 

150)) 

history = model.fit

            train_generator, # passiamo il generatore per il training 

            steps_per_epoch=10, 

            epochs=10, 

            validation_data=validation_generator, # passiamo il generatore per 

la validazione 

            validation_steps=10, 

            verbose=2 

            ) 

import numpy as np 

import random 

from tensorflow.keras.utils import img_to_array,load_img 

# definiamo un nuovo modello custom di Keras che riceve una immagine in input 

# e restituisce le rappresentazioni degli strati del modello precedente 

successive_outputs = [layer.output for layer in model.layers] 

visualization_model = tf.keras.models.Model(inputs=model.input, 

outputs=successive_outputs) 

# prepariamo una immagine a caso dal nostro dataset 

train_melanomi_dir='./train_set/Melanomi' 

train_nevi_dir = './train_set/Nevi' 

melanomi_img_files = [] 

nevi_img_files= [] 

for filename in os.listdir(train_melanomi_dir): 

    c = os.path.join(train_melanomi_dir, filename) 

    melanomi_img_files.append(c) 

    #print(c) 

for filename in os.listdir(train_nevi_dir): 

    d = os.path.join(train_nevi_dir, filename) 

    nevi_img_files.append(d) 

print(train_melanomi_dir) 

file_melanomi = os.listdir(train_melanomi_dir) 

print("melanoma_0", file_melanomi[0]) 

file_nevi = os.listdir(train_nevi_dir) 

print("nevo_0",file_nevi[0]) 

img_path = random.choice(melanomi_img_files + nevi_img_files) 

print ("img_path",img_path) 

img = load_img(img_path, target_size=(150, 150))  # questa è una immagine 

grezza in formato PIL 

x   = img_to_array(img)                           # array numpy con dimensione 

(150, 150, 3) 

x   = x.reshape((1,) + x.shape)                   # array numpy con dimensione  

1, 150, 150, 3) 

print("x", x) 

# normalizziamo i valori dei pixel per 1/255 

x /= 255.0 

# facendo una previsione non facciamo altro che ottenere 

# le rappresentazioni "intermedie" di questa immagine dal modello precedente 

successive_feature_maps = visualization_model.predict(x) 

# normalizziamo i valori dei pixel per 1/255 

x /= 255.0 

# mappiamo gli strati di questo modello con il loro nome 

layer_names = [layer.name for layer in model.layers] 

print("layer_names",layer_names) 

# plottiamo il tutto 

import matplotlib.pyplot as plt 

 

for layer_name, feature_map in zip(layer_names, successive_feature_maps): 

   

  if len(feature_map.shape) == 4: # se è uno strato convoluzionale o di pooling 

    n_features = feature_map.shape[-1]  # numero di feature 

    size       = feature_map.shape[ 1]  # dimensione 

    print("size", size) 

    # creiamo una griglia per visualizzare i dati 

    display_grid = np.zeros((size, size * n_features)) 

    # un po' di post processing per capirci qualcosa 

    for i in range(n_features): 

        np.seterr(invalid='ignore') 

        x  = feature_map[0, :, :, i] 

        x -= x.mean() 

        x /= x.std () 

        x *=  64 

        x += 128 

        x  = np.clip(x, 0, 255).astype('uint8') 

        #print ("questo è x", x) 

        display_grid[:, i  size : (i + 1)  size] = x 

    # mostriamo il grafico 

    scale = 10. / n_features 

    plt.figure( figsize=(scale * n_features, scale) ) 

    plt.title ( layer_name ) 

    print (layer_name) 

    plt.grid  ( False ) 

    plt.imshow( display_grid, aspect='auto', cmap='viridis'

# recuperiamo le metriche che ci interessano da history 

 

acc = history.history['accuracy'] 

print ("accuracy",acc) 

val_acc = history.history['val_accuracy'] 

print ("val_accuracy",val_acc) 

loss = history.history['loss'] 

print ("loss",loss) 

val_loss = history.history['val_loss'] 

print ("val_loss",val_loss) 

 

epochs = range(len(acc)) 

#print ("epochs",epochs) 

# plottiamo la accuracy con matplotlib 

#lt.plot(epochs, acc) 

#plt.plot(epochs, val_acc) 

plt.title('Accuracy in training e validazione') 

#fig = plt.figure() 

#fig, ax = plt.subplots(figsize=(20, 10)) 

#df.plot(x='date', y='GVA', legend=True, color='g', ax=ax) 

plt.figure() 

plt.show() 

# plottiamo la accuracy con matplotlib 

#plt.plot(epochs, val_acc) 

plt.title('Accuracy in training e validazione') 

plt.figure() 

plt.show() 

# plottiamo la loss con matplotlib 

#fig, ax = plt.subplots(figsize=(5, 5)) 

plt.title('Loss in training') 

#plt.plot(figsize=(5, 2.7), layout='constrained') 

plt.plot(epochs, loss, label='loss') 

#plt.plot(epochs, val_loss, label='val loss') 

plt.xlabel('epochs') 

plt.ylabel('data') 

plt.legend() 

#fig = plt.figure() 

#fig, ax = plt.subplots(figsize=(5, 5)) 

 

#df.plot(x='date', y='GVA', legend=True, color='g', ax=axplt.figure() 

plt.show() 

# image test 

import matplotlib.image as img 

#file_melanomi = os.listdir(train_melanomi_dir) 

#print("file_melanomi",file_melanomi) 

 

#image = img.imread("./Nevo_1.png") 

#plt.imshow(image) 

plt.show() 

img = load_img("./incognite/Incognita_05.png", target_size=(150, 150)) 

plt.imshow(img) 

plt.show() 

#PIL.Image.show() 

#img = image.load_img(path, target_size=(150, 150)) # e usiamo load_img per 

scalarla alla dimensione target 

x   = img_to_array(img)                           # array numpy con dimensione 

(150, 150, 3) 

x   = x.reshape((1,) + x.shape) 

# scaliamo i valori 

#x = image.img_to_array(img) 

x /= 255 

#x = np.expand_dims(x, axis=0) 

# appiattiamo l'output 

images = np.vstack([x]) 

#print("images", images) 

# eseguiamo la predizione 

classes = model.predict(images, batch_size=10) 

print(classes[0]) 

#-------------- 

#plt.title('incognita') 

#plt.figure() 

#plt.show() 

if classes[0] > 0.5: 

    print("incongita=" + " è un Neo!") 

else: 

    print("incognita=" + " è un Melanoma!") 

 

 

Spero che questo esercizio di didattica, adibito all’uso potenziale in medicina degli algoritmi di intelligenza artificiale, possa dare modo a qualcuno di trovare una fonte di ispirazione o perlomeno di appagare qualche curiosità. 


Da parte mia, mi rendo disponibile, per eventuali approfondimenti in merito a potenziali usi di questo ed altri algoritmi similari e ne approfitto per augurare a tutti buon Coding

 

Grazie per la lettura. Romeo Ceccato 

1 Comment

Rated 0 out of 5 stars.
No ratings yet

Add a rating
Rated 5 out of 5 stars.

Molto interessante e utile...peccato che non c'è la possibilità di scaricare gli archivi per poterlo provare...

Like
PCR (5).gif
PCR (4).gif
PCR.gif
PCR.gif
PCR.gif
PCR.gif
PCR (5).gif
3.gif
Vediamo se riesci a cliccarmi ! Nascondo una Sorpresa... (2).png

Ciao 

🤗 Articoli consigliati dalla nostra
Intelligenza Artificiale in base ai tuoi interessi

Correlazione Alta

Correlazione Media

Correlazione Bassa

Iscriviti

VUOI DIVENTARE UN MEMBRO DI INTELLIGENZA ARTIFICIALE ITALIA GRATUITAMENTE E TRARNE I SEGUENTI BENEFICI?

Corsi Gratis

più di 150 lezioni online

Dataset Gratis

più di 150o dataset

Ebook Gratis

più di 10 libri da leggere

Editor Gratis

un editor python online

Progetti Gratis

più di 25 progetti python

App Gratis

4 servizi web con I.A.

Unisciti Ora a oltre
1.000.000
di lettori e appassionanti d'I.A.

Tutto ciò che riguarda l'intelligenza Artificiale, in unico posto, in italiano e gratis.

MEGLIO DI COSI' NON SI PUO' FARE

Dopo l'iscrizione riceverai diversi Regali

VUOI SCRIVERE ARTICOLI INSIEME A NOI.

Grazie

bottom of page