import math

# display模塊可以決定顯示的內容以何種格式顯示

from IPython import display

# matplotlib為python的2D繪圖庫

# cm為顏色映射表

from matplotlib import cm

# 使用 GridSpec 自定義子圖位置

from matplotlib import gridspec

# pyplot提供了和matlab類似的繪圖API，方便用戶快速繪制2D圖表

from matplotlib import pyplot as plt

# numpy為python的科學計算包，提供了許多高級的數值編程工具

import numpy as np

# pandas是基于numpy的數據分析包，是為了解決數據分析任務而創建的

import pandas as pd

# sklearn(scikit-_learn_)是一個機器學習算法庫,包含了許多種機器學習得方式

# * Classification 分類

# * Regression 回歸

# * Clustering 非監督分類

# * Dimensionality reduction 數據降維

# * Model Selection 模型選擇

# * Preprocessing 數據預處理

# metrics:度量（字面意思），它提供了很多模塊可以為第三方庫或者應用提供輔助統計信息

from sklearn import metrics

# tensorflow是谷歌的機器學習框架

import tensorflow as tf

# Dataset無比強大得數據集

from tensorflow.python.data import Dataset

tf.logging.set_verbosity(tf.logging.ERROR)

# 為了觀察數據方便，最多只顯示10行數據

pd.options.display.max_rows = 10

pd.options.display.float_format = '{:.1f}'.format

//california_housing_dataframe.index原始序列集索引

//np.random.permutation（）隨機打亂原索引順序

//california_housing_dataframe.reindex（）以新的索引順序重新分配索引

california_housing_dataframe=california_housing_dataframe.reindex(np.random.permutation(california_housing_dataframe.index))

california_housing_dataframe["median_house_value"] /= 1000.0

california_housing_dataframe

# Define the input feature: total_rooms.

# 取數據集中得'total_rooms'這一列作為輸入特征

my_feature = california_housing_dataframe[["total_rooms"]]

# Configure a numeric feature column for total_rooms.

# 將一個名叫"total_rooms"的特征列定義為**數值數據** ，這樣的定義結果存在feature_columns中

# 即上文所說得**特征列**中，這時候特征列其實只是一個存儲了分類信息的集合，具體使用的時候需要

# 特征集合和特征列結合起來，分類器才能識別的呢

feature_columns = [tf.feature_column.numeric_column("total_rooms")]

# Define the label.

# 將"median_house_value"列的數據從數據集中取出作為target，這就是我們搭建的模型所要學習的東# 西

targets = california_housing_dataframe["median_house_value"]

# Use gradient descent as the optimizer for training the model.

my_optimizer=tf.train.GradientDescentOptimizer(learning_rate=0.0000001)

# 這里的clip_by_norm是指對梯度進行裁剪，通過控制梯度的最大范式，防止梯度爆炸的問題，是一種

# 比較常用的梯度規約的方式，解釋起來太費事啦。。。。略略

my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)

# Configure the linear regression model with our feature columns and optimizer

# Set a learning rate of 0.0000001 for Gradient Descent.

# 線性回歸模型，tf.estimator.LinearRegressor是tf.estimator.Estimator的子類

# 傳入參數為**特征**列和剛才配置的**優化器**，至此線性回歸模型就配置的差不多啦

# 前期需要配置模型，所以是與具體數據（特征值，目標值是無關的）

linear_regressor = tf.estimator.LinearRegressor(

feature_columns=feature_columns,

optimizer=my_optimizer

)

# 自定義個輸入函數

# 輸入的參數分別為

# features:特征值（房間數量）

# targets: 目標值（房屋價格中位數）

# batch_size:每次處理訓練的樣本數（這里設置為1）

# shuffle: 如果 `shuffle` 設置為 `True`，則我們會對數據進行隨機處理

# num_epochs:將默認值 `num_epochs=None` 傳遞到 `repeat()`，輸入數據會無限期重復

def my_input_fn(features, targets, batch_size=1, shuffle=True, num_epochs=None):

# dict(features).items():將輸入的特征值轉換為dictinary（python的一種數據類型，

# lalala = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com'}）

# 通過for語句遍歷，得到其所有的一一對應的值（key：value）

features = {key:np.array(value) for key,value in dict(features).items()}

# Dataset.from_tensor_slices（(features,targets)）將輸入的兩個參數拼接組合起來，

# 形成一組一組的**切片**張量{（房間數，價格），（房間數，價格）....}

ds = Dataset.from_tensor_slices((features,targets)) # warning: 2GB limit

