keras windows pycharm环境搭建与测试

官方文档

https://keras.io/zh/getting-started/sequential-model-guide/

https://keras.io/getting-started/sequential-model-guide/

keras 结构

https://www.aliyun.com/jiaocheng/526342.html

【安装Anaconda3】

下载：https://www.continuum.io/downloads，安装过程中提示failed to create anacoda menue错误时参考http://www.cnblogs.com/chuckle/p/7429624.html。

其它：https://blog.csdn.net/johinieli/article/details/66975546?utm_source=itdadao&utm_medium=referral

Anaconda3 下载

https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/ 

Anaconda完全入门指南

https://www.jianshu.com/p/eaee1fadc1e9

【安装TensorFlow】（须要网络链接，离线安装参考：http://www.jianshu.com/p/c245d46d43f0）

　　打开Anaconda Prompt，输入：

pip install tensorflow

pip install tensortflow

【安装keras】（须要网络链接，参考：http://www.jianshu.com/p/c245d46d43f0）

　　打开Anaconda Prompt，输入：

pip install keras

pip install keras

　　这里会安装Theano，不管它。

 

【测试keras是否安装成功】（参考：http://www.jianshu.com/p/c245d46d43f0）

　　打开Anaconda Prompt，在命令行中输入：

python

　　再输入：

import tensorflow as tf
sess = tf.Session()
a = tf.constant(10)
b = tf.constant(22)
print(sess.run(a + b))

import tensorflow as tf;

sess=tf.Session();

a=tf.constant(10);

b=tf.constant(22);

print(sess.run(a+b));

输出为32，TensorFlow安装成功。

再输入：

import keras

 import keras

无错即keras安装成功。

 

【安装Pycharm并激活】

略。

修改Python解释器路径，选择Anaconda安装目录下的python.exe：

【demo】

在Pycharm中新建工程，新建python file，拷贝下列代码（原作者：@渉风，http://www.cnblogs.com/surfzjy/p/6419201.html），运行。

预测分类

# 官方文档
# https://keras.io/zh/getting-started/sequential-model-guide/

from __future__ import print_function
# 导入numpy库， numpy是一个常用的科学计算库，优化矩阵的运算
import numpy as np
np.random.seed(1337)

# 导入mnist数据库， mnist是常用的手写数字库
from keras.datasets import mnist
# 导入顺序模型
from keras.models import Sequential
# 导入全连接层Dense， 激活层Activation 以及 Dropout层
from keras.layers.core import Dense, Dropout, Activation
# 导入优化器RMSProp
from keras.optimizers import RMSprop
# 导入numpy工具，主要是用to_categorical来转换类别向量
from keras.utils import np_utils

from keras.models import load_model

#epoch：一个epoch表示所有训练样本运算学习一遍。
#iteration/step：表示每运行一个iteration/step，更新一次参数权重，即进行一次学习，每一次更新参数需要batch size个样本进行运算学习，根据运算结果调整更新一次参数。
#batch size：一次参数更新运算所需的样本数量，深度学习每一次参数更新并不是一个样本学习运算得来的，而是通过对一组数据进行运算后更新一次参数，具体原因在这。

batch_size = 128
# 设置类别的个数
nb_classes = 10
# 设置迭代的次数  会将所有数据
nb_epoch = 5
# keras中的mnist数据集已经被划分成了60,000个训练集，10,000个测试集的形式，按以下格式调用即可
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# X_train原本是一个60000*28*28的三维向量，将其转换为60000*784的二维向量
X_train = X_train.reshape(60000, 784)
# X_test原本是一个10000*28*28的三维向量，将其转换为10000*784的二维向量
X_test = X_test.reshape(10000, 784)
# 将X_train, X_test的数据格式转为float32存储
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# 归一化
X_train /= 255
X_test /= 255
# 打印出训练集和测试集的信息
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples')
'''

将类别向量(从0到nb_classes的整数向量)映射为二值类别矩阵，
相当于将向量用one-hot重新编码
'''
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
# 建立顺序型模型
model = Sequential()
'''
模型需要知道输入数据的shape，
因此，Sequential的第一层需要接受一个关于输入数据shape的参数，
后面的各个层则可以自动推导出中间数据的shape，
因此不需要为每个层都指定这个参数
''' 

