MOOC网深度学习应用开发1——Tensorflow基础、多元线性回归:波士顿房价预测问题Tensorflow实战、MNIST手写数字识别：分类应用入门、泰坦尼克生存预测

Tensorflow基础

tensor基础

当数据类型不同时，程序做相加等运算会报错，可以通过隐式转换的方式避免此类报错。

单变量线性回归

监督式机器学习的基本术语

线性回归的Tensorflow实战：初步

多元线性回归:波士顿房价预测问题Tensorflow实战

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.utils import shuffle
from sklearn.preprocessing import scale
import tensorflow as tf

df = pd.read_csv("data/boston.csv",header=0)
print(df.describe())
print(df.head(3))  #显示前3条数据
print(df.tail(3))  #显示后3条数据
ds = df.values  #获取数据集的值，df.values以np.array形式返回数据集的值
print(ds.shape)
print(ds)
x_data = ds[:,:12] #x_data为归一化后的前12列特征数据
y_data = ds[:,12]  #y_data为最后1列标签数据
#对特征数据[0-11]列做0-1归一化
for i in range(12):
    x_data[:,i]=(x_data[:,i]-x_data[:,i].min())/(x_data[:,i].max()-x_data[:,i].min())
print('x_data shape=',x_data.shape)
print('y_data shape=',y_data.shape)
train_num = 300  #训练集的数目
valid_num = 100  #验证集的数目
test_num = len(x_data)-train_num-valid_num  #测试集的数目
x_train = x_data[:train_num]  #训练集
y_train = y_data[:train_num]  #训练集
x_valid = x_data[train_num:train_num+valid_num]  #验证集
y_valid = y_data[train_num:train_num+valid_num]  #验证集
x_test = x_data[train_num+valid_num:train_num+valid_num+test_num]  #测试集
y_test = y_data[train_num+valid_num:train_num+valid_num+test_num]  #测试集
#转换为tf.float32数据类型
x_train = tf.cast(x_train,dtype=tf.float32)
x_valid = tf.cast(x_valid,dtype=tf.float32)
x_test = tf.cast(x_test,dtype=tf.float32)
#构建模型
def model(x,w,b):
    return tf.matmul(x,w) + b
#创建待优化变量,[12,1]:因为输入有12个特征，所以需要12个权重
W = tf.Variable(tf.random.normal([12,1],mean=0.0,stddev=1.0,dtype=tf.float32))
B = tf.Variable(tf.zeros(1),dtype=tf.float32)
print(W)
print(B)
#模型训练
training_epochs = 50   #迭代次数
learning_tate = 0.001  #学习率
batch_size = 10  #批量训练一次的样本数
#定义均方差损失函数
def loss(x,y,w,b):
    err = model(x,w,b) - y  #计算模型预测值和标签值的差异
    squared_err = tf.square(err)   #求平方，得出方差
    return tf.reduce_mean(squared_err)  #求均值，得出均方差
#定义梯度计算函数
#计算样本数据[x,y]在参数[w,b]点上的梯度
def grad(x,y,w,b):
    with tf.GradientTape() as tape:
        loss_ = loss(x,y,w,b)
    return tape.gradient(loss_,[w,b])  #返回梯度向量
#定义优化器,指定学习率
optimizer = tf.keras.optimizers.SGD(learning_tate)
#迭代训练
loss_list_train = [] #用于保存训练集loss值的列表
loss_list_valid = [] #用于保存验证集loss值的列表
total_step = int(train_num/batch_size)

for epoch in range(training_epochs):
    for step in range(total_step):
        xs = x_train[step*batch_size:(step+1)*batch_size,:]
        ys = y_train[step*batch_size:(step+1)*batch_size]
        grads = grad(xs,ys,W,B)  #计算梯度
        optimizer.apply_gradients(zip(grads,[W,B]))  #优化器根据梯度自动调整变量W和B
    loss_train = loss(x_train,y_train,W,B).numpy     #计算当前轮的训练损失
    loss_valid = loss(x_valid,y_valid,W,B).numpy     #计算当前轮的验证损失
    loss_list_train.append(loss_train)
    loss_list_valid.append(loss_valid)
    print("epoch={:3d},train_loss={:.4f},valid_loss={:.4f}".format(epoch+1,loss_train,loss_valid))


plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.plot(loss_list_train,'blue',label="Train Loss")
plt.plot(loss_list_valid,'red',label="Valid Loss")
plt.legend(loc=1)  #通过参数loc指定图例位置
plt.show()

#查看损失
print("Test_loss:{:.4f}".format(loss(x_test,y_test,W,B).numpy()))
#模型应用
test_house_id = np.random.randint(0,test_num)
y = y_test[test_house_id]
y_pred = model(x_test,W,B)[test_house_id]
y_predit = tf.reshape(y_pred,()).numpy()
print("House id",test_house_id,"Actual value",y,"Predicted value",y_predit)

MNIST手写数字识别：分类应用入门

泰坦尼克生存预测

import urllib.request
import os
import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt

data_url = "http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic3.xls"
data_file_path = "data/titanic3.xls"
if not os.path.isfile(data_file_path):
    result=urllib.request.urlretrieve(data_url,data_file_path)
    print('downloaded:',result)
else:
    print(data_file_path,'data file alread exists.')
