（1）資料概覽

import pandas as pd
import seaborn as sns
sns.set(context="notebook", style="whitegrid", palette="dark")
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np

raw_data = pd.read_csv('ex1data2.txt', names=['square', 'bedrooms', 'price'])
raw_data.head()

（2）繪圖觀察資料

（3）資料預處理

def get_X(df):#讀取特徵
    ones = pd.DataFrame({'ones': np.ones(len(df))})#ones是m行1列的dataframe
    data = pd.concat([ones, df], axis=1)  # 合併資料，根據列合併
    return data.iloc[:, :-1].as_matrix()  # 這個操作返回 ndarray,轉為二維矩陣

def get_y(df):#讀取標籤
    #  '''iloc選取列資料，選取所有行資料，只要最後一列，'''
    return np.array(df.iloc[:, -1])#df.iloc[:, -1]是指df的最後一列

def normalize_feature(df):
    # """Applies function along input axis(default 0) of DataFrame."""
    return df.apply(lambda column: (column - column.mean()) / column.std())#特徵縮放

data = normalize_feature(raw_data)
data.head()

（4）模型

# X_data 為特徵集，y_data為目標集，alpha 為學習率，epoch 為迭代次數，optimizer為梯度下降演算法
def linear_regression(X_data, y_data, alpha, epoch, optimizer=tf.train.GradientDescentOptimizer):
      # placeholder for graph input
    X = tf.placeholder(tf.float32, shape=X_data.shape)
    y = tf.placeholder(tf.float32, shape=y_data.shape)

    # 設計計算圖
    with tf.variable_scope('linear-regression'):

        #初始化引數矩陣 2*1
        W = tf.get_variable("weights", (X_data.shape[1], 1),initializer=tf.constant_initializer())  # n*1
        #矩陣乘法
        y_pred = tf.matmul(X, W)  # m*n @ n*1 -> m*1
        #損失函式，a.T @ a  ,相當於求平方
        loss = 1 / (2 * len(X_data)) * tf.matmul((y_pred - y), (y_pred - y), transpose_a=True)  # (m*1).T @ m*1 = 1*1

         #設定學習率，使用梯度下降演算法，優化損失函式loss
    opt_operation = optimizer(learning_rate=alpha).minimize(loss)
   

    # 開始訓練
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())

         #存放損失值列表
        loss_data = []

        for i in range(epoch):
            _, loss_val, W_val = sess.run([opt_operation, loss, W], feed_dict={X: X_data, y: y_data})
            loss_data.append(loss_val[0, 0])  # because every loss_val is 1*1 ndarray

            if len(loss_data) > 1 and np.abs(loss_data[-1] - loss_data[-2]) < 10 ** -9:  # early break when it's converged
                # print('Converged at epoch {}'.format(i))
                break

    # clear the graph
    tf.reset_default_graph()
    return {'loss': loss_data, 'parameters': W_val}  

（5） 開始訓練

X_data = get_X(data)
print (X_data)
print(X_data.shape, type(X_data))

y_data = get_y(data).reshape(len(X_data), 1)  # special treatment for tensorflow input data
print (y_data)
print(y_data.shape, type(y_data))

epoch = 2000
alpha = 0.01

optimizer_dict={'GD': tf.train.GradientDescentOptimizer,
                'Adagrad': tf.train.AdagradOptimizer,
                'Adam': tf.train.AdamOptimizer,
                'Ftrl': tf.train.FtrlOptimizer,
                'RMS': tf.train.RMSPropOptimizer
               }
results = []
for name in optimizer_dict:
    res = linear_regression(X_data, y_data, alpha, epoch, optimizer=optimizer_dict[name])
    res['name'] = name
    results.append(res)

（6）繪圖

fig, ax = plt.subplots(figsize=(16, 9))

for res in results: 
    parameters = res['parameters']
    print (parameters)
    loss_data = res['loss']
    ax.plot(np.arange(len(loss_data)), loss_data, label=res['name'])

ax.set_xlabel('epoch', fontsize=18)
ax.set_ylabel('cost', fontsize=18)
ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
ax.set_title('different optimizer', fontsize=18)
plt.show()