# 输入层有784个神经元
# 第一个隐层有512个神经元，激活函数为ReLu，Dropout比例为0.2
model.add(Dense(512, input_shape=(784,)))
model.add(Activation('relu'))
model.add(Dropout(0.2))
#dropout ropout是指在深度学习网络的训练过程中，对于神经网络单元，按照一定的概率将其暂时从网络中丢弃。
# 注意是暂时，对于随机梯度下降来说，由于是随机丢弃，故而每一个mini-batch都在训练不同的网络。
#https://blog.csdn.net/program_developer/article/details/80737724

# 第二个隐层有512个神经元，激活函数为ReLu，Dropout比例为0.2
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.2))

# model.add(Dense(512))
# model.add(Activation('relu'))
# model.add(Dropout(0.2))

# 输出层有10个神经元，激活函数为SoftMax，得到分类结果
model.add(Dense(10))
model.add(Activation('softmax'))
#Softmax 将多分类的输出数值转化为相对概率，更容易理解和比较
# [3.3581444e-13 3.3409175e-11 4.2342165e-09 2.4993017e-08 1.6207779e-15
#  5.6781187e-11 5.6786124e-20 9.9999988e-01 1.6226248e-11 1.7751047e-07]
# [1.0568786e-13 3.0947852e-08 1.0000000e+00 9.8890653e-11 4.8005168e-19
#  9.2672009e-17 4.5638234e-17 2.3698708e-14 1.2249552e-14 7.3881355e-20]
#https://blog.csdn.net/red_stone1/article/details/80687921

# 输出模型的整体信息
# 总共参数数量为784*512+512 + 512*512+512 + 512*10+10 = 669706
model.summary()
# 输出各层信息
'''
配置模型的学习过程
compile接收三个参数：
1.优化器optimizer：参数可指定为已预定义的优化器名，如rmsprop、adagrad，
或一个Optimizer类对象，如此处的RMSprop()
2.损失函数loss：参数为模型试图最小化的目标函数，可为预定义的损失函数，
如categorical_crossentropy、mse，也可以为一个损失函数
3.指标列表：对于分类问题，一般将该列表设置为metrics=['accuracy']
'''
model.compile(loss='categorical_crossentropy',
              optimizer=RMSprop(),
              metrics=['accuracy'])
# 当使用categorical_crossentropy损失函数时，你的标签应为多类模式，例如如果你有10个类别，每一个样本的标签应该是一个10维的向量，该向量在对应有值的索引位置为1其余为0。
'''
训练模型
batch_size：指定梯度下降时每个batch包含的样本数
nb_epoch：训练的轮数，nb指number of
verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为epoch输出一行记录
validation_data：指定验证集
fit函数返回一个History的对象，其History.history属性记录了损失函数和其他指标的数值随epoch变化的情况，
如果有验证集的话，也包含了验证集的这些指标变化情况
'''
history = model.fit(X_train, Y_train,
                    batch_size = batch_size,
                    nb_epoch = nb_epoch,
                    verbose = 1,
                    validation_data = (X_test, Y_test))

# 按batch计算在某些输入数据上模型的误差
score = model.evaluate(X_test, Y_test, verbose=0)
#verbose：日志显示
#verbose = 0 为不在标准输出流输出日志信息
#verbose = 1 为输出进度条记录
#verbose = 2 为每个epoch输出一行记录
# 输出训练好的模型在测试集上的表现


classes = model.predict(X_test, batch_size=batch_size)

# [3.3581444e-13 3.3409175e-11 4.2342165e-09 2.4993017e-08 1.6207779e-15
#  5.6781187e-11 5.6786124e-20 9.9999988e-01 1.6226248e-11 1.7751047e-07]
# [1.0568786e-13 3.0947852e-08 1.0000000e+00 9.8890653e-11 4.8005168e-19
#  9.2672009e-17 4.5638234e-17 2.3698708e-14 1.2249552e-14 7.3881355e-20]