# batch(batch_size):將ds數據集按照batch_size大小組合成一個batch

# repeat(num_epochs):repeat代表從ds這個數據集要重復讀取幾次，在這里num_epochs=None

# 代表無限次重復下去，但是因為ds數據集有容量上限，所以會在上限出停止重復

ds = ds.batch(batch_size).repeat(num_epochs)

# Shuffle the data, if specified

# 現在ds中得數據集已經時按照batchsize組合成得一個一個batch，存放在隊列中，并且是重復了n次

# 這樣子得話，不斷重復，后面數據是沒有意義，所以要將其隨機打亂

# shuffle(buffer_size=10000):表示打亂得時候使用得buffer大小是10000，即ds中按順序取10000個出來

# 打亂放回去，接著從后面再取10000個，按順序來

if shuffle:

ds = ds.shuffle(buffer_size=10000)

# Return the next batch of data

# make_one_shot_iterator():最簡單的一種迭代器，僅會對數據集遍歷一遍

# make_one_shot_iterator().get_next():迭代的時候返回所有的結果

features, labels = ds.make_one_shot_iterator().get_next()

# 向 LinearRegressor 返回下一批數據

return features, labels

_ = linear_regressor.train(

input_fn = lambda:my_input_fn(my_feature, targets),

steps=100

)

# 上一步已經將數據輸入，并訓練了一百步，所以現在的模型的參數是已經調整過的

# 現在我們來獲得**誤差**，對誤差進行分析，以衡量訓練了一百步的模型效果怎么樣

# 獲取誤差的方式很簡單，還是采用原來的數據集輸入，這次不是訓練，而是直接預測，返回預測結果

prediction_input_fn =lambda: my_input_fn(my_feature, targets, num_epochs=1, shuffle=False)

predictions = linear_regressor.predict(input_fn=prediction_input_fn)

# 將預測結果取出，格式化為numpy數組，來進行誤差分析

predictions = np.array([item['predictions'][0] for item in predictions])

# 計算均方誤差（MSE），即Sum（（target-predictions）2）/N，

mean_squared_error = metrics.mean_squared_error(predictions, targets)

# 再對均方誤差開根，得到均方根誤差（RMSE），目的就是看看預測值和真實的target相差了多少

root_mean_squared_error = math.sqrt(mean_squared_error)

# 輸出MSE和RMSE

print "Mean Squared Error (on training data): %0.3f" % mean_squared_error

print "Root Mean Squared Error (on training data): %0.3f" % root_mean_squared_error

min_house_value = california_housing_dataframe["median_house_value"].min()

max_house_value = california_housing_dataframe["median_house_value"].max()

min_max_difference = max_house_value - min_house_value

print "Min. Median House Value: %0.3f" % min_house_value

print "Max. Median House Value: %0.3f" % max_house_value

print "Difference between Min. and Max.: %0.3f" % min_max_difference

print "Root Mean Squared Error: %0.3f" % root_mean_squared_error

# 使用pdndas的工具來對數據簡單處理分析

calibration_data = pd.DataFrame()

# pd.Series就是將參數中的list（一維的矩陣），添加到其中，具體效果看輸出的表格

calibration_data["predictions"] = pd.Series(predictions)

calibration_data["targets"] = pd.Series(targets)

calibration_data.describe()

# Get the min and max total_rooms values.

x_0 = sample["total_rooms"].min()

x_1 = sample["total_rooms"].max()

# 從目前的訓練模型中取出訓練得到的weight（權重）和bias（b：y=w1x1+w2x2+...+b其中的b（不知道要怎么翻））

weight = linear_regressor.get_variable_value('linear/linear_model/total_rooms/weights')[0]

bias = linear_regressor.get_variable_value('linear/linear_model/bias_weights')

# 使用目前訓練得到權值去估計x_0和x_1對應的y_0和y_1(因為訓練得到的預測結果是線性的，只要知道直線端點就ok)

y_0 = weight * x_0 + bias

y_1 = weight * x_1 + bias

# 還記得一開始導入的一個2D圖形庫matplotlib嗎，其是python的最主要的可視化庫

# 可以利用其繪制散點圖、直方圖和箱形圖，及修改圖表屬性等

# 下面使用其plot（二維線條畫圖函數），c='r'是線條參數，紅色

plt.plot([x_0, x_1], [y_0, y_1], c='r')

# 設置坐標軸lable

plt.ylabel("median_house_value")

plt.xlabel("total_rooms")

