Régression linéaire en Python – Real Python

Nous vivons à l’ère des grandes quantités de données, des ordinateurs puissants et de l’intelligence artificielle. Ce n'est que le début. La science des données et l’apprentissage automatique alimentent la reconnaissance de l’image, le développement de véhicules autonomes, les décisions dans les secteurs financier et énergétique, les progrès de la médecine, la montée des réseaux sociaux, etc. La régression linéaire en est une partie importante.

La régression linéaire est l’une des techniques fondamentales de statistique et d’apprentissage automatique. Que vous souhaitiez faire des statistiques, un apprentissage automatique ou un calcul scientifique, il y a de bonnes chances que vous en ayez besoin. Il est conseillé de l’apprendre d’abord, puis de passer à des méthodes plus complexes.

À la fin de cet article, vous aurez appris:

• Qu'est-ce qu'une régression linéaire?
• À quoi sert la régression linéaire
• Comment fonctionne la régression linéaire
• Comment implémenter la régression linéaire en Python, étape par étape

Régression

L’analyse de régression est l’un des domaines les plus importants de la statistique et de l’apprentissage automatique. Il existe de nombreuses méthodes de régression disponibles. La régression linéaire en fait partie.

Qu'est-ce que la régression?

La régression recherche les relations entre les variables.

Par exemple, vous pouvez observer plusieurs employés d’une entreprise et essayer de comprendre en quoi leur salaire dépend du fonctionnalités, tels que l'expérience, le niveau d'éducation, le rôle, la ville dans laquelle ils travaillent, etc.

C’est un problème de régression où les données relatives à chaque employé représentent un observation. On présume que l'expérience, l'éducation, le rôle et la ville sont des caractéristiques indépendantes, tandis que le salaire en dépend.

De même, vous pouvez essayer d'établir une dépendance mathématique des prix des maisons en fonction de leur superficie, du nombre de chambres à coucher, des distances par rapport au centre-ville, etc.

En règle générale, dans l'analyse de régression, vous tenez généralement compte de certains phénomènes intéressants et vous formulez un certain nombre d'observations. Chaque observation a deux caractéristiques ou plus. En supposant que (au moins) l'une des caractéristiques dépend des autres, vous essayez d'établir une relation entre elles.

En d'autres termes, vous devez trouver une fonction qui mappe suffisamment bien certaines caractéristiques ou variables à d'autres.

Les fonctions dépendantes sont appelées le variables dépendantes, les sorties, ou les réponses.

Les caractéristiques indépendantes sont appelées le variables indépendantes, contributions, ou prédicteurs.

Les problèmes de régression ont généralement une variable dépendante continue et non bornée. Toutefois, les entrées peuvent être des données continues, discrètes ou même catégoriques telles que le sexe, la nationalité, la marque, etc.

Il est courant de noter les sorties avec et les entrées avec . S'il existe deux variables indépendantes ou plus, elles peuvent être représentées par le vecteur = (,…, ᵣ), où est le nombre d'entrées.

Quand avez-vous besoin de régression?

En règle générale, vous avez besoin de régression pour déterminer si et comment un phénomène influence l'autre ou comment plusieurs variables sont liées. Par exemple, vous pouvez l’utiliser pour déterminer si et dans quelle mesure l'expérience ou le genre impacte les salaires.

La régression est également utile quand vous voulez prévoir une réponse en utilisant un nouvel ensemble de prédicteurs. Par exemple, vous pouvez essayer de prédire la consommation d'électricité d'un ménage pour la prochaine heure en fonction de la température extérieure, de l'heure du jour et du nombre de résidents de ce ménage.

La régression est utilisée dans de nombreux domaines: économie, informatique, sciences sociales, etc. Son importance augmente chaque jour avec la disponibilité de grandes quantités de données et une prise de conscience accrue de la valeur pratique des données.

Régression linéaire

La régression linéaire est probablement l'une des techniques de régression les plus importantes et les plus largement utilisées. C’est l’une des méthodes de régression les plus simples. L'un de ses principaux avantages est la facilité d'interprétation des résultats.

Formulation du problème

Lors de la mise en œuvre de la régression linéaire d'une variable dépendante sur l'ensemble des variables indépendantes = (,…, ᵣ), où est le nombre de prédicteurs, vous supposez une relation linéaire entre et: = ₀ + ₁₁ + ⋯ + ᵣᵣ + . Cette équation est la équation de régression. , ₁,…, sont les coefficients de régressionet est le erreur aléatoire.

La régression linéaire calcule la estimateurs des coefficients de régression ou simplement la poids prévus, noté, ₁,…,. Ils définissent le fonction de régression estimée () = + ₁₁ + ⋯ + ᵣᵣ. Cette fonction devrait capturer suffisamment les dépendances entre les entrées et les sorties.

le estimé ou réponse prévue, (ᵢ), pour chaque observation = 1,…, , devrait être aussi proche que possible de la valeur correspondante. réponse réelle ᵢ. Les différences ᵢ – (ᵢ) pour toutes les observations = 1,…, sont appelées les résidus. La régression consiste à déterminer la meilleurs poids prévus, c’est-à-dire les poids correspondant aux plus petits résidus.

Pour obtenir les meilleurs poids, vous avez généralement minimiser la somme des résidus au carré (SSR) pour toutes les observations = 1,…, : SSR = (- (ᵢ)) ². Cette approche s'appelle la méthode des moindres carrés ordinaires.

Performance de régression

La variation des réponses réelles ᵢ, = 1,…, est due en partie à la dépendance à l'égard des prédicteurs. Cependant, il existe également une variance inhérente supplémentaire de la sortie.

le coefficient de détermination, noté ², vous indique quelle quantité de variation de peut être expliquée par la dépendance de à l'aide du modèle de régression particulier. Plus grand ² indique un meilleur ajustement et signifie que le modèle peut mieux expliquer la variation de la sortie avec différentes entrées.

