Exercice 1 : Régression linéaire

Exercice 1 : Régression linéaire

---

introduire

Dans cet exercice, vous allez implémenter la régression linéaire et voir comment cela fonctionne sur vos données.

Avant de commencer l'exercice, vous devez télécharger les fichiers suivants pour le téléchargement des données :

• ex1data1.txt - Ensemble de données de régression linéaire univariée
• ex1data2.txt - Ensemble de données de régression linéaire multivariée

Tout au long de l'exercice, les devoirs obligatoires et les devoirs* optionnels notés suivants sont concernés :

• Implémenter un exemple de fonction simple ---------- (5 points)
• Réaliser la fonction d'affichage de l'ensemble de données ------- (5 points)
• Fonction pour calculer le coût de la régression linéaire ----- (40 points)
• La fonction fonctionnelle de la descente en pente ----- (50 points)
• Normalisation des données*
• Implémentation de la fonction de descente de gradient pour la régression linéaire multivariée*

Le devoir obligatoire est d'implémenter la régression linéaire univariée ; le devoir facultatif est d'implémenter la régression linéaire multivariée.

1 Implémenter un exemple de fonction simple

Dans cette partie de l'exercice, vous implémenterez le code pour renvoyer une 5*5matrice diagonale de . La sortie est la même que :

1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

1.1 Soumettre une solution

Effectuez l'implémentation ci-dessus dans la zone de code suivante. Après avoir terminé quelques exercices, si vous obtenez le même résultat que ci-dessus, c'est une réussite.

###在这里填入代码###
import numpy as np
print(np.eye(5))

[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]

2 Régression linéaire univariée

Dans cette partie de l'exercice, la régression linéaire univariée sera mise en œuvre et utilisée pour prédire le profit d'un food truck.

Supposons que vous soyez à la tête d'un restaurant et que vous envisagez d'ouvrir de nouveaux établissements dans différentes villes. La chaîne a déjà des food trucks dans différentes villes, et vous obtenez des données sur la population et les bénéfices pour chaque ville.

Vous devez maintenant utiliser ces données pour vous aider à choisir la prochaine ville à développer.

Le fichier ex1data1.txtcontient l'ensemble de données pour le problème de régression linéaire. La première colonne de données correspond à la population de la ville, et la deuxième colonne de données correspond au profit des food trucks de cette ville. Un profit négatif indique une perte.

2.1 Tracé des données

Il est souvent utile de visualiser les données avant de se lancer dans les exercices. Pour cet ensemble de données, un nuage de points peut être utilisé pour la visualisation car il n'a que deux attributs (population, profit).

# 引入所需要的库文件
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os

%matplotlib inline

# 数据存储路径
path = '/home/jovyan/work/ex1data1.txt'

# 读入相应的数据文件
data = pd.read_csv(path, header=None,names=['Population','Profit'])

#查看数据的前五条
data.head(5)

	Population	Profit
0	6.1101	17.5920
1	5.5277	9.1302
2	8.5186	13.6620
3	7.0032	11.8540
4	5.8598	6.8233

Ensuite, le code de visualisation des données est nécessaire et l'image dessinée par cette partie des données doit être la même que celle qui suit.

Points principaux:

• Réaliser la visualisation du nuage de points
• Les données sont distribuées sous forme de points rouges
• Nom des coordonnées horizontales et verticales SD

###在这里填入代码###
data.plot(kind='scatter', x='Population',y='Profit',c='red',figsize=(12,8))
plt.show()

2.2 Descente en gradient

Dans cette section, la descente de gradient sera utilisée pour sélectionner les paramètres de régression linéaire appropriés θ pour s'adapter à un ensemble de données donné.

2.2.1 Mettre à jour la formule

Le but de la régression linéaire est de minimiser une fonction de coût :

Réglage $h_{}\left(X\right)$ est donnée par le modèle linéaire suivant :

Pour rappel, les paramètres du modèle sont ${je}_{}$valeurs de , celles-ci seront ajustées pour minimiser le coût $J\left(\theta \right)$。

L'une de ces méthodes consiste à utiliser l'algorithme de descente de gradient par lots. Dans la descente de gradient par lots, la mise à jour est effectuée à chaque itération. Au fur et à mesure que chaque étape de la descente de gradient est calculée, le paramètre θ j \ ${je}_{}$Se rapproche de plus en plus du coût $J\left(\theta \right)$ atteint la valeur optimale la plus basse.

