ML | Diagnosi del cancro al seno in Wisconsin utilizzando la regressione logistica

| | | |

La regressione logistica viene utilizzata per prevedere se un determinato paziente ha un tumore maligno o benigno in base agli attributi in un determinato set di dati.

Codice: carica librerie

# facendo algebra lineare

import numpy as np


# elaborazione dati

< p> import panda come pd


# rendering

import matplotlib.pyplot as plt

Codice: carica set di dati

data = pd.read_csv ( ".. breast-can cer-wisconsin-data data.csv" )

print (data.head)

Output:

Codice: Carica set di dati

data.info ()

Output:

 RangeIndex : 569 voci, da 0 a 568 colonne di dati (totale 33 colonne): id 569 non-null int64 diagnostic 569 non-null object radius_mean 569 non-null float64 texture_mean 569 non-null float64 perimetro_mean 569 non-null float64 area_mean 569 non-null float64 smoothness_mean 569 non null float6 4 compactness_mean 569 non-null float64 concavity_mean 569 non-nullmean concavity 569 punti non-nullmean 569 non-nullmean conc9 -null float64 symmetry_mean 569 non-null float64 fractal_dimension_mean 569 non-null float64 raggio_se 569 non-null float64 non-null float64 perimetro_se 569 float non nullo64 ​​area_se 569 float non nullo64 ​​smoothness_se 569 float non nullo non compactness-569 float64 concavity_se 569 float non nullo64 ​​punti concavi_se 569 float non nullo64 ​​symmetry_se 569 float non nullo64 ​​fractal_dimension_se 569 float non nullo649 raggio_worst 5 float non nullo64 ​​texture_worst 569 float non nullo64 ​​perimetro_worst 569_ float non nullo64 ​​perimetro_worst 569_ area non null smoothness_worst 569 float non nullo64 ​​compactness_worst 569 float non nullo64 ​​concavity_worst 569 float non nullo64 ​​punti concavi_worst 5 69 float non nullo64 symmetry_worst 569 float64 non nullo fractal_dimension_worst 569 float64 non nullo Senza nome: 32 0 float64 non nullo dtypes: float64 (31), int 64 (1), oggetto (1) utilizzo della memoria: 146,8+ KB 

Codice: stiamo eliminando le colonne — "Id" e "Unnamed: 32" poiché non svolgono alcun ruolo nelle previsioni.

data.drop ([ ’Senza nome: 32’ , ’ id’ ], asse = 1 )

data.diagnosis = [ 1 if ciascuno = = "M" else 0 for ciascuno in data.diagnosis]

Codice: input e output

y = data.diagnosis.values ​​​​

x_data = data.drop ([ ’diagnosis’ ], asse = 1 )

Codice: normalizzazione

x = (x_data - np. min (x_data)) / (np. max (x_data) - np. min (x_data)). valori

Codice: dati separati per l’allenamento e test.

Codice Peso e Grado

from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split (

x, y, test_size = 0.15 , random_state = 42 )

x_train = x_train.T

x_test = x_test.T

y_train = y_train.T

y_test = y_test.T

print ( "x train:" , x_train.shape)

print ( "x test:" , x_test.shape)

print ( " y train: " , y_train.shape)

print ( "y test:" , y_test.shape)

def initialize_weights_and_bias (dimensione):

w = np.full ((dimensione, 1 ), 0,01 )

b < classe codice = "parola chiave"> = 0.0

return w, b

Codice: sigmoidal funzione — calcola il valore z.

# z = np.dot (wT, x_train) + b

def sigmoid (z):

y_head = 1 / ( 1 + np.exp ( - z))

return y_head

Distribuzione avanti e indietro del codice

def forward_backward_propagation (w, b, x_train, y_train):

z = np.dot (wT, x_train) + b

y_head = sigmoid (z )

perdita = - y_train * np.log (y_head) - ( 1 - y_train) * np.log ( 1 - y_head)

# x_train.shape [1] da scalare

costo codice> = ( np. somma (perdita)) / x_train.shape [ 1 ]

< p> # backpropagation

peso_derivato = ( np.dot (x_train, (

(y_head - y_train) .T))) / x_train. shape [ 1 ]

deriva_bias = np. sum (

y_head - y_train) / x_train. shape [ 1 ]

gradienti = { "peso_derivativo" : derivativo_peso,

"derivative_bias" : derivato_bias}

