Régression linéaire à l'aide de la méthode de descente de gradient [expliquée avec un exemple de codage]

L'apprentissage automatique fait toujours le tour, que vous aspiriez à devenir développeur de logiciels, scientifique des données ou analyste de données. Pour faire de sérieux efforts en régression linéaire, vous devez bien connaître Python. Commencer une phase initiale peut être une tâche fastidieuse, cet article vous aidera à mieux comprendre la régression.

La méthode de descente de gradient est choisie dans diverses itérations en raison des techniques d'optimisation qu'elle a à offrir. Avec l'algorithme, il est possible de réduire la taille, par exemple, la régression logistique et le réseau de neurones. Avant de commencer avec le gradient, jetons un coup d'œil à la régression linéaire.

Lire : Algorithmes d'apprentissage automatique pour la science des données

Qu'est-ce que la régression linéaire ?

C'est l'approche linéaire qui est adoptée pour la modélisation de la relation entre une variable dépendante et une ou plusieurs variables indépendantes. La relation linéaire entre ces variables serait exprimée sous le format d'équation ay=mx+b.

Il s'agit d'un algorithme d'apprentissage automatique surveillé qui améliorera sa courbe d'apprentissage à partir d'une variable dépendante x donnée et y comme l'autre responsable de l'effet. Cette nature aide à prédire les valeurs et les facteurs de certitude pour x et y.

Qu'est-ce que la descente de gradient ?

L'utilisation de la régression de gradient consiste à optimiser l'algorithme utilisé pour trouver les valeurs des paramètres requis d'une fonction ce qui permet de minimiser directement le coût d'une fonction.

Laissez-nous comprendre le concept avec un scénario, imaginez que vous voulez descendre un fort dans un environnement sombre. Pendant ce temps, supposons que vous êtes complètement handicapé et que vous devez trouver la distance la plus courte et la plus facile pour redescendre. La descente en pente sera la ressource utilisée pour trouver le chemin optimisé pour atteindre votre destination. Avec une entrée directionnelle de base, l'algorithme serait possible de tracer et de suggérer le meilleur itinéraire.

Le gradient est l'un des algorithmes les plus utilisés et les plus largement acceptés dans l'apprentissage automatique. Il est également considéré comme jetant les bases de la maîtrise de l'apprentissage automatique dans les premières étapes.

Pour une meilleure approximation du gradient, essayons de l'implémenter avec un code dans un exemple, en travaillant sur python avec l'aide de NumPy.

de l'importation NumPy *

# y = mx + b

# m est la pente, b est l'ordonnée à l'origine

def compute_error_for_line_given_points(b, m, points):

erreur totale = 0

for i in range(0, len(points)):

x = points[i, 0]

y = points[i, 1]

erreur totale += (y – (m * x + b)) ** 2

retourne erreur totale / float(len(points))

def step_gradient(b_current, m_current, points, learningRate):

b_gradient = 0

m_gradient = 0

N = float(len(points))

for i in range(0, len(points)):

x = points[i, 0]

y = points[i, 1]

b_gradient += -(2/N) * (y – ((m_current * x) + b_current))

m_gradient += -(2/N) * x * (y – ((m_current * x) + b_current))

new_b = b_current – ​​(taux d'apprentissage * b_gradient)

new_m = m_current – ​​(learningRate * m_gradient)

retourner [nouveau_b, nouveau_m]

def gradient_descent_runner(points, Starting_b, Starting_m, Learning_rate, num_iterations):

b = départ_b

m = départ_m

pour je dans la plage (num_itérations):

b, m = step_gradient(b, m, array(points), learning_rate)

retour [b, m]

def run() :

points = genfromtxt("data.csv", delimiter="",")

taux_d'apprentissage = 0,0001

initial_b = 0 # estimation initiale de l'ordonnée à l'origine

initial_m = 0 # estimation de la pente initiale

nombre_itérations = 1000

print "Démarrage de la descente du gradient à b = {0}, m = {1}, erreur = {2}".format(initial_b, initial_m, compute_error_for_line_given_points(initial_b, initial_m, points))

imprimer "En cours d'exécution…"

[b, m] = gradient_descent_runner(points, initial_b, initial_m, learning_rate, num_iterations)

print "Après {0} itérations b = {1}, m = {2}, erreur = {3}".format(num_iterations, b, m, compute_error_for_line_given_points(b, m, points))

si __nom__ == '__main__' :

Cours()

Référence du code

Il s'agit d'une représentation visuelle du programme de recherche de gradient où les problèmes sont résolus dans la régression linéaire en traçant les points sur une seule ligne. Le code est une démonstration de son fonctionnement et aide à définir plusieurs points le long d'une ligne. La descente de gradient tente de trouver les meilleures valeurs pour ces paramètres concernant une fonction d'erreur.

Le code contient une fonction particulière étiquetée 'run'. Il aide à définir un ensemble de paramètres utilisés dans l'algorithme pour faire un ensemble initial de prédictions basées sur le comportement des variables et la pente de la ligne. Les autres facteurs impliquent le nombre d'itérations nécessaires pour obtenir la descente de gradient dans le format indiqué ci-dessous :

initial_b = 0 # estimation initiale de l'ordonnée à l'origine

initial_m = 0 # estimation de la pente initiale

nombre_itérations = 1000

Vous pouvez facilement comprendre que la méthode Gradient est assez simple et directe. Une fois que vous avez compris ses capacités de fonctionnement, la seule partie sur laquelle vous devez vous concentrer est le coût de la fonction que vous souhaitez optimiser.

L'objectif est de faire des efforts continus pour faire différentes itérations pour chacune des valeurs des variables, pour évaluer leurs coûts et pour créer de nouvelles variables qui initieraient un meilleur et un faible coût dans le programme.

Doit lire: Questions d'entretien sur l'apprentissage automatique

Conseils pour la descente en dégradé

1. Taux d'apprentissage

Le protocole d'optimisation permet de réduire la valeur du taux d'apprentissage même à des décimales plus petites, d'essayer de mélanger différentes valeurs adaptées à la plate-forme, puis d'opter pour la meilleure valeur de travail. L'apprentissage peut être beaucoup plus rapide et fructueux, pour ce faire, assurez-vous de limiter le nombre de passages dans chaque ensemble de données. Le nombre idéal serait entre 1 et 10.

2. Tracer le coût moyen

Le temps de formation pour chaque instance d'ensemble de données peut entraîner un retard en raison du temps supplémentaire pris lors de l'exécution de l'algorithme. Pour de meilleurs résultats, choisissez la moyenne sur 100 ou 1000 pour de meilleures chances de trouver une meilleure tendance d'apprentissage pour l'algorithme.

Sommaire

Dans cet article, vous avez appris le gradient et comment créer un tel algorithme, cela aide à faire des prédictions précises et plus efficaces avec un modèle de régression appris. Pour comprendre à un niveau beaucoup plus complet et plus approfondi avec des scénarios de cas réels, inscrivez-vous avec upGrad. Nous proposons des cours organisés spécialement structurés pour les aspirants scientifiques des données et les candidats à l'apprentissage automatique.