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 ?
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.