< p> return costo, gradienti

Codice: opzioni di aggiornamento

def aggiornamento (w, b, x_train , y_train, learning_rate, number_of_iterarion):

cost_list = []

cost_list2 = []

index = []

# L’aggiornamento (apprendimento) dei parametri è un numero

per i in intervallo (number_of_iterarion):

# esegue la propagazione avanti e indietro e trova costi e gradienti

costo, gradienti = forward_backward_propagation (w, b, x_train, y_train)

cost_list.append (costo)

# aggiorniamo

w = w - learning_rate * gradienti [ "peso_derivato" ]

b = b - tasso_apprendimento * gradienti [ "derivative_bias" ] < /p>

if i % 10 = = 0 :

cost_list2.append (costo )

index.append (i)

print ( "Costo dopo l’iterazione% i:% f" % (i, costo))

# aggiorna (impara) i parametri dei pesi e delle distorsioni

parametri = { "peso" : w, " bias" : b}

plt.plot (index, cost_list2)

plt.xticks (indice, rotazione = ’verticale’ )

plt.xlabel ( " Numero di iterazioni " )

plt.ylabel ( "Costo" )

plt. mostra ()

return parametri, gradienti, cost_list

Codice: Previsioni

< /p>

def predict (w, b, x_test):

# x_test è un input per la distribuzione diretta

z = si gmoid (np.dot (wT, x_test) + b)

Y_predizione = np.zeros (( 1 , x_test.shape [ 1 ]))

< p> # se z è maggiore di 0,5, la nostra previsione è di segno uno (y_head = 1),

# se z è inferiore a 0,5, la nostra previsione è zero (y_head = 0),

for i in intervallo (z.shape [ 1 ]):

if z [ 0 , io] " = 0.5 :

Y_prediction [ 0 , i ] = 0

else :

Y_prediction [ 0 , i] = 1

return Y_prediction

< p>

Codice: regressione logistica

def logistica_regression (x_train, y_train, x_test, y_test,

learning_rate , num_iterations):

dimensione = x_train.shape [ 0 ]

w, b = initialize_weights_and_bias (dimensione)

parametri, gradienti, cost_list = update (

w, b, x_train, y_train , learning_rate, num_iterations)

y_prediction_test = predict (

parametri [ "peso" ], parametri [ "bias" ], x_test)

y_prediction_train = predict (

arametri [ "peso" ], parametri [ "bias" ], x_train)

Train / test errori

print ( " precisione del treno: {}% " . formato (

100 - np.mean (np. abs (y_prediction_train - y_train)) * < classe codice = "valore"> 100 ))

print ( "accuratezza del test: {}% " . formato (

100 - np.mean (np. abs (y_prediction_test - y_test)) * 100 )) < /p>


regressione_logistica (x_train, y_train, x_test,

y_test, learning_rate = 1 , num_iterazioni = 100 )

Output:

 Costo dopo l’iterazione 0 : 0,692836 Costo dopo l’iterazione 10: 0,498576 Costo dopo l’iterazione 20: 0,404996 Costo dopo l’iterazione 30: 0,350059 Costo dopo l’iterazione 40: 0,313747 Costo dopo l’iterazione ER ITErazione 50: 0,287767 Costo dopo iterazione 60: 0,268114 Costo dopo iterazione 70: 0.252627 Costo dopo iTerat ION 80: 0,240036 Costo dopo iterazione 90: 0,229543 Costo dopo iterazione 100: 0,220624 Costo dopo iterazione 110: 0,212920 Costo dopo iterazione 120: 0.206175 Costo dopo iterazione 130: 0.200201 Costo dopo l’iterazione 140: 0.194860 

Output:

 precisione del treno: 95,23809523809524% accuratezza del test: 94,18604651162791% 

Codice: controlla i risultati con linear_model.LogisticRegression

< td class = "code">

from sklearn import < codice classe = "semplice"> modello_lineare

logreg = linear_model.LogisticRegression (random_state = 42 , max_iter = 150 )

print ( "accuratezza del test: {}" . formato (

logreg.fit ( x_train .T, y_train.T) .score (x_test.T, y_test.T)))

print ( " precisione del treno: {} " . formato (

logreg.fit (x_train.T, y_train.T) .score (x_train.T, y_train .T)))

Output:

 accuratezza del test: 0.9651162790697675 accuratezza del training: 0.9668737060041408