# scatter()繪制散點圖，在此繪制sample中的對應的total_rooms和median_house_value的散點圖

plt.scatter(sample["total_rooms"], sample["median_house_value"])

plt.show()

# 定義個函數融合上面所有的操作，以下是參數說明，并順便復習以下上面的內容

# learning_rate:學習速率（步長）,可以調節梯度下降的速度

# steps:訓練步數，越久效果一般會越準確，但花費的時間也是越多的

# batch_size:每次處理訓練的樣本數（將原來數據打包成一塊一塊的，塊的大小）

# input_feature:輸入的特征

def train_model(learning_rate, steps, batch_size, input_feature="total_rooms"):

periods = 10

# 將步長分十份，用于每訓練十分之一的步長就輸出一次結果

steps_per_period = steps / periods

# 以下是準備數據,分別是my_feature_data 和 targets

my_feature = input_feature

my_feature_data = california_housing_dataframe[[my_feature]]

my_label = "median_house_value"

targets = california_housing_dataframe[my_label]

# 創建特征列

feature_columns = [tf.feature_column.numeric_column(my_feature)]

# 創建輸入函數（訓練和預測）

training_input_fn = lambda:my_input_fn(my_feature_data, targets, batch_size=batch_size)

prediction_input_fn = lambda: my_input_fn(my_feature_data, targets, num_epochs=1, shuffle=False)

# 創建線性回歸模型

my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)

my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)

linear_regressor = tf.estimator.LinearRegressor(

feature_columns=feature_columns,

optimizer=my_optimizer

)

# 設置每個階段的輸出

# 新建繪畫窗口，自定義畫布的大小為15*6

plt.figure(figsize=(15, 6))

# 設置畫布劃分以及圖像在畫布上輸出的位置1行2列，繪制在第1個位置

plt.subplot(1, 2, 1)

plt.title("Learned Line by Period")

plt.ylabel(my_label)

plt.xlabel(my_feature)

sample = california_housing_dataframe.sample(n=300)

plt.scatter(sample[my_feature], sample[my_label])

# np.linspace(-1, 1, periods):用于輸出等差數列，起始-1，結尾1，periods=10，10等分（不寫的話默認50等分）

# cm.coolwarm(x):設置顏色，用于十條線顯示不同顏色

colors = [cm.coolwarm(x) for x in np.linspace(-1, 1, periods)]

# 周期評估并輸出（把訓練分十次，并輸出）

print "Training model..."

print "RMSE (on training data):"

root_mean_squared_errors = []

for period in range (0, periods):

linear_regressor.train(

input_fn=training_input_fn,

steps=steps_per_period

)

predictions = linear_regressor.predict(input_fn=prediction_input_fn)

predictions = np.array([item['predictions'][0] for item in predictions])

root_mean_squared_error = math.sqrt(

metrics.mean_squared_error(predictions, targets))

print " period %02d : %0.2f" % (period, root_mean_squared_error)

root_mean_squared_errors.append(root_mean_squared_error)

# 取出十次訓練得到的w和b，用于繪制

y_extents = np.array([0, sample[my_label].max()])

weight = linear_regressor.get_variable_value('linear/linear_model/%s/weights' % input_feature)[0]

bias = linear_regressor.get_variable_value('linear/linear_model/bias_weights')

x_extents = (y_extents - bias) / weight

x_extents = np.maximum(np.minimum(x_extents,

sample[my_feature].max()),

sample[my_feature].min())

y_extents = weight * x_extents + bias

plt.plot(x_extents, y_extents, color=colors[period])

print "Model training finished."

# 輸出RMSE曲線圖

plt.subplot(1, 2, 2)

plt.ylabel('RMSE')

plt.xlabel('Periods')

plt.title("Root Mean Squared Error vs. Periods")

plt.tight_layout()

plt.plot(root_mean_squared_errors)

# 輸出預測target的對比

calibration_data = pd.DataFrame()

calibration_data["predictions"] = pd.Series(predictions)

calibration_data["targets"] = pd.Series(targets)

display.display(calibration_data.describe())

print "Final RMSE (on training data): %0.2f" % root_mean_squared_error

# 調用train_model

# learning_rate=0.00002：學習速率翻倍，有限步長可能會計算的更接近

# steps=500：訓練500步

# batch_size=5：一批5組數據

train_model(

learning_rate=0.00002,

steps=500,

batch_size=5

)

train_model(

learning_rate=0.00002,

steps=1000,

batch_size=5,

input_feature="population"

)