keras快速上手-基于python的深度学习实践-基于索引的深度学习对话模型-源代码

该章的源代码已经调通,如下, 先记录下来,再慢慢理解


#!/usr/bin/env python
# coding: utf-8

# In[1]:

import pandas as pd
import numpy as np
import pickle

import keras
from keras.models import Sequential, Model
from keras.layers import Input, Dense, Activation, Dropout, Embedding, Reshape, Dot, Concatenate, Multiply, Merge
from keras.layers import LSTM
from keras.optimizers import RMSprop
from keras.utils.data_utils import get_file
from keras.preprocessing.sequence import pad_sequences
from keras.models import model_from_json

import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
import jieba
plt.rcParams[‘figure.figsize‘]=(20, 10)

# 读入数据

# In[2]: 文件下载地址:http://dataset.cs.mcgill.ca/ubuntu-corpus-1.0/ubuntu_blobs.tgz

with open("dataset.pkl", "rb") as f:
    data = pickle.load(f)

# In[3]:

print("size ======= %s" % len(data))

# In[4]:

import gc
gc.collect()

# 看看数据里都是什么

# In[5]:

for j in range(len(data)):
    print("======= %s" % j)
    for i, k in enumerate(data[j]):
        print(k)

# 这里分析最长的句子的长度

# In[6]:

# 这里分析最长的句子的长度
length=map(len, data[0][‘c‘])
res=list(length)
context_length=np.max(res[:])
print(context_length)

length=map(len, data[0][‘r‘])
res=list(length)
response_length=np.max(res[:])
print(response_length)

# 这里分析整个词典的大小

# In[7]:

context_size = np.max(list(map(lambda x:  max(x) if len(x)>0 else 0, data[0][‘c‘])))
print(context_size)
response_size = max(list(map(lambda x:  max(x) if len(x)>0 else 0, data[0][‘r‘])))
print(response_size)"

# In[8]:

max(data[0][‘r‘][1])

# In[9]:

embedding_dim=64
lstm_dim=64

context_length=np.max(list(map(len, data[0][‘c‘])))
#print(context_length)
response_length=np.max(list( map(len, data[0][‘r‘])))
#print(response_length)

Y = data[0][‘r‘]

print(‘Begin Modeling...‘)

context_size = np.max(list(map(lambda x:  max(x) if len(x)>0 else 0, data[0][‘c‘])))
response_size = max(list(map(lambda x:  max(x) if len(x)>0 else 0, data[0][‘r‘])))
volcabulary_size=max(context_size, response_size)

context_length=120

# 对上下文部分进行嵌入和建模
context=Input(shape=((context_length,)), dtype=‘Int32‘, name=‘context_input‘)
context_embedded=Embedding(input_length=context_length, output_dim=embedding_dim, input_dim=volcabulary_size)(context)
context_lstm=LSTM(lstm_dim)(context_embedded)

# 对回应部分进行嵌入和建模
response_length=120
response=Input(shape=((response_length,)), dtype=‘Int32‘, name=‘response_input‘)
response_embedded=Embedding(input_length=response_length, output_dim=embedding_dim, input_dim=volcabulary_size)(response)
response_lstm=LSTM(lstm_dim)(response_embedded)

print(response_lstm.outputs)

x = Dot([1, 1])([context_lstm, response_lstm])
#x = Multiply()([context_lstm, response_lstm])
yhat = Dense(2, activation=‘softmax‘)(x)

model = Model(inputs=[context, response], outputs=yhat)
model.compile(optimizer=‘rmsprop‘,
              loss=‘binary_crossentropy‘,
              metrics=[‘accuracy‘])
print(‘Finish compiling...‘)
model.summary()

# In[10]:

# 针对该数据定制的generator。一般应该将三个部分分离以后再编制generator