#读取数据文件，结果为DataFrame
df_data = pd.read_excel(data_file_path)
#查看数据摘要
print(df_data.describe())
#筛选提取需要的特征字段，去掉ticket，cabin等
selected_cols=['survived','name','pclass','sex','age','sibsp','parch','fare','embarked']
selected_df_data=df_data[selected_cols]
print(selected_cols)
#Pandas使用isnull()来判断缺失值，生成所有数据的True/False矩阵，元素为空时显示为True
print(selected_df_data.isnull())
#显示哪些列存在缺失值
print(selected_df_data.isnull().any())
#判断哪些列存在缺失值，将列中为空的个数统计出来
print(selected_df_data.isnull().sum())
#显示存在缺失值的行列，确定缺失值的位置
print(selected_df_data[selected_df_data.isnull().value==True])


#定义数据预处理函数
def prepare_data(df_data):
    # 删除name字段
    df = df_data.drop(['name'], axis=1)
    #数据预处理
    #为缺失age记录填充值，设置为平均值
    age_mean = df['age'].mean()
    #将age列中空值(null)设置为平均值
    df['age']=df['age'].fillna(age_mean)
    #性别sex由字符串转换为数字编码
    df['sex'] = df['sex'].map({'female':0,'male':1}).astype(int)
    #港口embarked由字母表示转换为数字编码
    df['embarked']=df['embarked'].map({'C':0,'Q':1,'S':2}).astype(int)
    #分离特征值和标签值
    #1.转换为ndarray数组
    ndarray_data = df.values
    #2.后7列是特征值,第一个冒号表示全部的行，第二个表示第1列到最后一列
    features = ndarray_data[:,1:]
    #3.第0列是标签值，第一个冒号表示全部的行，第二个表示第0列
    label = ndarray_data[:,0]
    #特征值标准化处理
    from sklearn import preprocessing
    #特征值标准化
    minmax_scale = preprocessing.MinMaxScaler(feature_range=(0,1))  #把所有数值映射到0-1之间，即 value/(max-min)
    norm_feature = minmax_scale.fit_transform(features)
    return norm_feature,label

#shuffle打乱数据顺序，为后面训练做准备
###shuffle，打乱数据顺序，通过Pandas的抽样函数sample实现，frac为百分比
###shuffle_df_data数据保持不变
shuffled_df_data = selected_df_data(frac=1)
#得到处理后的数据集
x_data,y_data = prepare_data(shuffled_df_data)
#划分训练集和测试集
train_size = int(len(x_data)*0.8)
x_train = y_data[:train_size]
y_train = y_data[:train_size]
x_test = x_data[train_size:]
y_test = y_data[train_size:]
#keras建模
model = tf.keras.models.Sequential()
###加入第一层，输入特征数据是7列，也可以用input_shape=(7,)
model.add(tf.keras.layers.Dense(units=64,
                                input_dim=7,
                                use_bias=True,
                                kernel_initializer='uniform',
                                bias_initializer='zeros',
                                activation='relu'))
model.add(tf.keras.layers.Dropout(rate=0.3))
model.add(tf.keras.layers.Dense(units=32,
                                activation='sigmoid'))
model.add(tf.keras.layers.Dropout(rate=0.3))
model.add(tf.keras.layers.Dense(units=1,
                                activation='sigmoid'))
print(model.summary())
#训练模型
###optimizer可以是优化器的名字，如‘adam’,也可以是优化器的实例，如tf.train.AdamOptimizer(0.003)
###loss是损失函数名
###用sigmoid作为激活函数，一般损失函数选用binary_crossentropy
###用softmax作为激活函数，一般损失函数选用categorical_crossentropy
###metrivs模型要训练和评估的度量值
model.compile(optimizer=tf.keras.optimizers.Adam(0.003),
              loss='binary_crossentropy',
              metrics=['accuracy'])
### x:输入的特征数据
### y:标签数据
### validation_split:验证集所占的比例
### verbose:训练过程显示模式，取值 0：不显示 1：带进度条模式 2：每epoch显示一行
### 返回值：过程历史对象，包括训练过程的loss和acc数据，以及验证过程的
train_history=model.fit(x=x_data,
                        y=y_data,
                        validation_split=0.2,
                        epochs=100,
                        batch_size=40,
                        verbose=2)
print(train_history.history)
print(train_history.history.keys())
#训练过程可视化
def visu_train_history(train_history,train_metric,validation_metric):
    plt.plot(train_history.history[train_metric])
    plt.plot(train_history.history[validation_metric])
    plt.title('Train History')
    plt.ylabel(train_metric)
    plt.xlabel('epoch')
    plt.legend(['train','validation'],loc='upper left')
    plt.show()
visu_train_history(train_history,'acc','val_acc')
visu_train_history(train_history,'loss','val_loss')
#模型评估
evaluate_result = model.evaluate(x=x_test,
                                 y=y_test)
print(evaluate_result)
print(model.metrics_names)
#应用模型进行预测
#加入Jack&Rose的数据
Jack_info = [0,'Jack',3,'male',23,1,0,5.000,'S']
Rose_info = [1,'Rose',1,'female',20,1,100.000,'S']
#创建新的旅客DataFrame
new_passenger_pd=pd.DataFrame([Jack_info,Rose_info],columns=selected_cols)
#在老的DataFrame中加入新的旅客信息
all_passenger_pd=selected_df_data.append(new_passenger_pd)
print(all_passenger_pd[-3:])  #查看倒数3行
#执行预测
###数据准备
x_features,y_label = prepare_data(all_passenger_pd)
#利用模型计算旅客生存概率
surv_probability=model.predict(x_features)
print(surv_probability[:5])
#在数据表最后一列插入生存概率
all_passenger_pd.insert(len(all_passenger_pd.columns),'surv_probability',surv_probability)
print(all_passenger_pd[-5:])