Coursera Learner working on a presentation with Coursera logo and
Coursera Learner working on a presentation with Coursera logo and

De ce modèle, on a tendance à déduire que la rechute pure et simple n’est pas appropriée pour les questions d’ordre. La rechute directe n’est pas limitée, et cela fait entrer en ligne de compte la rechute calculée. Leur valeur s’échelonne soigneusement de 0 à 1.

La rechute stratégique de base

(Code source complet : https://github.com/SSaishruthi/LogisticRegression_Vectorized_Implementation/mass/ace/Logistic_Regression.ipynb)

Modèle

Rendement = 0 ou 1

Théorie => Z = WX + B

hθ(x) = sigmoïde (Z)

Dans le cas où “Z” passe à l’illimité, Y(prévu) recevra 1 et si “Z” passe à l’illimité négatif, Y(prévu) recevra 0.

Examen de la théorie

Le rendement de la spéculation est la probabilité évaluée. Celle-ci est utilisée pour déterminer dans quelle mesure la valeur anticipée peut être considérée comme réelle lorsqu’on lui donne une information X. Considérons le modèle ci-dessous,

X = [x0 x1] = [1 adresse IP]

Compte tenu de l’estime x1, supposons que la probabilité évaluée soit de 0,8. Cela signifie qu’il y a 80% de chances qu’un courriel soit un spam.

Scientifiquement, cela peut être composé comme,

Figure 3 : Représentation scientifique

Cela légitime l’appellation de “rechute stratégique”. Les informations sont intégrées dans un modèle de rechute directe, qui est alors suivi d’une capacité calculée anticipant la variable objective de la salle de soins.

Types de rechute stratégique

1. Une double rechute stratégique

La réaction pure et simple n’a que deux résultats potentiels. Modèle : Spam ou pas

2. La rechute stratégique multinomiale

Au moins trois cours sans demande. Modèle : Anticiper quelle alimentation est la plus favorisée (Végétarienne, Non-Végétarienne, Végétarienne)

3. Rechute stratégique ordinale

Au moins trois classes avec demande. Modèle : Classement des films de 1 à 5

Limite de choix

Pour prévoir quelle information sur la classe a sa place, une limite peut être fixée. À la lumière de cette limite, la probabilité évaluée acquise est caractérisée en classes.

State, on the off chance that predicted_value ≥ 0.5, at that point characterize email as spam else as not spam.

La limite de choix peut être directe ou non. Les demandes polynomiales peuvent être étendues pour obtenir une limite de choix ahurissante.

Fonction de coût

Pourquoi les travaux coûteux qui ont été utilisés pour le direct ne peuvent pas être utilisés pour le stratégique ?

La rechute directe utilise l’erreur quadratique moyenne comme capacité de coût. Si elle est utilisée pour une rechute stratégique, il s’agira alors d’une capacité de paramètres (thêta) non augmentée. Les chutes d’inclinaison s’uniront dans le monde entier, du moins si la capacité est arquée.

Explication de la fonction de coût

Fonction de coût simplifiée

Pourquoi cette fonction de coût ?

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

a capacité négative est due au fait que lorsque nous nous entraînons, nous devons augmenter la probabilité en limitant les travaux malheureux. La diminution du coût améliorera la probabilité la plus extrême en s’attendant à ce que des exemples soient tirés d’une dispersion indistinctement libre.

Dérivation de la formule de l’algorithme de descente en gradient

Mise en œuvre de Python

def weightInitialization(n_features) :

    w = np.zeros((1,n_features))

    b = 0

    retour w,b

def sigmoid_activation(résultat) :

    résultat_final = 1/(1+np.exp(-résultat))

    retourner le résultat final

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

    m = X.shape [0]

    #Prévision

    résultat_final = activation_sigmoïde(np.dot(w,X.T)+b)

    Y_T = Y.T

    coût = (-1/m)*(np.sum((Y_T*np.log(résultat_final)) + ((1-Y_T)*(np.log(1-final_result))))

    #

    #Calcul du gradient

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

    db = (1/m)*(np.sum(résultat_final-Y.T))

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

    retour des diplômés, coût

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

    coûts = []

    pour i dans la gamme(no_iterations) :

        #

        grads, cost = model_optimize(w,b,X,Y)

        #

        dw = diplômés [dw].

        db = diplômé [db]].

        #weight update

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

        b = b – (learning_rate * db)

        #

        si (i % 100 == 0) :

            coûts.append(coût)

            #print(“Le coût après l’itération %i est %f” %(i, coût))

    #paramètres finaux

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

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

    Coefficient de retour, gradient, coûts

def predict(final_pred, m) :

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

    pour i dans la gamme(final_pred.shape[1]) :

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

            y_pred[0][i] = 1

    retour y_pred

Coût vs nombre d’opérations

Préparer et tester la précision du cadre est de 100 %.

Cet usage est destiné à la double rechute calculée. Pour les informations comportant plusieurs classes, la rechute softmax doit être utilisée.