def data_gen(data, batch_size=100):
    contextRaw = data[‘c‘]
    responseRaw = data[‘r‘]
    yRaw = data[‘y‘]

    number_of_batches = len(contextRaw) // batch_size
    counter=0

    context_length=np.max(list(map(len, contextRaw)))//3
    response_length=np.max(list( map(len, responseRaw)))//3

    context_length=120
    response_length=120

    while 1:
        lowerBound = batch_size*counter
        upperBound = batch_size*(counter+1)
        Ctemp = contextRaw[lowerBound : upperBound]
        C_batch = pad_sequences(Ctemp, maxlen=context_length, padding=‘post‘)
        C_res = np.zeros((batch_size, context_length), dtype=np.int)

        Rtemp = responseRaw[lowerBound : upperBound]
        R_batch = pad_sequences(Rtemp, maxlen=response_length, padding=‘post‘)
        R_res = np.zeros((batch_size, response_length), dtype=np.int)
        for k in np.arange(batch_size):
            C_res[k, :] = C_batch[k, :]
            R_res[k, :] = R_batch[k, :]
        y_res= keras.utils.to_categorical(yRaw[lowerBound : upperBound])
        counter += 1
        yield([C_res.astype(‘float32‘), R_res.astype(‘float32‘)], y_res.astype(‘float32‘))
        if (counter < number_of_batches):
            counter=0            

# 下面训练这个模型。在6GB显存的GTX 1060上,小批量的大小不能超过200。读者有时间可以试试多次迭代,看看效果。

# In[11]:

#Y = keras.utils.to_categorical(data[0][‘y‘], num_classes=2)
batch_size=168
model.fit_generator(data_gen(data[0], batch_size=batch_size),
                    steps_per_epoch=len(data[0][‘c‘])//batch_size,
                    validation_data = data_gen(data[1]),
                    validation_steps = len(data[1][‘c‘])//batch_size,
                    epochs=1)

# 下面我们将模型存入磁盘。我们也可以在拟合过程中使用checkponit选项将每一步的结果都分别存入一个磁盘文件中。

# In[12]:

# 将模型结构存为JSON格式
model_json = model.to_json()
with open("dual_lstm_model.json", "w") as json_file:
    json_file.write(model_json)
# 将模型拟合得到的权重存入HDF5文件中
model.save_weights("dual_lstm_model.h5")
print("模型已经写入磁盘")

# In[13]:

# 如果要调用已有模型,可以通过如下方法

# 从磁盘载入模型结构
json_file = open(‘dual_lstm_model.json‘, ‘r‘)
loaded_model_json = json_file.read()
json_file.close()
model = model_from_json(loaded_model_json)
# 从磁盘读入模型权重
model.load_weights("dual_lstm_model.h5")
print("载入模型完毕")
model.compile(optimizer=‘rmsprop‘,
              loss=‘binary_crossentropy‘,
              metrics=[‘accuracy‘])
print(‘模型编译完毕...‘)

# 下面进行预测。输入数据的组织形式应该遵循data generator里面的数据处理和输出组织形式,但是我们可以通过predict_generator方法直接引用现有的data generator,只是用在测试集,而不是训练集上。

# In[14]:

batch_size=256
ypred = model.predict_generator( data_gen(data[2], batch_size=batch_size), steps=(len(data[2][‘c‘])//batch_size), verbose=1)

# In[15]:

yTest = data[1][‘y‘]

ypred2=(2-(ypred[:,0]>ypred[:,1]))-1
z = [str(ypred2[i])==yTest[i] for i in range(len(ypred2))]
np.mean(z)

原文地址:http://blog.51cto.com/12597095/2343037

时间: 2024-10-13 05:07:30

keras快速上手-基于python的深度学习实践-基于索引的深度学习对话模型-源代码的相关文章

学习Keras:《Keras快速上手基于Python的深度学习实战》PDF代码+mobi

有一定Python和TensorFlow基础的人看应该很容易,各领域的应用,但比较广泛,不深刻,讲硬件的部分可以作为入门人的参考. <Keras快速上手基于Python的深度学习实战>系统地讲解了深度学习的基本知识.建模过程和应用,并以深度学习在推荐系统.图像识别.自然语言处理.文字生成和时间序列中的具体应用为案例,详细介绍了从工具准备.数据获取和处理到针对问题进行建模的整个过程和实践经验. <Keras快速上手>PDF,531页,带书签目录,彩色配图,文字可以复制. 配套源代码和

分享《Python 游戏编程快速上手(第3版)》高清中文版PDF+高清英文版PDF+源代码

下载:https://pan.baidu.com/s/1n4hyQq1YFkuLiL2G3388fw 更多资料分享:http://blog.51cto.com/3215120 <Python 游戏编程快速上手(第3版)>高清中文版PDF+高清英文版PDF+源代码高清中文版,带目录和书签,文字能够复制粘贴图.高清英文版,带目录和书签,文字能够复制粘贴.中英文两版对比学习.配套源代码.经典书籍,讲解详细. 其中,高清中文版如图: 原文地址:http://blog.51cto.com/3215120

分享《Keras快速上手:基于Python的深度学习实战(谢梁等)》PDF版+源代码+mobi版

下载:https://pan.baidu.com/s/1u0gYCTbT1I2rq88AFDV3Mg 更多资料:http://blog.51cto.com/14050756 PDF版,531页,带书签目录,彩色配图,文字可以复制粘贴.配套源代码和数据. 系统地讲解了深度学习的基本知识.建模过程和应用,并以深度学习在推荐系统.图像识别.自然语言处理.文字生成和时间序列中的具体应用为案例,详细介绍了从工具准备.数据获取和处理到针对问题进行建模的整个过程和实践经验. 如图: 原文地址:http://b

keras快速上手-基于python的深度学习实践_第8章_文字生成源代码

源代码如下,但质量较差 # -*- coding: utf-8 -*- #!/usr/bin/env python # coding: utf-8 # # 序列模型 # In[1]: import pandas as pd import numpy as np import gc import keras from keras.models import Sequential from keras.models import load_model from keras.layers import

《Python编程快速上手》第7.18.1实践练习

# -*- coding:utf-8 -*- # 7.18.1 # 强口令检测 # 写一个函数,使用正则表达式,确保传入的口令字符串是强口令 # 长度不少于8个字符,同时包含大小写,至少有1个数字 import re passd=input("Input your password:") ch_len=re.compile(r'.{8,}') ch_uppercase=re.compile(r'[A-Z]{1,}') ch_case=re.compile(r'[a-z]{1,}') c

《Python编程快速上手》第7.18.2实践练习

# -*- coding:utf-8 -*- #strip正则表达式 #if 只字符串,不带参数,去首尾空白 #else 去除参数 text=input("Input a text:") import re def st(text): #原样返回检测 textReg=re.compile(r"^\w+$") #前后或前或后,空白检测 blankReg=re.compile(r'^\s+(\w+)\s+$|^\s+(\w+)|(\w+)\s+$') check_bla

《Python编程快速上手》第8.9.3实践练习

#!python3 # -*- coding:utf-8 -*- # 8.9.3 #打开指定路径中所有.txt文件 #用户输入正则,将匹配行输出,输出文件名 import re,os pat=input("输入要处理的文件夹绝对路径:") lis_dir=os.listdir(pat) lis_txt=[] for x in lis_dir: #取出.txt结尾的文件名,加进列表 if re.search(r'\.txt$',x): lis_txt.append(x) text=inp

《Python编程快速上手》第9.8.1实践练习

#!python3 #9.8.1 #遍历目录树,查找特定扩展名的文件(自定义) #and把查找到的文件,copy到新文件夹 import os,shutil file_dir=input("输入要查找的目录:") file_dir=os.path.abspath(file_dir) file_list=[] if not os.path.exists(file_dir): print("目录不存在") else: file_type=input("输入要查

学习《深度学习实践:计算机视觉》PDF+缪鹏

<深度学习实践:计算机视觉>主要介绍了深度学习在计算机视觉方面的应用及工程实践,以Python 3为 开发语言,并结合当前主流的深度学习框架进行实例展示.主要内容包括:OpenCV入门.深度学习框架 介绍.图像分类.目标检测与识别.图像分割.图像搜索以及图像生成等,涉及到的深度学习框架包括 PyTorch.TensorFlow.Keras.Chainer.MXNet等.通过本书,读者能够了解深度学习在计算机视觉各个 方向的应用以及新进展. <深度学习实践:计算机视觉>主要关注计算机