Da questo modello si tende a dedurre che la ricaduta diretta non è appropriata per problemi di ordine. La ricaduta diretta è senza limiti, e questo porta la ricaduta calcolata nel quadro. Il loro valore va attentamente da 0 a 1.

Rilancio strategico di base

(Codice sorgente completo: https://github.com/SSaishruthi/LogisticRegression_Vectorized_Implementation/mass/ace/Logistic_Regression.ipynb)

Modello

Rendimento = 0 o 1

Teoria => Z = WX + B

hθ(x) = sigmoide (Z)

Nella remota possibilità che ‘Z’ vada a illimitato, Y (previsto) otterrà 1 e se ‘Z’ va a negativo illimitato, Y (previsto) otterrà 0.

Esame della teoria

Il risultato della speculazione è la probabilità valutata. Questo viene utilizzato per raccogliere quanto può essere sicuro che il valore anticipato possa essere reale quando viene data un’informazione X. Considerate il modello sottostante,

X = [x0 x1] = [1 indirizzo IP

Alla luce della stima x1, supponiamo di avere la probabilità valutata di essere 0,8. Questo indica che c’è l’80% di possibilità che un’e-mail sia spam.

Scientificamente questo può essere composto come,

Figura 3: Rappresentazione scientifica

Questo legittima il nome di “ricaduta strategica”. Le informazioni si inseriscono nel modello di ricaduta diretta, che a quel punto è seguito da una capacità calcolata che anticipa la variabile obiettivo del reparto chiaro.

Tipi di rilancio strategico

1. 1. Una duplice ricaduta strategica

La reazione vera e propria ha solo due potenziali risultati. Modello: Spam o no

2. 2. Rivoluzione strategica multinazionale

Almeno tre classi senza richiedere. Modello: Anticipare quale nutrimento è più favorito (Veg, Non-Veg, Vegetariano)

3. 3. Riassetto strategico ordinario

Almeno tre classi con richiesta. Modello: Valutazione del film da 1 a 5

Limite di scelta

Per prevedere quali informazioni di classe hanno un posto, è possibile impostare un limite. Alla luce di questo limite, la probabilità valutata acquisita è caratterizzata in classi.

Dichiarare, nella remota possibilità che il valore_previsto ≥ 0,5, a quel punto caratterizzare l’email come spam altrimenti come non spam.

Il limite di scelta può essere diretto o non diritto. Le richieste polinomiali possono essere ampliate per ottenere un limite di scelta sbalorditivo.

Funzione di costo

Perché il lavoro a costi che è stato utilizzato per la diretta non può essere utilizzato per la strategia?

La ricaduta diritta utilizza l’errore medio al quadrato come capacità di costo. Nel caso in cui questa venga utilizzata per una ricaduta strategica, a quel punto sarà una capacità non elevata di parametri (theta). I crolli di inclinazione si uniranno in tutto il mondo almeno solo se la capacità è arcuata.

Spiegazione della funzione di costo

Funzione di costo semplificata

Perché questa funzione di costo?

ttps://miro.medium.com/max/1516/1*heGae4aZ-dN-rLsfx2-P9g.jpeg
ttps://miro.medium.com/max/2304/1*JIpaau-jFfvX2yR9L1YZ6A.jpeg
ttps://miro.medium.com/max/736/1*ueEwU1dE0Yu-KpMJanf9AQ.png

La sua capacità negativa è dovuta al fatto che quando ci alleniamo, dobbiamo aumentare le probabilità limitando il lavoro di sfortuna. Diminuire il costo migliorerà la probabilità più estrema aspettandosi che gli esempi siano tratti da una dispersione indistintamente libera.

Derivare la formula dell’algoritmo di discesa graduale

Implementazione del Pitone

Def weightInizializzazione(n_caratteristiche):

    w = np.zeri((1,n_caratteristiche))

    b = 0

    ritorno w,b

def sigmoid_activation(result):

    risultato_finale = 1/(1+np.exp(-risultato))

    restituire il risultato finale

def model_optimize(w, b, X, Y):

    m = forma X.shape[0]

    #Prediction

    risultato_finale = attivazione_sigmoide(np.dot(w,X.T)+b)

    Y_T = Y.T

    costo = (-1/m)*(np.sum((Y_T*np.log(risultato_finale)) + ((1-Y_T)*(np.log(1-final_risultato finale)))))

    #

    #Calcolo della pendenza

    dw = (1/m)*(np.dot(X.T, (final_result-Y.T).T))

    db = (1/m)*(np.sum(final_result-Y.T))

    grads = {“dw”: dw, “db”: db}

    Gradi di ritorno, costo

def model_predict(w, b, X, Y, learning_rate, no_iterations):

    costi = []

    per i in range(no_iterazioni):

        #

        gradazioni, costo = modello_ottimizzare(w,b,X,Y)

        #

        dw = grads[“dw”]

        db = grads[“db”]

        #aggiornamento del peso

        w = w – (learning_rate * (dw.T))

        b = b – (learning_rate * db)

        #

        se (i % 100 == 0):

            costi.appendice(costo)

            #print(“Costo dopo %i iterazione è %f” %(i, costo))

    #parametri finali

    coeff = {“w”: w, “b”: b}

    gradiente = {“dw”: dw, “db”: db}

    ritorno coeff, pendenza, costi

def predict(final_pred, m):

    y_pred = np.zeri((1,m))

    per i in range(final_pred.shape.pred[1]):

        se final_pred[0][i] > 0,5:

            y_pred[0][i] = 1

    restituire y_pred

Costo vs Numero_di_Iterazioni

Preparare e testare la precisione della struttura è del 100 %.

Questo utilizzo è per una doppia ricaduta calcolata. Per informazioni con classi multiple, si deve utilizzare la ricaduta softmax.