La valeur ² = 1 correspond à SSR = 0, c’est-à-dire au ajustement parfait puisque les valeurs des réponses prédites et réelles s’adaptent parfaitement.

Régression linéaire simple

La régression linéaire simple ou à une variable est le cas le plus simple de régression linéaire avec une seule variable indépendante, = .

La figure suivante illustre la régression linéaire simple:

Lors de la mise en œuvre d'une régression linéaire simple, vous commencez généralement par un ensemble donné de paires entrée-sortie (-) (cercles verts). Ces paires sont vos observations. Par exemple, l'observation la plus à gauche (cercle vert) a l'entrée = 5 et la sortie réelle (réponse) = 5. La suivante a = 15 et = 20, etc.

La fonction de régression estimée (ligne noire) a l'équation () = ₀ + ₁. Votre objectif est de calculer les valeurs optimales des poids prédits et qui minimisent le SSR et déterminent la fonction de régression estimée. La valeur de, aussi appelée intercepter, indique le point où la droite de régression estimée coupe l’axe. C’est la valeur de la réponse estimée (for) pour 0 = 0. La valeur de détermine le pente de la droite de régression estimée.

Les réponses prédites (carrés rouges) sont les points de la ligne de régression qui correspondent aux valeurs d'entrée. Par exemple, pour l'entrée = 5, la réponse prévue est (5) = 8,33 (représentée par le carré rouge le plus à gauche).

Les résidus (lignes grises verticales en tirets) peuvent être calculés comme suit: ᵢ – (ᵢ) = – ₀ – ₁ᵢ pour = 1,…, . Ce sont les distances entre les cercles verts et les carrés rouges. Lorsque vous implémentez une régression linéaire, vous essayez réellement de minimiser ces distances et de rendre les carrés rouges aussi proches que possible des cercles verts prédéfinis.

La régression linéaire multiple

La régression linéaire multiple ou multivariée est un cas de régression linéaire avec deux variables indépendantes ou plus.

S'il n'y a que deux variables indépendantes, la fonction de régression estimée est (, ₂) = + ₁₁ + ₂₂. Il représente un plan de régression dans un espace tridimensionnel. Le but de la régression est de déterminer les valeurs des poids, ₁ et ₂ de telle sorte que ce plan soit aussi proche que possible des réponses réelles et donne le SSR minimal.

Le cas de plus de deux variables indépendantes est similaire, mais plus général. La fonction de régression estimée est (₁,…, ᵣ) = + ₁₁ + ⋯ + ᵣᵣ et il y a + 1 pondérations à déterminer lorsque le nombre d'entrées est.

Régression Polynomiale

Vous pouvez considérer la régression polynomiale comme un cas généralisé de régression linéaire. Vous supposez la dépendance polynomiale entre la sortie et les entrées et, par conséquent, la fonction de régression estimée polynomiale.

En d'autres termes, en plus des termes linéaires tels que, votre fonction de régression peut inclure des termes non linéaires tels que ₂₁², ₃₁³ ou même ₄₁₂, ²₂, etc.

L'exemple le plus simple de régression polynomiale a une seule variable indépendante et la fonction de régression estimée est un polynôme de degré 2: () = + ₁ + ₂².

Maintenant, rappelez-vous que vous voulez calculer, ₁ et ₂, ce qui minimise le SSR. Ce sont vos inconnus!

En gardant cela à l'esprit, comparez la fonction de régression précédente avec la fonction (, ₂) = + ₁₁ + ₂₂ utilisée pour la régression linéaire. Elles se ressemblent beaucoup et sont toutes deux des fonctions linéaires des inconnues, ₁ et ₂. C'est pourquoi tu peux résoudre le problème de la régression polynomiale en tant que problème linéaire avec le terme ² considéré comme une variable d’entrée.

Dans le cas de deux variables et du polynôme de degré 2, la fonction de régression a cette forme: (, ₂) = ₀ + ₁₁ + ₂₂ + ₃₁² + ₄₁₂ + ₅₂². La procédure de résolution du problème est identique à celle du cas précédent. Vous appliquez une régression linéaire pour cinq entrées:, ₂, ₁², ₂ et ₂². Ce que vous obtenez comme résultat de la régression sont les valeurs de six poids qui minimisent le SSR:, ₁, ₂, ₃, ₄ et ₅.

Bien sûr, il y a des problèmes plus généraux, mais cela devrait suffire à illustrer ce point.

Insuffisance et surapprentissage

Une question très importante susceptible de se poser lorsque vous appliquez une régression polynomiale est liée à: le choix du degré optimal de la fonction de régression polynomiale.

Il n'y a pas de règle simple pour faire cela. Cela dépend du cas. Vous devez toutefois être conscient de deux problèmes pouvant découler du choix du diplôme: sous-équipage et surapprentissage.

Insuffisant se produit lorsqu'un modèle ne peut pas capturer avec précision les dépendances entre les données, généralement en conséquence de sa propre simplicité. Il produit souvent un ² faible avec des données connues et de mauvaises capacités de généralisation lorsqu'il est appliqué avec de nouvelles données.

Surapprentissage se produit lorsqu'un modèle apprend à la fois les dépendances entre les données et les fluctuations aléatoires. En d'autres termes, un modèle apprend trop bien les données existantes. Les modèles complexes, qui comportent de nombreuses caractéristiques ou termes, sont souvent sujets à la sur-adaptation. Appliqués à des données connues, ces modèles donnent généralement un ²² élevé. Cependant, ils généralisent souvent mal et ont un ²² nettement plus faible lorsqu’ils sont utilisés avec de nouvelles données.

La figure suivante illustre les modèles sous-équipés, bien équipés et sur-équipés:

Le graphique en haut à gauche montre une droite de régression linéaire dont le ² est faible. Il peut également être important qu'une ligne droite ne puisse pas prendre en compte le fait que la réponse réelle augmente lorsque s'éloigne de 25 vers zéro. Ceci est probablement un exemple d'insuffisance.

Le graphique en haut à droite illustre la régression polynomiale avec un degré égal à 2. Dans ce cas, il peut s'agir du degré optimal pour modéliser ces données. Le modèle a une valeur de ² qui est satisfaisante dans de nombreux cas et montre bien les tendances.

Le graphique en bas à gauche présente la régression polynomiale avec un degré égal à 3. La valeur de ² est plus élevée que dans les cas précédents. Ce modèle se comporte mieux avec les données connues que les précédentes. Cependant, il montre des signes de surajustement, en particulier pour les valeurs d’entrée proches de 60 où la ligne commence à diminuer, bien que les données réelles ne le montrent pas.

Enfin, sur le graphique en bas à droite, vous pouvez voir l'ajustement parfait: six points et le polynôme du degré 5 (ou supérieur), rendement ² = 1.
Chaque réponse réelle est égale à sa prédiction correspondante.

Dans certaines situations, cela pourrait être exactement ce que vous recherchez. Dans de nombreux cas, cependant, il s’agit d’un modèle suréquipé. Son comportement est probablement médiocre avec des données invisibles, en particulier avec des entrées supérieures à 50.

Par exemple, il suppose, sans aucune preuve, qu'il y a une baisse significative des réponses pour> 50 et que atteint zéro pour près de 60. Un tel comportement est la conséquence d'un effort excessif pour apprendre et adapter les données existantes.

Il existe de nombreuses ressources où vous pouvez trouver plus d'informations sur la régression en général et la régression linéaire en particulier. La page d’analyse de régression sur Wikipedia, l’article de régression linéaire de Wikipédia, ainsi que l’article de régression linéaire de Khan Academy sont de bons points de départ.

Implémentation de la régression linéaire en Python

Il est temps de commencer à mettre en œuvre la régression linéaire en Python. Fondamentalement, tout ce que vous devez faire est d’appliquer les packages appropriés, leurs fonctions et leurs classes.

Paquets Python pour la régression linéaire

Le paquet NumPy est un package scientifique Python fondamental qui permet de nombreuses opérations hautes performances sur des tableaux à une ou plusieurs dimensions. Il offre également de nombreuses routines mathématiques. Bien sûr, il est open source.

Si vous n’êtes pas familier avec NumPy, vous pouvez utiliser le Guide de l’utilisateur NumPy officiel et lire Look Ma, Pas de boucles for-loop: Programmation de tableaux avec NumPy. De plus, Pure Python vs NumPy vs TensorFlow Performance Comparison peut vous donner une bonne idée des gains de performances que vous pouvez obtenir en appliquant NumPy.

Le paquet scikit-learn est une bibliothèque Python largement utilisée pour l'apprentissage automatique, construite sur NumPy et quelques autres packages. Il fournit les moyens de prétraiter les données, de réduire la dimensionnalité, de mettre en œuvre la régression, la classification, la mise en cluster, etc. Comme NumPy, scikit-learn est également une source ouverte.

Vous pouvez consulter la page Modèles linéaires généralisés sur le site Web scikit-learn pour en savoir plus sur les modèles linéaires et obtenir des informations plus détaillées sur le fonctionnement de ce package.

Si vous souhaitez implémenter la régression linéaire et que vous avez besoin de fonctionnalités dépassant le cadre de scikit-learn, vous devez envisager modèles de statistiques. C’est un puissant progiciel Python pour l’estimation de modèles statistiques, la réalisation de tests, etc. C’est aussi une source ouverte.

Vous pouvez trouver plus d'informations sur modèles de statistiques sur son site officiel.

Régression linéaire simple avec scikit-learn

Commençons par le cas le plus simple, qui est une simple régression linéaire.

La mise en œuvre de la régression linéaire comporte cinq étapes de base:

1. Importez les packages et les classes dont vous avez besoin.
2. Fournissez des données avec lesquelles travailler et éventuellement effectuer les transformations appropriées.
3. Créez un modèle de régression et adaptez-le aux données existantes.
4. Vérifiez les résultats de l'ajustement du modèle pour savoir si le modèle est satisfaisant.
5. Appliquez le modèle aux prévisions.

Ces étapes sont plus ou moins générales pour la plupart des approches et des implémentations de régression.

Étape 1: Importer des packages et des classes

La première étape consiste à importer le package numpy et la classe Régression linéaire de sklearn.linear_model:

importation numpy comme np
de sklearn.linear_model importation Régression linéaire

Vous disposez désormais de toutes les fonctionnalités nécessaires pour mettre en œuvre la régression linéaire.

Le type de données fondamental de NumPy est le type de tableau appelé numpy.ndarray. Le reste de cet article utilise le terme tableau faire référence à des instances du type numpy.ndarray.

La classe sklearn.linear_model.LinearRegression sera utilisé pour effectuer une régression linéaire et polynomiale et faire des prédictions en conséquence.

Étape 2: Fournir des données

La deuxième étape consiste à définir les données avec lesquelles travailler. Les entrées (régresseurs,) et la sortie (prédicteur,) doivent être des tableaux (les instances de la classe numpy.ndarray) ou des objets similaires. C'est le moyen le plus simple de fournir des données pour la régression:

X = np.tableau([[[[5, 15, 25, 35, 45, 55]).remodeler((-1, 1))
y = np.tableau([[[[5, 20, 14, 32, 22, 38])

Maintenant, vous avez deux tableaux: l’entrée X et sortie y. Tu devrais appeler .reshape () sur X parce que ce tableau doit être bidimensionnel, ou pour être plus précis, d'avoir une colonne et autant de lignes que nécessaire. C’est exactement ce que l’argument (-1, 1) de .reshape () spécifie.

C'est ainsi X et y regarde maintenant:

>>> impression(X)
[[ 5]
 [15]
 [25]
 [35]
 [45]
 [55]]
>>> impression(y)
[ 5 20 14 32 22 38]

Comme vous pouvez le voir, X a deux dimensions, et x.shape est (6, 1), tandis que y a une seule dimension, et y.hape est (6).

Étape 3: Créez un modèle et adaptez-le

L'étape suivante consiste à créer un modèle de régression linéaire et à l'ajuster à l'aide des données existantes.

Créons une instance de la classe Régression linéaire, qui représentera le modèle de régression:

modèle = Régression linéaire()

Cette instruction crée la variable modèle comme l'instance de Régression linéaire. Vous pouvez fournir plusieurs paramètres facultatifs pour Régression linéaire:

• fit_intercept est un booléen (Vrai par défaut) qui décide de calculer l'interception ₀ (Vrai) ou le considérer égal à zéro (Faux).
• normaliser est un booléen (Faux par défaut) qui décide de normaliser les variables d'entrée (Vrai) ou pas (Faux).
• copy_X est un booléen (Vrai par défaut) qui décide de copier (Vrai) ou écraser les variables d'entrée (Faux).
• n_emplois est un entier ou Aucun (valeur par défaut) et représente le nombre de travaux utilisés dans le calcul parallèle. Aucun signifie généralement un travail et -1 d'utiliser tous les processeurs.

Cet exemple utilise les valeurs par défaut de tous les paramètres.

Il est temps de commencer à utiliser le modèle. Tout d'abord, vous devez appeler .en forme() sur modèle:

Avec .en forme(), vous calculez les valeurs optimales des poids et ₁ à l’aide des entrées et sorties existantes (X et y) comme arguments. En d'autres termes, .en forme() correspond au modèle. Il retourne soi, qui est la variable modèle lui-même. C’est pourquoi vous pouvez remplacer les deux dernières déclarations par celle-ci:

modèle = Régression linéaire().en forme(X, y)

Cette déclaration fait la même chose que les deux précédentes. C'est juste plus court.

Étape 4: Obtenir des résultats

Une fois que votre modèle est ajusté, vous pouvez obtenir les résultats pour vérifier si le modèle fonctionne de manière satisfaisante et l’interpréter.

Vous pouvez obtenir le coefficient de détermination (²) avec .But() appelé modèle:

>>> r_sq = modèle.But(X, y)
>>> impression('coefficient de détermination:', r_sq)
coefficient de détermination: 0.715875613747954

Quand vous postulez .But(), les arguments sont aussi le prédicteur X et régresseur y, et la valeur de retour est ².

Les attributs de modèle sont .intercepter_, qui représente le coefficient, et .coef_, qui représente ₁:

>>> impression('intercepter:', modèle.intercepter_)
interception: 5.633333333333329
>>> impression('pente:', modèle.coef_)
pente: [0.54]

Le code ci-dessus montre comment obtenir et. Vous pouvez remarquer que .intercepter_ est un scalaire, tandis que .coef_ est un tableau.

La valeur ₀ = 5,63 (environ) indique que votre modèle prédit la réponse 5,63 lorsque est égal à zéro. La valeur ₁ = 0,54 signifie que la réponse prévue augmente de 0,54 lorsque augmente de un.

Vous devriez remarquer que vous pouvez fournir y comme un tableau à deux dimensions ainsi. Dans ce cas, vous obtiendrez un résultat similaire. Voici à quoi cela pourrait ressembler:

>>> nouveau modèle = Régression linéaire().en forme(X, y.remodeler((-1, 1)))
>>> impression('intercepter:', nouveau modèle.intercepter_)
intercepter: [5.63333333]
>>> impression('pente:', nouveau modèle.coef_)
pente:[[[[[0.54]]

Comme vous pouvez le constater, cet exemple est très similaire au précédent, mais dans ce cas, .intercepter_ est un tableau à une dimension avec l'élément unique ₀, et .coef_ est un tableau à deux dimensions avec l'élément unique ₁.

Étape 5: Prédire la réponse

Une fois que le modèle est satisfaisant, vous pouvez l’utiliser pour les prévisions avec des données existantes ou nouvelles.

Pour obtenir la réponse prévue, utilisez .prédire():

>>> y_pred = modèle.prédire(X)
>>> impression('réponse prévue:', y_pred, SEP=' n')
réponse prévue:
[ 8.33333333 13.73333333 19.13333333 24.53333333 29.93333333 35.33333333]

Lors de l'application .prédire(), vous passez le régresseur comme argument et obtenez la réponse prédite correspondante.

C'est une manière presque identique de prédire la réponse:

>>> y_pred = modèle.intercepter_ + modèle.coef_ * X
>>> impression('réponse prévue:', y_pred, SEP=' n')
réponse prévue:
[[ 8.33333333]
 [13.73333333]
 [19.13333333]
 [24.53333333]
 [29.93333333]
 [35.33333333]]

Dans ce cas, vous multipliez chaque élément de X avec model.coef_ et ajouter model.intercept_ au produit.

La sortie ici ne diffère de l'exemple précédent que par ses dimensions. La réponse prévue est maintenant un tableau à deux dimensions, alors que dans le cas précédent, elle avait une dimension.

Si vous réduisez le nombre de dimensions de X à un, ces deux approches donneront le même résultat. Vous pouvez le faire en remplaçant X avec x.reshape (-1), x.flatten (), ou x.ravel () en le multipliant avec model.coef_.

En pratique, les modèles de régression sont souvent appliqués pour les prévisions. Cela signifie que vous pouvez utiliser des modèles ajustés pour calculer les sorties en fonction de nouvelles, nouvelles entrées:

>>> x_nouveau = np.s'organiser(5).remodeler((-1, 1))
>>> impression(x_nouveau)
[[0]
 [1]
 [2]
 [3]
 [4]]
>>> y_nouveau = modèle.prédire(x_nouveau)
>>> impression(y_nouveau)
[5.63333333 6.17333333 6.71333333 7.25333333 7.79333333]

Ici .prédire() est appliqué au nouveau régresseur x_nouveau et donne la réponse y_nouveau. Cet exemple utilise commodément arange () de numpy générer un tableau avec les éléments de 0 (inclus) à 5 (exclusif), c’est-à-dire 0, 1, 2, 3, et 4.

Vous pouvez trouver plus d'informations sur Régression linéaire sur la page de documentation officielle.

Régression linéaire multiple avec scikit-learn

Vous pouvez mettre en œuvre une régression linéaire multiple en suivant les mêmes étapes que pour une régression simple.

Étapes 1 et 2: Importez des packages et des classes et fournissez des données

Tout d'abord, vous importez numpy et sklearn.linear_model.LinearRegression et fournir des entrées et sorties connues:

importation numpy comme np
de sklearn.linear_model importation Régression linéaire

X = [[[[[[[[0, 1], [[[[5, 1], [[[[15, 2], [[[[25, 5], [[[[35, 11], [[[[45, 15], [[[[55, 34], [[[[60, 35]]
y = [[[[4, 5, 20, 14, 32, 22, 38, 43]
X, y = np.tableau(X), np.tableau(y)

C’est un moyen simple de définir l’entrée X et sortie y. Vous pouvez imprimer X et y pour voir à quoi ils ressemblent maintenant:

>>> impression(X)
[[ 0  1]
 [ 5  1]
 [15  2]
 [25  5]
 [35 11]
 [45 15]
 [55 34]
 [60 35]]
>>> impression(y)
[ 4  5 20 14 32 22 38 43]

En régression linéaire multiple, X est un tableau à deux dimensions avec au moins deux colonnes, tandis que y est généralement un tableau à une dimension. Ceci est un exemple simple de régression linéaire multiple, et X a exactement deux colonnes.

Étape 3: Créez un modèle et adaptez-le

L’étape suivante consiste à créer le modèle de régression en tant qu’instance de Régression linéaire et l'ajuster avec .en forme():

modèle = Régression linéaire().en forme(X, y)

Le résultat de cette déclaration est la variable modèle se référant à l'objet de type Régression linéaire. Il représente le modèle de régression équipé des données existantes.

Étape 4: Obtenir des résultats

Vous pouvez obtenir les propriétés du modèle de la même manière que dans le cas d'une régression linéaire simple:

>>> r_sq = modèle.But(X, y)
>>> impression('coefficient de détermination:', r_sq)
coefficient de détermination: 0.8615939258756776
>>> impression('intercepter:', modèle.intercepter_)
interception: 5.52257927519819
>>> impression('pente:', modèle.coef_)
pente: [0.44706965 0.25502548]

Vous obtenez la valeur de ² en utilisant .But() et les valeurs des estimateurs de coefficients de régression avec .intercepter_ et .coef_. Encore, .intercepter_ détient le biais ₀, alors que maintenant .coef_ est un réseau contenant et ₂ respectivement.

Dans cet exemple, l'interception est approximativement de 5,52 et correspond à la valeur de la réponse prévue lorsque ₁ = ₂ = 0. L'augmentation de ₁ de 1 entraîne l'augmentation de la réponse prévue de 0,45. De même, lorsque ₂ augmente de 1, la réponse augmente de 0,26.

Étape 5: Prédire la réponse

Les prévisions fonctionnent également de la même manière que dans le cas de la régression linéaire simple:

>>> y_pred = modèle.prédire(X)
>>> impression('réponse prévue:', y_pred, SEP=' n')
réponse prévue:
[577760476801295312738674971797474792397529728294660957[577760476801295312738674971797474792397529728294660957[577760476801295312738674971797444792397529728294660957[577760476801295312738674971797444792397529728294660957
    38.78227633 41.27265006]

La réponse prédite est obtenue avec .prédire(), qui ressemble beaucoup à ce qui suit:

>>> y_pred = modèle.intercepter_ + np.somme(modèle.coef_ * X, axe=1)
>>> impression('réponse prévue:', y_pred, SEP=' n')
réponse prévue:
[577760476801295312738674971797474792397529728294660957[577760476801295312738674971797474792397529728294660957[577760476801295312738674971797444792397529728294660957[577760476801295312738674971797444792397529728294660957
    38.78227633 41.27265006]

Vous pouvez prédire les valeurs de sortie en multipliant chaque colonne de l'entrée avec la pondération appropriée, en additionnant les résultats et en ajoutant l'interception à la somme.

Vous pouvez également appliquer ce modèle à de nouvelles données:

>>> x_nouveau = np.s'organiser(dix).remodeler((-1, 2))
>>> impression(x_nouveau)
[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
>>> y_nouveau = modèle.prédire(x_nouveau)
>>> impression(y_nouveau)
[ 5.77760476  7.18179502  8.58598528  9.99017554 11.3943658 ]

C’est la prédiction utilisant un modèle de régression linéaire.

Régression polynomiale avec scikit-learn

La mise en œuvre de la régression polynomiale avec scikit-learn est très similaire à la régression linéaire. Il n'y a qu'une seule étape supplémentaire: vous devez transformer le tableau d'entrées pour inclure des termes non linéaires tels que ².

Étape 1: Importer des packages et des classes

En plus de numpy et sklearn.linear_model.LinearRegression, vous devez également importer la classe PolynomialFeatures de sklearn.preprocessing:

importation numpy comme np
de sklearn.linear_model importation Régression linéaire
de sklearn.preprocessing importation PolynomialFeatures

L'importation est maintenant terminée et vous avez tout ce dont vous avez besoin pour travailler.

Étape 2a: Fournir des données

Cette étape définit les entrées et les sorties et est la même que dans le cas de la régression linéaire:

X = np.tableau([[[[5, 15, 25, 35, 45, 55]).remodeler((-1, 1))
y = np.tableau([[[[15, 11, 2, 8, 25, 32])

Vous avez maintenant l’entrée et la sortie dans un format approprié. Gardez à l’esprit que vous avez besoin que l’entrée soit un tableau à deux dimensions. C'est pourquoi .reshape () est utilisé.

Étape 2b: Transformer les données d'entrée

C'est le nouvelle étape vous devez implémenter pour la régression polynomiale!

Comme vous l'avez vu précédemment, vous devez inclure ² (et peut-être d'autres termes) en tant que fonctionnalités supplémentaires lors de la mise en œuvre de la régression polynomiale. Pour cette raison, vous devez transformer le tableau d'entrée X contenir la ou les colonnes supplémentaires avec les valeurs de ² (et éventuellement plus de fonctionnalités).

Il est possible de transformer le tableau d’entrée de plusieurs manières (comme en utilisant insérer() de numpy), mais la classe PolynomialFeatures est très pratique pour cela. Créons une instance de cette classe:

transformateur = PolynomialFeatures(diplôme=2, include_bias=Faux)

La variable transformateur se réfère à une instance de PolynomialFeatures que vous pouvez utiliser pour transformer l'entrée X.

Vous pouvez fournir plusieurs paramètres facultatifs pour PolynomialFeatures:

• diplôme est un entier (2 par défaut) qui représente le degré de la fonction de régression polynomiale.
• interaction_only est un booléen (Faux par défaut) qui décide d’inclure uniquement les fonctionnalités d’interaction (Vrai) ou toutes les fonctionnalités (Faux).
• include_bias est un booléen (Vrai par défaut) qui décide d’inclure ou non la colonne de biais (intercept) de uns (Vrai) ou pas (Faux).

Cet exemple utilise les valeurs par défaut de tous les paramètres, mais vous voudrez parfois expérimenter le degré de la fonction et il peut être intéressant de fournir cet argument de toute façon.

Avant d'appliquer transformateur, vous devez l’adapter avec .en forme():

Une fois que transformateur est installé, il est prêt à créer une nouvelle entrée modifiée. Vous appliquez .transformer() pour faire ça:

X_ = transformateur.transformer(X)

C’est la transformation du tableau d’entrée avec .transformer(). Il prend le tableau d'entrée comme argument et retourne le tableau modifié.

Vous pouvez aussi utiliser .fit_transform () pour remplacer les trois déclarations précédentes par une seule:

X_ = PolynomialFeatures(diplôme=2, include_bias=Faux).fit_transform(X)

Cela correspond et transforme le tableau d’entrée en une seule instruction avec .fit_transform (). Il prend également le tableau d'entrée et fait effectivement la même chose que .en forme() et .transformer() appelé dans cet ordre. Il retourne également le tableau modifié. Voici à quoi ressemble le nouveau tableau d'entrée:

>>> impression(X_)
[[   5.   25.]
 [  15.  225.]
 [  25.  625.]
 [  35. 1225.]
 [  45. 2025.]
 [  55. 3025.]]

Le tableau d'entrées modifié contient deux colonnes: l'une avec les entrées d'origine et l'autre avec leurs carrés.

Vous pouvez trouver plus d'informations sur PolynomialFeatures sur la page de documentation officielle.

Étape 3: Créez un modèle et adaptez-le

Cette étape est également la même que dans le cas de la régression linéaire. Vous créez et adaptez le modèle:

modèle = Régression linéaire().en forme(X_, y)

Le modèle de régression est maintenant créé et ajusté. Il est prêt à être appliqué.

Vous devez garder à l’esprit que le premier argument de .en forme() est le tableau d'entrée modifié X_ et pas l'original X.

Étape 4: Obtenir des résultats

Vous pouvez obtenir les propriétés du modèle de la même manière que dans le cas de la régression linéaire:

>>> r_sq = modèle.But(X_, y)
>>> impression('coefficient de détermination:', r_sq)
coefficient de détermination: 0.8908516262498564
>>> impression('intercepter:', modèle.intercepter_)
interception: 21.372321428571425
>>> impression('coefficients:', modèle.coef_)
coefficients: [-1.32357143  0.02839286]

Encore, .But() renvoie ². Son premier argument est aussi l'entrée modifiée X_, ne pas X. Les valeurs des poids sont associées à .intercepter_ et .coef_: .intercepter_ représente, tandis que .coef_ fait référence au tableau qui contient et ₂ respectivement.

Vous pouvez obtenir un résultat très similaire avec différents arguments de transformation et de régression:

X_ = PolynomialFeatures(diplôme=2, include_bias=Vrai).fit_transform(X)

Si vous appelez PolynomialFeatures avec le paramètre par défaut include_bias = True (ou si vous l'omettez simplement), vous obtiendrez le nouveau tableau d'entrée X_ avec la colonne supplémentaire la plus à gauche contenant seulement les uns. Cette colonne correspond à l'interception. Voici à quoi ressemble le tableau d’entrée modifié:

>>> impression(X_)
[[1.000e+00 5.000e+00 2.500e+01]
 [1.000e+00 1.500e+01 2.250e+02]
 [1.000e+00 2.500e+01 6.250e+02]
 [1.000e+00 3.500e+01 1.225e+03]
 [1.000e+00 4.500e+01 2.025e+03]
 [1.000e+00 5.500e+01 3.025e+03]]

La première colonne de X_ contient les uns, le second a les valeurs de X, tandis que le troisième tient les carrés de X.

L'interception est déjà incluse dans la colonne la plus à gauche et vous n'avez pas besoin de l'inclure à nouveau lors de la création de l'instance de Régression linéaire. Ainsi, vous pouvez fournir fit_intercept = False. Voici à quoi ressemble la prochaine déclaration:

modèle = Régression linéaire(fit_intercept=Faux).en forme(X_, y)

La variable modèle correspond à nouveau au nouveau tableau d'entrée X_. Donc X_ devrait être passé comme premier argument au lieu de X.

Cette approche donne les résultats suivants, similaires au cas précédent:

>>> r_sq = modèle.But(X_, y)
>>> impression('coefficient de détermination:', r_sq)
coefficient de détermination: 0.8908516262498565
>>> impression('intercepter:', modèle.intercepter_)
interception: 0.0
>>> impression('coefficients:', modèle.coef_)
coefficients: [21.37232143 -1.32357143  0.02839286]

Tu vois ça maintenant .intercepter_ est zéro, mais .coef_ contient en fait ₀ comme premier élément. Tout le reste est identique.

Étape 5: Prédire la réponse

Si vous voulez obtenir la réponse prévue, utilisez simplement .prédire(), mais rappelez-vous que l'argument doit être l'entrée modifiée X_ au lieu de l'ancien X:

>>> y_pred = modèle.prédire(X_)
>>> impression('réponse prévue:', y_pred, SEP=' n')
réponse prévue:
[15.46428571  7.90714286  6.02857143  9.82857143 19.30714286 34.46428571]

Comme vous pouvez le constater, la prédiction fonctionne presque de la même manière que dans le cas de la régression linéaire. Cela nécessite simplement l'entrée modifiée au lieu de l'original.

Vous pouvez appliquer la même procédure si vous avez plusieurs variables d'entrée. Vous aurez un tableau d’entrée avec plus d’une colonne, mais tout le reste est identique. Voici un exemple:

# Étape 1: Importer des packages
importation numpy comme np
de sklearn.linear_model importation LinearRegression
de sklearn.preprocessing importation PolynomialFeatures

# Step 2a: Provide data
X = [[[[[[[[0, 1], [[[[5, 1], [[[[15, 2], [[[[25, 5], [[[[35, 11], [[[[45, 15], [[[[55, 34], [[[[60, 35]]
y = [[[[4, 5, 20, 14, 32, 22, 38, 43]
X, y = np.tableau(X), np.tableau(y)

# Step 2b: Transform input data
x_ = PolynomialFeatures(diplôme=2, include_bias=False).fit_transform(X)

# Step 3: Create a model and fit it
modèle = LinearRegression().en forme(x_, y)

# Step 4: Get results
r_sq = modèle.But(x_, y)
intercepter, les coefficients = modèle.intercept_, modèle.coef_

# Step 5: Predict
y_pred = modèle.prédire(x_)

This regression example yields the following results and predictions:

>>> impression('coefficient of determination:', r_sq)
coefficient of determination: 0.9453701449127822
>>> impression('intercept:', intercepter)
intercept: 0.8430556452395734
>>> impression('coefficients:', les coefficients, sep='n')
coefficients:
[ 2.44828275  0.16160353 -0.15259677  0.47928683 -0.4641851 ]
>>> impression('predicted response:', y_pred, sep='n')
predicted response:
[05404740811363402831607809622157913929738586192350834636[05404740811363402831607809622157913929738586192350834636[05404740811363402831607809622157913929738586192350834636[05404740811363402831607809622157913929738586192350834636
    39.05631386 41.92339046]

In this case, there are six regression coefficients (including the intercept), as shown in the estimated regression function (₁, ₂) = ₀ + ₁₁ + ₂₂ + ₃₁² + ₄₁₂ + ₅₂².

You can also notice that polynomial regression yielded a higher coefficient of determination than multiple linear regression for the same problem. At first, you could think that obtaining such a large ² is an excellent result. It might be.

However, in real-world situations, having a complex model and ² very close to 1 might also be a sign of overfitting. To check the performance of a model, you should test it with new data, that is with observations not used to fit (train) the model.

Advanced Linear Regression With statsmodels

You can implement linear regression in Python relatively easily by using the package statsmodels as well. Typically, this is desirable when there is a need for more detailed results.

The procedure is similar to that of scikit-learn.

Step 1: Import packages

First you need to do some imports. En plus de numpy, you need to import statsmodels.api:

importation numpy comme np
importation statsmodels.api comme sm

Now you have the packages you need.

Step 2: Provide data and transform inputs

You can provide the inputs and outputs the same way as you did when you were using scikit-learn:

X = [[[[[[[[0, 1], [[[[5, 1], [[[[15, 2], [[[[25, 5], [[[[35, 11], [[[[45, 15], [[[[55, 34], [[[[60, 35]]
y = [[[[4, 5, 20, 14, 32, 22, 38, 43]
X, y = np.tableau(X), np.tableau(y)

The input and output arrays are created, but the job is not done yet.

You need to add the column of ones to the inputs if you want statsmodels to calculate the intercept ₀. It doesn’t takes ₀ into account by default. This is just one function call:

That’s how you add the column of ones to X avec add_constant(). It takes the input array X as an argument and returns a new array with the column of ones inserted at the beginning. This is how X et y look now:

>>> impression(X)
[[ 1.  0.  1.]
 [ 1.  5.  1.]
 [ 1. 15.  2.]
 [ 1. 25.  5.]
 [ 1. 35. 11.]
 [ 1. 45. 15.]
 [ 1. 55. 34.]
 [ 1. 60. 35.]]
>>> impression(y)
[ 4  5 20 14 32 22 38 43]

You can see that the modified X has three columns: the first column of ones (corresponding to ₀ and replacing the intercept) as well as two columns of the original features.

Step 3: Create a model and fit it

The regression model based on ordinary least squares is an instance of the class statsmodels.regression.linear_model.OLS. This is how you can obtain one:

You should be careful here! Please, notice that the first argument is the output, followed with the input. There are several more optional parameters.

To find more information about this class, please visit the official documentation page.

Once your model is created, you can apply .fit() on it:

By calling .fit(), you obtain the variable résultats, which is an instance of the class statsmodels.regression.linear_model.RegressionResultsWrapper. This object holds a lot of information about the regression model.

Step 4: Get results

The variable résultats refers to the object that contains detailed information about the results of linear regression. Explaining them is far beyond the scope of this article, but you’ll learn here how to extract them.

You can call .summary() to get the table with the results of linear regression:

>>> impression(résultats.résumé())
OLS Regression Results                            
==============================================================================
Dep. Variable:                      y   R-squared:                       0.862
Model:                            OLS   Adj. R-squared:                  0.806
Method:                 Least Squares   F-statistic:                     15.56
Date:                Sun, 17 Feb 2019   Prob (F-statistic):            0.00713
Time:                        19:15:07   Log-Likelihood:                -24.316
No. Observations:                   8   AIC:                             54.63
Df Residuals:                       5   BIC:                             54.87
Df Model:                           2                                         
Covariance Type:            nonrobust                                         
==============================================================================
coef    std err          t      P>|t|      [0.025      0.975]
------------------------------------------------------------------------------
const          5.5226      4.431      1.246      0.268      -5.867      16.912
x1             0.4471      0.285      1.567      0.178      -0.286       1.180
x2             0.2550      0.453      0.563      0.598      -0.910       1.420
==============================================================================
Omnibus:                        0.561   Durbin-Watson:                   3.268
Prob(Omnibus):                  0.755   Jarque-Bera (JB):                0.534
Skew:                           0.380   Prob(JB):                        0.766
Kurtosis:                       1.987   Cond. No.                         80.1
==============================================================================

Warnings:
[1]    Standard Errors assume that the covariance matrix of the errors is correctly specified.

This table is very comprehensive. You can find many statistical values associated with linear regression including ², ₀, ₁, and ₂.

In this particular case, you might obtain the warning related to kurtosistest. This is due to the small number of observations provided.

You can extract any of the values from the table above. Here’s an example:

>>> impression('coefficient of determination:', résultats.rsquared)
coefficient of determination: 0.8615939258756777
>>> impression('adjusted coefficient of determination:', résultats.rsquared_adj)
adjusted coefficient of determination: 0.8062314962259488
>>> impression('regression coefficients:', résultats.params)
regression coefficients: [5.52257928 0.44706965 0.25502548]

That’s how you obtain some of the results of linear regression:

1. .rsquared holds ².
2. .rsquared_adj represents adjusted ² (² corrected according to the number of input features).
3. .params refers the array with ₀, ₁, and ₂ respectively.

You can also notice that these results are identical to those obtained with scikit-learn for the same problem.

To find more information about the results of linear regression, please visit the official documentation page.

Step 5: Predict response

You can obtain the predicted response on the input values used for creating the model using .fittedvalues ou .predict() with the input array as the argument:

>>> impression('predicted response:', résultats.fittedvalues, sep='n')
predicted response:
[577760476801295312738674971797444792397529728294660957[577760476801295312738674971797444792397529728294660957[577760476801295312738674971797444792397529728294660957[577760476801295312738674971797444792397529728294660957
    38.78227633 41.27265006]
>>> impression('predicted response:', résultats.prédire(X), sep='n')
predicted response:
[577760476801295312738674971797444792397529728294660957[577760476801295312738674971797444792397529728294660957[577760476801295312738674971797444792397529728294660957[577760476801295312738674971797444792397529728294660957
    38.78227633 41.27265006]

This is the predicted response for known inputs. If you want predictions with new regressors, you can also apply .predict() with new data as the argument:

>>> x_new = sm.add_constant(np.arange(dix).remodeler((-1, 2)))
>>> impression(x_new)
[[1. 0. 1.]
 [1. 2. 3.]
 [1. 4. 5.]
 [1. 6. 7.]
 [1. 8. 9.]]
>>> y_new = résultats.prédire(x_new)
>>> impression(y_new)
[ 5.77760476  7.18179502  8.58598528  9.99017554 11.3943658 ]

You can notice that the predicted results are the same as those obtained with scikit-learn for the same problem.

Beyond Linear Regression

Linear regression is sometimes not appropriate, especially for non-linear models of high complexity.

Fortunately, there are other regression techniques suitable for the cases where linear regression doesn’t work well. Some of them are support vector machines, decision trees, random forest, and neural networks.

There are numerous Python libraries for regression using these techniques. Most of them are free and open-source. That’s one of the reasons why Python is among the main programming languages for machine learning.

The package scikit-learn provides the means for using other regression techniques in a very similar way to what you’ve seen. It contains the classes for support vector machines, decision trees, random forest, and more, with the methods .fit(), .predict(), .score() and so on.

Conclusion

You now know what linear regression is and how you can implement it with Python and three open-source packages: NumPy, scikit-learn, and statsmodels.

You use NumPy for handling arrays.

Linear regression is implemented with the following:

• scikit-learn if you don’t need detailed results and want to use the approach consistent with other regression techniques
• statsmodels if you need the advanced statistical parameters of a model

Both approaches are worth learning how to use and exploring further. The links in this article can be very useful for that.

When performing linear regression in Python, you can follow these steps:

1. Import the packages and classes you need
2. Provide data to work with and eventually do appropriate transformations
3. Create a regression model and fit it with existing data
4. Check the results of model fitting to know whether the model is satisfactory
5. Apply the model for predictions

If you have questions or comments, please put them in the comment section below.