print('Test score:', score[0])
print('Test accuracy:', score[1])


model.save('C:/Users/sj/Downloads/model.h5')
print('load the model ')
model = load_model('C:/Users/sj/Downloads/model.h5')
print('Use the loaded model to predict the X_test again')
score = model.evaluate(X_test, Y_test, verbose=0)

print('Test score:', score[0])
print('Test accuracy:', score[1])

预测数值：

import numpy as np
import keras as ks
from keras.models import Sequential
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
from keras.layers import Dense, Activation,Dropout
import pandas as pd

# source code from
# https://ask.csdn.net/questions/693201
# collection.csv (rows:2015)：
# 1	1957	0	0	0	0	1131633.871	509566.129	1047995.181	593204.8193
# 1	1958	0	0	0	0	926483.871	714716.129	0	1641200
# 1	1959	4443.304631	22000	0	0	906630.6452	734569.3548	0	1641200
# 1	1960	3569.504508	18666.66667	0	0	933101.6129	708098.3871	995265.8635	645934.1365
# 1	1961	4166.18949	11333.33333	3333.333333	0	800746.7742	840453.2258	32955.82329	1608244.177
# 1	1962	4112.638188	10000	2000	0	893395.1613	747804.8387	1239138.956	402061.0442
# 1	1963	0	0	0	0	853688.7097	787511.2903	481155.0201	1160044.98
# 1	1964	3299.988493	10000	0	0	979425.8065	661774.1935	0	1641200
# 1	1965	10435.97224	17333.33333	3333.333333	0	906630.6452	734569.3548	1476420.884	164779.1165
# ...

# 导入数据注意格式 有时csv文件不一定是
x_yuan = np.loadtxt(open("C:/Users/sj/Downloads/collection.csv","rb"),usecols=(3, 4, 5, 6, 7, 8, 9),delimiter=",",skiprows=0)
x = preprocessing.scale(x_yuan)
y = np.loadtxt(open("C:/Users/sj/Downloads/collection.csv","rb"),usecols=(2 ),delimiter=",",skiprows=0)
# x_yuan = np.loadtxt(open("C:/Users/sj/Desktop/collection.txt","rb"),delimiter=" ",skiprows=1)
# x = preprocessing.scale(x_yuan)
# y = np.loadtxt(open("C:/Users/sj/Desktop/collection.txt","rb"),usecols=(2 ),delimiter=" ",skiprows=1)

x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.7, random_state=43)

model = Sequential()

# model.add(Dense(units=30, input_dim=7))

model.add(Dense(10, input_shape=(7,)))
model.add(Activation('relu'))
model.add(Dropout(0.2))

# model.add(Dense(10, input_shape=(7,)))
# model.add(Activation('relu'))
# model.add(Dropout(0.2))

# model.add(Dense(512))
# model.add(Activation('relu'))
# model.add(Dropout(0.2))


model.add(Dense(1))
model.add(Activation('linear'))


ks.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0, mode='auto', epsilon=0.0001, cooldown=0, min_lr=0)

sgd = ks.optimizers.SGD(lr=0.001, clipnorm=1.,decay=1e-6, momentum=0.9)
model.compile(optimizer='sgd', loss='mae', metrics=['mae'])  #平均绝对误差(MAE)
# model.fit(x_train, y_train, batch_size=30, epochs=20, callbacks=None, validation_data=(x_test,y_test), shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0)

batch_size = 30
# 设置迭代的次数  会将所有数据
nb_epoch = 20
for i in range(15):
    history = model.fit(x_train, y_train,
                        batch_size = batch_size,
                        epochs = nb_epoch,
                        verbose = 0,
                        validation_data = (x_test, y_test))

    predict = model.predict(x_test)

    predictdDf = pd.DataFrame(predict)

    y_testDf=pd.DataFrame(y_test)

    corr = predictdDf.corrwith(y_testDf)

    print(corr)



#
# sum = 0
# for i in range(len(y_test)):
#     sum = sum+(y_test[i]-predict[i])**2
#     mse = sum/len(y_test)
# print(mse)

 

其它： 数据处理、数据增强