【推荐系统】基于文本挖掘的推荐模型【含基于CNN的文本挖掘、python代码】

import pandas as pd
import numpy as np
import jieba
import gensim
import tqdm
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras import models
import random
from gensim.models import Word2Vec
def data_processing():
    array = pd.read_csv("  ", header=None)
    np_array = np.array(array)
    mid=round(len(np_array)/1000)
    print(mid)
    print(999 * (mid + 1))
    test_star=np_array[1:mid,7]
    train_star=np_array[999*(mid+1):,7]
    train_star = keras.utils.to_categorical( train_star, num_classes=10)
    test_star = keras.utils.to_categorical( test_star, num_classes=10)
    test_comment=np_array[1:mid,8]
    train_comment=np_array[999*(mid+1):,8]
    return test_comment,test_star,train_comment,train_star
#分词
def get_separate_words(data):
    seqlist=jieba.cut(data,cut_all  = False)
    seqlist=list(seqlist)
    seqlist= seqlist + [0] * (177 - len(seqlist))
    # print(list(seqlist))
    # print(','.join(seqlist))
    return seqlist
#创建分词向量
def create_segmentation_vector(data):
    separate_words_list = []
    words_vector_list=[]
    # max=0
    for k in range(len(data)):
        separate_words_list.append(get_separate_words(data[k]))
        # if len(get_separate_words(data[k]))>max:
        #     max=len(get_separate_words(data[k]))
        # print(separate_words_list)
    word=Word2Vec(separate_words_list, min_count=1, vector_size=8)
    for j in range(len(separate_words_list)):
            k=word.wv[separate_words_list[j]]
            op=[]
            for t1 in k:
                tem=[]
                for t2 in t1:
                    tem.append(float(t2))
                op.append((tem.copy()))
            word_vector=op
            words_vector_list.append([word_vector])
        # print(words_vector_list)
    return words_vector_list,max

# 模型
def cnn(X_train,Y_train,X_test,Y_test):
    X_train = np.array(X_train)
    X_train = X_train.reshape(X_train.shape[0], 177, 8, 1)
    Y_train = np.array(Y_train)
    Y_test= np.array(Y_test)
    X_test = np.array(X_test)
    X_test= X_test.reshape(X_test.shape[0], 177, 8, 1)
    print('开始卷积')
    # 定义模型Sequential 序贯模型。序贯模型是线性、从头到尾的结构顺序，不分叉，是多个网络层的线性堆叠
    model = models.Sequential()
    # # 向模型中添加层
    # 【Conv2D】
    # 构建卷积层。用于从输入的高维数组中提取特征。卷积层的每个过滤器就是一个特征映射，用于提取某一个特征，
    # 过滤器的数量决定了卷积层输出特征个数，或者输出深度。
    # 因此，图片等高维数据每经过一个卷积层，深度都会增加，并且等于过滤器的数量
    model.add(layers.Conv2D(1, kernel_size=(8,8),  # 添加卷积层，深度1，过滤器大小8*8
                            activation='relu',  # 使用relu激活函数
                            input_shape=(177,8,1)))   # 输入的尺寸
    model.add(layers.MaxPooling2D(pool_size=(170, 1)))    # 添加池化层，过滤器大小是170*1
    model.add(layers.Conv2D(64, (1,1), activation='relu'))  # 添加卷积层
    model.add(layers.MaxPooling2D(pool_size=(1, 1)))    # 添加池化层
    model.add(layers.Flatten())     # 将池化层的输出拉直，然后作为全连接层的输入
    model.add(layers.Dense(500, activation='relu'))     # 添加有500个结点的全连接层，激活函数用relu
    model.add(layers.Dense(10, activation='softmax'))   # 输出最终结果，有10个，激活函数用softmax
    # 定义损失函数、优化函数、评测方法
    #  model.compile()方法用于在配置训练方法时，告知训练时用的优化器、损失函数和准确率评测标准
    #  model.compile(optimizer = 优化器，loss = 损失函数，metrics = ["准确率”])

    # 多分类损失函数categorical_crossentropy
    # 优化器采用SGD随机梯度下降算法
    model.compile(loss=keras.losses.categorical_crossentropy,

                  optimizer=keras.optimizers.SGD(),
                  metrics=['accuracy'])


    # 自动完成模型的训练过程
    # model.fit()方法用于执行训练过程
    # model.fit( 训练集的输入特征，训练集的标签，
    #             batch_size,  #每一个batch的大小
    #             epochs,   #迭代次数
    #             validation_data = (测试集的输入特征，测试集的标签），
    #             validation_split = 从测试集中划分多少比例给训练集，
    #             validation_freq = 测试的epoch间隔数）
    model.fit(X_train, Y_train,   # 训练集
              batch_size=128,   # batchsize
              epochs=3,    # 训练轮数
              validation_data=(X_test, Y_test))   # 验证集
    score = model.evaluate(X_test, Y_test)
    print('Test loss:', score[0])
    print('Test accuracy:', score[1])

    customization_good = np.array(['这是一个非常好电影'])
    k=create_segmentation_vector(customization_good)
    k = np.array(k[0])
    k = k.reshape(k.shape[0], 177, 8, 1)
    predict1 = model.predict(k)
    # print(predict1)
    print('评论:这是一个非常好电影\n评分为')
    print(np.argmax(predict1))

    customization_bad=['这是差劲烂片']
    k = create_segmentation_vector(customization_bad)
    k = np.array(k[0])
    k = k.reshape(k.shape[0], 177, 8, 1)
    predict2 = model.predict(k)
    print('评论:这是差劲烂片\n评分为')
    print(np.argmax(predict2))