(Mettre à jour simultanément tous ${je}_{}$）

2.2.2 Mise en œuvre

Dans la partie précédente de l'exercice, nous avons chargé les données requises dans des variables dataet nommé leurs colonnes séparément.

Ensuite, nous avons ajouté une dimension aux données pour ajuster le terme d'interception ${je}_{}$. Et définissez la valeur initiale du paramètre sur 0, le taux d'apprentissage $\alpha$ est fixé à 0,01.

#在列索引为0处添加数据列，该列值均为1
data.insert(0, 'Ones', 1)

#获取数据列数
cols = data.shape[1]

#对变量X和y进行初始化,并将其数据类型转换为矩阵
X = data.iloc[:,0:cols-1]
y = data.iloc[:,cols-1:cols]
X = np.matrix(X.values)
y = np.matrix(y.values)

#学习率、迭代次数的初始化
alpha = 0.01
iterations = 1500

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-10-ba7d5fe01814> in <module>
      1 #在列索引为0处添加数据列，该列值均为1
----> 2 data.insert(0, 'Ones', 1)
      3 
      4 #获取数据列数
      5 cols = data.shape[1]


/opt/conda/lib/python3.6/site-packages/pandas/core/frame.py in insert(self, loc, column, value, allow_duplicates)
   3220         value = self._sanitize_column(column, value, broadcast=False)
   3221         self._data.insert(loc, column, value,
-> 3222                           allow_duplicates=allow_duplicates)
   3223 
   3224     def assign(self, **kwargs):


/opt/conda/lib/python3.6/site-packages/pandas/core/internals.py in insert(self, loc, item, value, allow_duplicates)
   4336         if not allow_duplicates and item in self.items:
   4337             # Should this be a different kind of error??
-> 4338             raise ValueError('cannot insert {}, already exists'.format(item))
   4339 
   4340         if not isinstance(loc, int):


ValueError: cannot insert Ones, already exists

2.2.3 Coût de calcul J(θ)

Tout en effectuant une descente de gradient pour minimiser la fonction de coût $Lorsque\; J\left(\theta \right)$ , il est utile de surveiller l'état de convergence en calculant le coût.

Dans cette partie de l'exercice, vous devez implémenter un coût de calcul J ( θ ) J(\theta)Fonction de$J$$($$\theta$$)$computeCost pour vérifier la convergence de l'implémentation de descente de gradient.

où Xet yne sont pas des valeurs scalaires mais des matrices dont les lignes représentent des exemples dans l'ensemble d'apprentissage.

Important :
Après avoir terminé la fonction, définissez $La\; valeur\; \theta$ est initialisée à 0 et le coût est calculé, et la valeur de coût obtenue est imprimée.

Si le résultat est 32,07, le calcul réussit.

###在这里填入代码###
# 代价函数
def computeCost(X,y,w):
    inner = np.power(((X * w) - y),2)
    return np.sum(inner) / (2 * len(X))

theta = np.matrix(np.zeros((2,1)))

computeCost(X,y,theta)

32.072733877455676

2.2.4 Descente en gradient

Ensuite, nous allons implémenter la descente de gradient, le code donné a implémenté la structure de boucle, il vous suffit de fournir $mise\; à\; jour\; de\; \theta$ .

Lors de la mise en œuvre du code, assurez-vous de comprendre ce qui est optimisé et ce qui est mis à jour.

Rappelez-vous, le coût $J\left(\theta \right)$ est un paramètre-be vecteur$\theta$ se termine au lieu de$X$和$y$ . Autrement dit, nous allons$La\; valeur\; de\; J\left(\theta \right)$ est minimisée en changeant le vecteur$valeur\; de\; \theta$ , plutôt qu'en changeant$X$或$et$。

Un bon moyen de vérifier que la descente de gradient fonctionne est de regarder $J\left(\theta \right)$ et vérifiez si la valeur diminue à chaque étape. A chaque itération, le code appellecomputeCostla fonction et imprime le coût. En supposant que vous implémentiez la descente de gradient, calculez le coût correctement,$La\; valeur\; J\left(\theta \right)$ ne devrait jamais augmenter et devrait converger vers une valeur stable à la fin de l'algorithme.

Points principaux:

Une fois la descente de gradient implémentée, les valeurs finales des paramètres doivent être utilisées pour visualiser les résultats d'ajustement de la régression linéaire, et les résultats du dessin doivent être similaires à ceux illustrés dans la figure ci-dessous.

###在这里填入代码###
def gradientDescent(X, y, theta, alpha, iters):
    temp = np.matrix(np.zeros(theta.shape))
    parameters = int(theta.ravel().shape[1]) 
    cost = np.zeros(iters)
    
    for i in range(iters):
        error = (X * theta) - y
        
        for j in range(parameters):
            term = np.multiply(error, X[:,j])
            temp[j,0] = theta[j,0] - ((alpha / len(X)) * np.sum(term))
            
        theta = temp
        cost[i] = computeCost(X, y, theta)
        
    return theta, cost

# 开始训练，最终输出训练完成的模型参数
t_final, cost_final = gradientDescent(X, y, theta, alpha, iterations)

# 计算最终的参数所得到的成本值
computeCost(X, y, t_final)

4.483388256587726

###在这里填入代码###
#对拟合曲线进行绘制
x = np.linspace(data.Population.min(), data.Population.max(), 100)
f = t_final[0,0] + (t_final[1,0] * x)
 
fig, ax = plt.subplots(figsize=(9,6))
ax.plot(x, f, 'b', label='Prediction')
ax.scatter(data.Population, data.Profit, c='red',label='Traning Data')
ax.legend(loc=2)
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')

Text(0.5, 1.0, 'Predicted Profit vs. Population Size')

2.3 Visualisation de la fonction de coût

Afin de mieux comprendre le calcul itératif de la fonction de coût, la valeur de coût calculée à chaque étape est enregistrée et tracée.

fig, ax = plt.subplots(figsize=(12,8))
ax.plot(np.arange(iterations), cost, 'r')
ax.set_xlabel('Iterations')
ax.set_ylabel('Cost')
ax.set_title('Error vs. Training Epoch')

Text(0.5, 1.0, 'Error vs. Training Epoch')

exercice facultatif

---

3 Régression linéaire multivariée

Dans cette partie, plusieurs variables seront utilisées pour mettre en œuvre une régression linéaire afin de prédire les prix des logements. Disons que vous vendez actuellement une maison et que vous voulez savoir ce qu'est un bon prix du marché.

Une approche consiste à recueillir d'abord des informations sur les maisons récemment vendues et ensuite à modéliser les prix des maisons.

Le fichier ex1data2.txtcontient les prix des maisons et des informations connexes pour Portland, Oregon. La première colonne est la taille de la maison en pieds carrés, la deuxième colonne est le nombre de chambres à coucher et la troisième colonne est le prix de la maison.

3.1 Standardisation des fonctionnalités

Le code suivant ex1data2.txtchargera et affichera cet ensemble de données à partir d'un fichier file.

En regardant les données, on peut voir que la taille de la maison est d'environ 1000 fois le nombre de chambres. Lorsque la différence entre différentes valeurs propres est de plusieurs ordres de grandeur, la mise à l'échelle des caractéristiques peut faire converger plus rapidement la descente du gradient .

path = '/home/jovyan/work/ex1data2.txt'
data2 = pd.read_csv(path, header=None, names=['Size', 'Bedrooms', 'Price'])
data2.head()

	Taille	Chambres	Prix
0	2104	3	399900
1	1600	3	329900
2	2400	3	369000
3	1416	2	232000
4	3000	4	539900

Dans cette partie de l'exercice, votre tâche consiste à écrire le code et à standardiser les données dans l'ensemble de données .

Points principaux :

• Soustrayez la moyenne de chaque caractéristique de l'ensemble de données.
• Après avoir soustrait la moyenne, divisez les nouvelles valeurs propres par leurs "écarts-types" respectifs

L'écart type est une mesure de la variation de la plage de valeurs pour une caractéristique particulière (la plupart des points de données seront à moins de deux écarts types de la moyenne); c'est une alternative à la plage de valeurs.

Lors de la normalisation des fonctionnalités, vous devez stocker les valeurs utilisées pour la normalisation - moyenne et écart type. Après avoir appris les paramètres du modèle, il est souvent nécessaire de prévoir le prix des maisons neuves. Étant donné un nouveau $Les\; valeurs\; x$ (taille de la maison et nombre de chambres) doivent d'abord être normalisées aux nouvelles données en utilisant la moyenne et l'écart type précédemment calculés à partir de l'ensemble d'apprentissage.

###在这里填入代码###
data2 = (data2 - data2.mean()) / data2.std()
data2.head()

	Taille	Chambres	Prix
0	0,130010	-0,223675	0,475747
1	-0,504190	-0,223675	-0,084074
2	0,502476	-0,223675	0,228626
3	-0,735723	-1.537767	-0,867025
4	1.257476	1.090417	1.595389

3.2 Descente en gradient

Dans l'exercice précédent, nous avons implémenté le problème de descente de gradient en utilisant la régression linéaire univariée. Dans cette partie du lien, la seule différence est qu'à ce stade, nos données deviennent la matrice $X。$ _

En supposant que la fonction et la règle de mise à jour de la descente de gradient par lots restent constantes, votre tâche consiste à coder la fonction de coût et la descente de gradient pour la régression linéaire multivariée .

Points principaux :

• Assurez-vous que votre code peut prendre en charge des données de n'importe quelle taille et que les données sont vectorisées.
• Une fois que le code a implémenté la fonction de coût et la descente de gradient, la valeur de coût finale doit être d'environ 0,13.
• Veuillez suivre les exigences de l'exercice de régression linéaire univariée pour tracer la courbe de variation du coût.

###在这里填入代码###
data2.insert(0, 'Ones', 1)
cols = data2.shape[1]
X2 = data2.iloc[:,0:cols-1]
y2 = data2.iloc[:,cols-1:cols]

X2 = np.matrix(X2.values)
y2 = np.matrix(y2.values)
theta = np.matrix(np.array([0,0,0]))

w2_final, cost2_final = gradientDescent(X2, y2, theta.T, alpha, iterations)

print('The weight vector:\n',w2_final)
computeCost(X2, y2, w2_final)
 
fig, ax = plt.subplots(figsize=(12,8))
ax.plot(np.arange(iterations), cost2_final, 'r')
ax.set_xlabel('Iterations')
ax.set_ylabel('Cost')
ax.set_title('Error vs. Iterations')

The weight vector:
 [[-1.00309831e-16]
 [ 8.84042349e-01]
 [-5.24551809e-02]]





Text(0.5, 1.0, 'Error vs. Iterations')