图3.6：吹风机品牌的topsisi得分前十名结果
图3.7：星级与最终结果之间的相关性相关性很大。
然后考虑基于lstm算法的nlp分析的情绪模型以及与最终结果的相关性。结果如图3.12和3.13所示。可以看出，假设检验结果为0.000，相关水平为0.506，相关性很大。考虑到购买数量和与最终结果的相关性，结果如图3.14和3.15所示。可以看出，假设检验结果为0.235，相关水平为-0.104，与相关性很小。4问题一4.1问题分析因为标题要求：基于评分和评论这两个指标，它们具有对阳光影响最大，确定一种数据测量方法。所以考虑这两个
图3.8：星级与最终结果之间的相关性
图3.9：投票星级与最终结果之间的相关性
因素：星级越高，产品越好；评论越好，越好产品; 星级越高，评论越可信。使用的topsis算法第一个问题，给出了三个指数：星级，NLP索引（按textblob）和NLP指数由LSTM。将每个指标的数据引入topsis算法以获得结果，可以用作评分和审查两个指标的数据衡量标准。4.2模型建立与解决方案考虑以下两个因素：星级越高，产品越好；越好评论，产品越好；星级越高，评论越可信。评论和星级是产品，因此两者应保持一致，但现在将有“五星级差评”和“一星肯定评价”，这表示出现了评分和星级。不一致之处。在这种情况下，数据需要进行预处理，并且“五星级差评”和“一星赞”将被删除。在上面的第一个问题中，通过基于textblob的NLP和基于机器学习的lstm
图3.10：投票星级与最终结果之间的相关性图
3.11：基于textblob nlp分析星级评定的情绪与最终结果模型，我们已将产品评论指标转化为数据形式的两个指标：NLP按textblob索引，按LSTM索引NLP。在第一个问题中，考虑了五个指标，包括星级和NLP指数，之后按textblob的NLP指数和按LSTM的NLP指数审查情绪分析。另外两个是我们的预定价格和购买数量。因此，在第一个问题中，考虑了星级和评论评论，并且建立了基于这五个指标的topsis算法模型。但是如果根据标题的含义只能判断产品的好坏通过评级和审查，那么我们仅将topsis算法模型提供给以下三个指标：星级和NLP指数Nemo指数通过textblob，NLP指数通过LSTM进行分析。
下图4.1是topsis算法之后的数据结果排名。
图3.12：基于textblob nlp分析星级评定的情绪与最终结果
5问题b
5.1问题分析b
根据“可以预测或预测的数据”来分析和讨论“基于时间的度量和模式”表示产品的声誉会在市场中增加或减少。”该表在一段时间内具有相关的索引参数，因此请找出产品的数据以相对大量的购买为样本，然后执行拓扑算法分析此样本中的数据以获得结果。数据以图表。
5.2模型建立与解决
我们发现了一种名为“ conair 1875瓦电气石陶瓷吹风机”的产品，该产品从2008年11月8日到2015年8月26日。执行nlp语义情感该产品对n条评论的认可产生了两个指标，textblob给出了NLP指数LSTM的NLP指数。这两个指标，星级评定和四个评判指标作为Topsis算法。按时间顺序对topsis的结果进行排序，然后制作一个图形：水平轴是时间轴（从2008年11月8日到2015年8月26日），垂直轴是topsis的结果。如图5.1、5.2和5.3所示。
6.问题c
介绍了时间序列模型。时间序列模型是用于预测一段时间内变量的变化。AR模型：如果时间序列Xt是其先前值和随机项的线性函数，可以表示为：X 吨 = φ 1 X 叔 1 + φ 2 X 叔 2 + … + φ p X 吨-P + ù 吨（6.1）
图3.13：基于lstm算法的nlp分析情绪之间的相关性模型和最终结果
真正的参数φ 1 ，φ 2 ，…，φ p被称为自回归系数，是一个特殊的估计参数。随机数u t是一系列独立的白噪声，并且服从正态分布，平均的0和的方差σ 2。随意的想法不是与滞后变量有关。MA模型：如果时间序列Xt是其当前误差和先前随机误差的线性函数术语，可以表示为：X 吨 = Ü 吨 - θ 1 Ü 叔 1 - θ 2 ü 叔 2 - … - θ q ü 吨-Q（6.2）真正的参数θ 1 ，θ 2 ，…，θ q是移动平均系数，是成为参数估计。ARMA模型：如果时间序列Xt是其当前和先前随机数的线性函数错误条款和以前的值。表示为：X 吨 = φ 1 X 叔 1 + φ 2 X 叔 2 + … + φ p X 吨-P + ù 吨 - θ 1 Ü 叔 1 - θ 2 ü 叔 2 - … - θ q ù q（6.3）公式（6.3）称为阶（p，q）的自回归平均模型，写为ARMA（p，q）。真正的参数φ 1 ，φ 2 ，…，φ p被称为自回归系数，和θ 1 ，θ 2 ，…，θ q被称为移动平均系数。使用ARMA模型根据当前评级预测未来产品的价值和视图，结果如图所示
图3.14：基于lstm算法的nlp分析情绪之间的相关性模型和最终结果
7问题d
7.1问题分析d
根据先前问题的时间模式，分析是否还会有更多问题在一段时间内集中正面或负面评论。直接使用问题B的时空算法进行分析。找出一条数据，其中topsis算法连续一段时间处于高点和低点，以进行分析数据索引。
7.2模型建立与解决
为了更直观，我们将问题b的时间轴四舍五入以绘制雷达图表，即图5.3。从该图可以直观地看出，对产品在一定时间内会出现高点和低点。随机走入低谷（4月25日，2015年至2015年5月6日）进行分析。如您在2015年4月25日所见，一位客户评论说：“耗尽了大约4个月我买了之后 总可怜。我已经使用Conait吹风机多年了，从没有之前发行。这是一个半身像：-（“，并且打了一颗低星，所以顾客的评价态度稍后更改，导致此期间的TOPSIS RESULT减少。还可以看出，TOPSIS分数的高潮发生在2015年2月25日至2015年3月6日。分析了以下日期的具体数据：您可以看到在此期间，topsisNLP TEXTBLOB，NLP的四个指标LSTM，PRAISE RATE和STAR RATING都在接近最大值的水平，这表明这一时期的商品综合指标非常高。
图3.15：采购数量与最终结果之间的相关性高，并获得好评如潮。
8.问题e
根据问题1中的topsis算法模型，我们可以使用spss查找评分，平均得分和NLP指数之间的相关性（按textblob），NLP指数按LSTM，如下图所示如上图所示，可以看出textblob假设检验结果的NLP指数为0.000，相关水平为0.756。的相关性很大。因此，基于textbolb算法的评论具有很强的与星级之间呈正线性关系。可以看出，LSTM假设检验结果的NLP指数为0.559，相关性水平为-0.051，线性相关性不显着。因此，基于LSTM算法与星级无关紧要的线性关系。
9.给公司的写一封信
尊敬的营销总监
感谢您邀请我们的团队担任您的顾问。我们很荣幸为您服务。对于您的要求和问题，几天后我们的团队就达到了最佳解决方案思考和计算。请花几分钟为您阅读我们的解决方案，希望您很满意。根据公司提供的数据集，我们使用机器学习来分析基于自然语言处理（NLP）的文本，并获得了一些指标来判断产品质量（星级评价，NLP供评论，购买数量，有用的促销注释），在对这些指标建模TOPSIS算法后，获得每种产品。研究这些指标后，我们发现评论和购买
图3.16：采购数量与最终结果之间的相关性
数量指标对于产品最重要；产品评价指标并分析了产品销售的时间点，结果发现口在一定时间内增加或减少，即产品对应于我们在此期间较早研究的这些指标的变化时间的口碑也会改变。产品的声誉直接影响价值产品的质量和质量。希望贵公司的各种评价产品的指标，尤其是用户评论，售出的产品数量以及极端服务端口在一定时间内得到关注。同时，在分析了当前数据，我们可以预测未来几天的数据。也就是说，我们也希望贵公司可以建立商品的预测模型并预测商品中的指标下一个时期。将会发生的事情对于您公司的产品销售非常重要且有用。您忠诚的，你的朋友们
10附录参考文献
[1] Vivek Narayanan，Ishan Arora，Arjun Bhatia，“快速准确的情感分类使用增强的朴素贝叶斯模型。”
[2]黄，CL；Yoon，K.（1981）。多属性决策：方法与应用阳离子。纽约：施普林格出版社。
[3] Yoon，K.（1987）。“不同折衷情况之间的和解”。的杂志运筹学学会。38（3）：277286. doi：10.1057 / jors.1987.44
[4] abc Sepp Hochreiter；JürgenSchmidhuber（1997）。“长期短期记忆”。神经的计算。9（8）：17351780. doi：10.1162 / neco.1997.9.8.1735。PMID 9377276。
[5] Graves，A .；Liwicki，M .；费尔南德斯（S. Bertolami，R .; 邦克，H。Schmidhuber，J.（2009年）。“新型的连接器系统，用于改进无限制的手写识别”（PDF）。IEEE模式分析和机器智能交易。31（5）：855868。CiteSeerX 10.1.1.139.4502。doi：10.1109 / tpami.2008.137。PMID 19299860。
[6] Funnell，Rob（2016年6月13日）。“'Arma Mobile Ops’在新西兰的App Store”。TouchArcade。2016年6月23日检索。
图4.1：topsis算法之后的数据结果排名
图5.1：topsis结果
图5.2：拓扑结果
图5.3：拓扑结果
图6.1：ARMA结果
图6.2：ARMA结果
图7.1：槽分析结果
图7.2：高潮分析结果
图8.1：
图8.2：
图8.3：
图8.4：
代码部分
1.Textblob的NLP语义情感分析
from textblob import TextBlob
text = "Like these for my rentals, but.. had one to quit on me although it's brand new"
blob = TextBlob(text)
print(blob.sentiment)
结果：
Sentiment(polarity=0.13636363636363635, subjectivity=0.45454545454545453)
2.基于LSTM机器学习的NLP语义情感分析
参考：这个网址
import os
os.environ['TF\_CPP\_MIN\_LOG\_LEVEL'] = '2'
import json
import numpy as np
import keras.backend as K
from keras.utils import to_categorical
from keras.preprocessing.text import Tokenizer
from keras.preprocessing import sequence
from keras.models import load_model
from keras.models import Sequential
from keras.layers import Dense, Dropout, Embedding, LSTM, Bidirectional
from textblob import TextBlob
# 1. Loading the data
print("loading data...")
pos_file_name = "pos\_amazon\_cell\_phone\_reviews.json"
neg_file_name = "neg\_amazon\_cell\_phone\_reviews.json"
pos_file = open(pos_file_name, "r")
neg_file = open(neg_file_name, "r")
pos_data = json.loads(pos_file.read())['root']
neg_data = json.loads(neg_file.read())['root']
print("Posititve data loaded. ", len(pos_data), "entries")
print("Negative data loaded. ", len(neg_data), "entries")
print("done loading data...")
plabels = []
nlabels = []
# 2.Process reviews into sentences
pos_sentences, neg_sentences = [], []
for entry in pos_data :
pos_sentences.append(entry['summary'] + " . " + entry['text'])
plabels.append(1)
for entry in neg_data :
nlabels.append(0)
neg_sentences.append(entry['summary'] + " . " + entry['text'])
print(len(pos_sentences))
print(len(neg_sentences))
#
texts = pos_sentences + neg_sentences
labels = [1]\*len(pos_sentences) + [0]\*len(neg_sentences)
print("after app", labels)
# print(type(pos\_sentences), pos\_sentences.shape, type(neg\_sentences), neg\_sentences.shape)
# print(type(texts), texts.shape, type(labels), labels.shape)
# 3. Tokenize
tokenizer = Tokenizer()
tokenizer.fit_on_texts(texts)
'''
根据文本列表更新内部词汇表。
在文本包含列表的情况下，
我们假设列表中的每个条目都是一个标记。
必须在使用' texts\_to\_sequences '或' texts\_to\_matrix '之前。
'''
sequences = tokenizer.texts_to_sequences(texts)
'''
将文本中的每个文本转换为一个整数序列。
整数序列如：the -->1 and -->3
只有“num\_words-1”最常见的单词才会被考虑在内。
只有标记器知道的单词才会被考虑在内。
#参数
文本:文本列表(字符串)。
#返回
序列的列表。
'''
word_index = tokenizer.word_index
# 每个单词出现的次数
print('Found %s unique tokens.' % len(word_index))
# 宏定义 最大序列长度
MAX_SEQUENCE_LENGTH = 50
data = sequence.pad_sequences(sequences, maxlen=MAX_SEQUENCE_LENGTH)
'''
该函数将一个' num\_samples '序列列表(整数列表)转换为一个二维Numpy形状数组' (num\_samples, num\_timesteps) '。
如果提供了' num\_timesteps '，则为' maxlen '参数，否则为最长序列的长度。
'''
print(labels)
labels = np.array(labels)
print('Shape of data tensor:', data.shape)
print('Shape of label tensor:', labels.shape)
# split the data into a training set and a validation set
indices = np.arange(data.shape[0]) #0-shape
np.random.shuffle(indices) #以随机数来给indices赋值
# data和label都打乱
data = data[indices]
labels = labels[indices]
#
rest_data = data[3000:]
rest_labels = labels[3000:]
data = data[:5000]
labels = labels[:5000]
VALIDATION_SPLIT = 0.2 #验证参数
nb_validation_samples = int(VALIDATION_SPLIT \* data.shape[0]) #总样本数\*验证参数
print(data.shape, labels.shape, nb_validation_samples)
print(labels)
x_train = data[:-nb_validation_samples] #取得时候在后面省略 总样本数\*验证参数 这么多个
y_train = labels[:-nb_validation_samples]
x_val = data[-nb_validation_samples:] #只取后面的 总样本数\*验证参数 这么多个
y_val = labels[-nb_validation_samples:]
print(len(x_train), len(y_train))
#
#GloVe
embeddings_index = {} #嵌入的指数
f = open('glove.6B.50d.txt', 'r', encoding = 'utf-8')
for line in f:
values = line.split()
word = values[0] #word
coefs = np.asarray(values[1:], dtype='float32') #value数组
embeddings_index[word] = coefs
f.close()
print('Found %s word vectors.' % len(embeddings_index)) #词条特征向量
EMBEDDING_DIM = MAX_SEQUENCE_LENGTH
embedding_matrix = np.zeros((len(word_index) + 1, EMBEDDING_DIM))
# 嵌入矩阵：（有多少词汇，每个句子有多少词汇--50）
for word, i in word_index.items():
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None:
# words not found in embedding index will be all-zeros.
embedding_matrix[i] = embedding_vector
#
from keras.layers import Embedding
'''
将正整数(索引)转化为固定大小的稠密向量。
如。[[4]， [20]] -> [[0.25, 0.1]， [0.6， -0.2]]
输入，输出，
'''
embedding_layer = Embedding(len(word_index) + 1,
EMBEDDING_DIM,
weights=[embedding_matrix],
input_length=MAX_SEQUENCE_LENGTH,
trainable=False)
def precision(y_true, y_pred): #计算准确率
true_positives = K.sum(K.round(K.clip(y_true \* y_pred, 0, 1)))
predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
precision = true_positives / (predicted_positives + K.epsilon())
return precision
#
def recall(y_true, y_pred): #召回率
true_positives = K.sum(K.round(K.clip(y_true \* y_pred, 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
recall = true_positives / (possible_positives + K.epsilon())
return recall
#
#
# Training the LSTM model
#
batch_size = 128
#
'''
线性叠加层。
#参数
层:要添加到模型中的层的列表。
名称:模型的名称
'''
model = Sequential()
#
'''
在层堆栈的顶部添加一个层实例。
#参数
一层一层:实例。
#提出
类型错误:如果“层”不是一个层实例。
ValueError:在“层”参数没有
知道它的输入形状。
ValueError:在“层”参数有
多个输出张量，或已经连接
其他地方(在“序列”模型中禁止)。
'''
model.add(embedding_layer)
#
model.add(LSTM(64))
#
'''
”“将Dropout应用于输入。
辍学包括随机设置
在训练期间的每次更新中，输入单位的分数“比率”为0，
这有助于防止过度拟合。
＃参数
速率：在0到1之间浮动。要降低的输入单位的分数。
noise\_shape：一维整数张量，表示
二进制丢弃掩码，它将与输入相乘。
例如，如果您的输入具有形状
（（batch\_size，时间步长，功能）和
您希望所有时间步长的辍学面具都一样，
您可以使用`noise\_shape =（batch\_size，1，features）`。
seed：用作随机种子的Python整数。
＃参考
-[Dropout：防止神经网络过度拟合的简单方法]（
http://www.jmlr.org/papers/volume15/srivastava14a/srivastava14a.pdf）
“”
'''
model.add(Dropout(0.50))
#
model.add(Dense(1, activation='sigmoid'))
#
# try using different optimizers and different optimizer configs
# 尝试使用不同的优化器和不同的优化器配置
model.compile('adam', 'binary\_crossentropy', metrics=['accuracy', precision, recall])
print('Train...')
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=16,
validation_data=[x_val, y_val])
x = model.evaluate(rest_data[:5000], rest_labels[:5000])
model.compile(optimizer='adam', loss='categorical\_crossentropy', metrics=['accuracy', precision, recall])
# model.save("model.hdf5")
#
print("Loss: ", x[0])
print("Accuracy: ", x[1])
print("Precision: ", x[2])
print("Recall: ", x[3])
input_text = "I like this dryer but it is a little bit larger than I wanted. Work really well and is not too loud."
# token = Tokenizer(num\_words=2000)
# token.fit\_on\_texts(train\_text)
#将影评转化为数字列表
input_seq = tokenizer.texts_to_sequences([input_text])#将影评转化为数字列表
#进行取长补短操作
pad_input_seq = sequence.pad_sequences(input_seq , maxlen=50)#进行取长补短操作
predict_result=model.predict_classes(pad_input_seq)#放入模型进行分析
print(predict_result)
model部分的结果，以及识别预测结果
Loss: 0.2165962651014328
Accuracy: 0.9152
Precision: 0.9188494445800781
Recall: 0.9928984497070312
[[1]]
这里训练模型要用到：
亚马逊的评论数据集（含手工标注5w条评论的情感值）＋GLOVE语义情感数据库。
- 以下为识别新句子：
input_text = "I love this hair dryer;Nevertheless, I still highly recommend it and would buy it again."
model = load_model("model.hdf5",custom_objects={'precision': precision,'recall':recall})
sequences = tokenizer.texts_to_sequences(input_text)
print(sequences)
word_index = tokenizer.word_index
print('Found %s unique tokens.' % len(word_index))
data = sequence.pad_sequences(sequences, maxlen=MAX_SEQUENCE_LENGTH)#取长补短操作
print(data)
print('Shape of data tensor:', data.shape)
result=model.predict_classes(data)#放入模型进行分析
print(result)
TOPSIS模型的Python实现
import numpy as np
import xlrd
import pandas as pd
# 从excel文件中读取数据
def read(file):
wb = xlrd.open_workbook(filename=file) # 打开文件
sheet = wb.sheet_by_index(0) # 通过索引获取表格
rows = sheet.nrows # 获取行数
all_content = [] # 存放读取的数据
# title star blob rnn h/t verified\_purchase
for j in [5, 7, 8, 10, 13, 13]: # 取第1~第4列对的数据
temp = []
for i in range(1, rows):
cell = sheet.cell_value(i, j) # 获取数据
temp.append(cell)
all_content.append(temp) # 按列添加到结果集中
temp = []
return np.array(all_content)
# 极小型指标 -> 极大型指标
def dataDirection\_1(datas):
return np.max(datas) - datas # 套公式
# 中间型指标 -> 极大型指标
def dataDirection\_2(datas, x_best):
temp_datas = datas - x_best
M = np.max(abs(temp_datas))
answer_datas = 1 - abs(datas - x_best) / M # 套公式
return answer_datas
# 区间型指标 -> 极大型指标
def dataDirection\_3(datas, x_min, x_max):
M = max(x_min - np.min(datas), np.max(datas) - x_max)
answer_list = []
for i in datas:
if (i < x_min):
answer_list.append(1 - (x_min - i) / M) # 套公式
elif (x_min <= i <= x_max):
answer_list.append(1)
else:
answer_list.append(1 - (i - x_max) / M)
return np.array(answer_list)
# 正向化矩阵标准化
def temp2(datas):
K = np.power(np.sum(pow(datas, 2), axis=1), 0.5)
for i in range(0, K.size):
for j in range(0, datas[i].size):
datas[i, j] = datas[i, j] / K[i] # 套用矩阵标准化的公式
return datas
# 计算得分并归一化
def temp3(answer2):
list_max = np.array(
[np.max(answer2[0, :]), np.max(answer2[1, :]), np.max(answer2[2, :]),
]) # 获取每一列的最大值
list_min = np.array(
[ np.min(answer2[0, :]), np.min(answer2[1, :]), np.min(answer2[2, :]),
]) # 获取每一列的最小值
max_list = [] # 存放第i个评价对象与最大值的距离
min_list = [] # 存放第i个评价对象与最小值的距离
answer_list = [] # 存放评价对象的未归一化得分
for k in range(0, np.size(answer2, axis=1)): # 遍历每一列数据
max_sum = 0
min_sum = 0
for q in range(0, 3): # 有四个指标
max_sum += np.power(answer2[q, k] - list_max[q], 2) # 按每一列计算Di+
min_sum += np.power(answer2[q, k] - list_min[q], 2) # 按每一列计算Di-
max_list.append(pow(max_sum, 0.5))
min_list.append(pow(min_sum, 0.5))
answer_list.append(min_list[k] / (min_list[k] + max_list[k])) # 套用计算得分的公式 Si = (Di-) / ((Di+) +(Di-))
max_sum = 0
min_sum = 0
answer = np.array(answer_list) # 得分归一化
return (answer / np.sum(answer))
def main(file, problem_result, problem_data):
answer1 = read(file) # 读取文件
# title star sentiment rnn-sentiment h/t verified\_purchase
delete_data = 0
shape = answer1.shape[1]
for i in range(shape):
a = float(answer1[1][i - delete_data]) == 5
b = float(answer1[2][i - delete_data]) < 0
c = float(answer1[3][i - delete_data]) == 0
d = float(answer1[1][i - delete_data]) == 1
e = float(answer1[2][i - delete_data]) > 0
f = float(answer1[3][i - delete_data]) == 1
print(str(a) + " " + str(b) + " " + str(c) + " " + str(d) + " " + str(e) + " " + str(f))
# if answer1[5][i - delete\_data] == "Y":
# answer1[5][i - delete\_data] == 1
# if answer1[5][i - delete\_data] == "N":
# answer1[5][i - delete\_data] == 0
if a == True and b == True and c == True:
print("Deleting number:" + str(delete_data) + " wrong data.............................")
for n in range(5):
if n == 0:
print("product\_title is :" + answer1[n, i - delete_data])
if n == 1:
print("rating\_star is :" + answer1[n, i - delete_data])
if n == 2:
print("sentiment is :" + answer1[n, i - delete_data])
if n == 3:
print("rnn-lstm-sentiment is :" + answer1[n, i - delete_data])
if n == 4:
print("helpful comments/total coments is :" + answer1[n, i - delete_data])
# if n == 5:
# print("verified\_purchase is :" + answer1[n,i])
answer1 = np.delete(answer1, i - delete_data, axis=1)
delete_data = delete_data + 1
if d == True and e == True and f == True:
print("\nDeleting number:" + str(delete_data) + " wrong data.............................")
for n in range(6):
if n == 0:
print("product\_title is :" + answer1[n, i - delete_data])
if n == 1:
print("rating\_star is :" + answer1[n, i - delete_data])
if n == 2:
print("sentiment is :" + answer1[n, i - delete_data])
if n == 3:
print("rnn-lstm-sentiment is :" + answer1[n, i - delete_data])
if n == 4:
print("helpful comments/total coments is :" + answer1[n, i - delete_data])
# if n == 5:
# print("verified\_purchase is :" + answer1[n, i])
answer1 = np.delete(answer1, i - delete_data, axis=1)
delete_data = delete_data + 1
title = "null"
star = 0
sentiment = 0
rnn_sentiment = 0
helpful_comments = 0
n = 0 # array number
purchase_count = 0
array = answer1
array1 = answer1[0]
for i in range(answer1.shape[1]):
purchase_count = purchase_count + 1
# print("star is " + str(star) + "\n")
star = star + float(answer1[1, i])
sentiment = sentiment + float(answer1[2, i])
rnn_sentiment = rnn_sentiment + float(answer1[3, i])
helpful_comments = float(answer1[4, i])
if title != answer1[0][i]:
print("\nnumber: " + str(n) + " product")
title = answer1[0][i]
array[5][n] = purchase_count
array[1][n] = star / purchase_count
array[2][n] = sentiment / purchase_count
array[3][n] = rnn_sentiment / purchase_count
array[4][n] = helpful_comments / purchase_count
array[0][n] = title
print("star is " + str(star) + " sentiment is " + str(sentiment) + " rnn sentiment is " + str(
rnn_sentiment) + " h is " + str(helpful_comments))
print("title " + str(title) + "\nstar/count " + str(star / purchase_count) + "\nsentiment/count " + str(
sentiment / purchase_count) + "\nrnn\_sentiment/count " + str(
rnn_sentiment / purchase_count) + "\nhelpful\_comments/count:" + str(
helpful_comments / purchase_count) + "\npurchase\_count:" + str(purchase_count))
star = 0
sentiment = 0
rnn_sentiment = 0
helpful_comments = 0
purchase_count = 0
n = n + 1
# array = np.c\_[array,array1[0].T]
print(array[0][490])
print(array[1][490])
print(array[2][490])
print(array[3][490])
print(array[4][490])
print(array[5][490])
# print(array[6][490])
answer1 = array
answer2 = []
for i in range(1, 4): # 按照不同的列，根据不同的指标转换为极大型指标，因为只有四列
answer = None
if i == 1: # 本来就是极大型指标，不用转换
answer = answer1[i].astype(float)
elif i == 2: # 范围型指标
answer = dataDirection_3(answer1[i].astype(float), 0.0, 1.0)
elif i == 3:
answer = answer1[i].astype(float)
# elif i == 4:
# answer = answer1[i].astype(float)
# elif i == 5:
# answer = answer1[i].astype(float)
# elif i == 5:
# answer = answer1[i].astype(float)
answer2.append(answer)
print()
for i in range(3):
print(answer2[i][36])
answer2 = np.array(answer2) # 将list转换为numpy数组
answer3 = temp2(answer2) # 数组正向化
answer4 = temp3(answer3) # 标准化处理去钢
data = pd.DataFrame(answer4) # 计算得分
array = array.T
data2 = pd.DataFrame(array)
print()
for i in range(6):
print(answer1[i][36])
print()
for i in range(3):
print(answer2[i][36])
print()
for i in range(3):
print(answer3[i][36])
print()
print(answer4[36])
# 将得分输出到excel表格中
writer = pd.ExcelWriter(problem_result
) # 写入Excel文件
data.to_excel(writer, 'page\_1') # ‘page\_1’是写入excel的sheet名
writer.save()
writer.close()
writer2 = pd.ExcelWriter(problem_data
) # 写入Excel文件
data2.to_excel(writer2, 'page\_1') # ‘page\_1’是写入excel的sheet名
writer2.save()
writer2.close()
return 1
print(main('pacifier\_problem1.xlsx', 'result\_pacifier\_problem1.xlsx', 'data\_pacifier\_problem1.xlsx'))
print(main('hair\_dryer\_problem1.xls', 'result\_hair\_dryer.xlsx', 'data\_hair\_dryer.xlsx'))
print(main('microwave\_problem1.xls', 'result\_microwave.xlsx', 'data\_microwave.xlsx'))
4.分析单个商品的TOPSIS评价结果和时间的关系
import numpy as np
import xlrd
import pandas as pd
# 从excel文件中读取数据
def read(file):
wb = xlrd.open_workbook(filename=file) # 打开文件
sheet = wb.sheet_by_index(0) # 通过索引获取表格
rows = sheet.nrows # 获取行数
all_content = [] # 存放读取的数据
# star blob rnn h/t date
for j in [2, 3, 5, 8, 11, 9 , 10]: # 取第1~第4列对的数据
temp = []
for i in range(1, rows):
cell = sheet.cell_value(i, j) # 获取数据
temp.append(cell)
all_content.append(temp) # 按列添加到结果集中
temp = []
return np.array(all_content)
# 极小型指标 -> 极大型指标
def dataDirection\_1(datas):
return np.max(datas) - datas # 套公式
# 中间型指标 -> 极大型指标
def dataDirection\_2(datas, x_best):
temp_datas = datas - x_best
M = np.max(abs(temp_datas))
answer_datas = 1 - abs(datas - x_best) / M # 套公式
return answer_datas
# 区间型指标 -> 极大型指标
def dataDirection\_3(datas, x_min, x_max):
M = max(x_min - np.min(datas), np.max(datas) - x_max)
answer_list = []
for i in datas:
if (i < x_min):
answer_list.append(1 - (x_min - i) / M) # 套公式
elif (x_min <= i <= x_max):
answer_list.append(1)
else:
answer_list.append(1 - (i - x_max) / M)
return np.array(answer_list)
# 正向化矩阵标准化
def temp2(datas):
K = np.power(np.sum(pow(datas, 2), axis=1), 0.5)
for i in range(0, K.size):
for j in range(0, datas[i].size):
datas[i, j] = datas[i, j] / K[i] # 套用矩阵标准化的公式
return datas
# 计算得分并归一化
def temp3(answer2):
list_max = np.array(
[np.max(answer2[0, :]), np.max(answer2[1, :]), np.max(answer2[2, :]), np.max(answer2[3, :])
]) # 获取每一列的最大值
list_min = np.array(
[ np.min(answer2[0, :]), np.min(answer2[1, :]), np.min(answer2[2, :]), np.max(answer2[3, :])
]) # 获取每一列的最小值
max_list = [] # 存放第i个评价对象与最大值的距离
min_list = [] # 存放第i个评价对象与最小值的距离
answer_list = [] # 存放评价对象的未归一化得分
for k in range(0, np.size(answer2, axis=1)): # 遍历每一列数据
max_sum = 0
本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。
最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。
最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！下面就开始进入正题，如何从一个萌新一步一步进入网络安全行业。
### 学习路线图
其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。
相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。
#### 网络安全工具箱
当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份**我自己整理的网络安全入门工具以及使用教程和实战。**
#### 项目实战
最后就是项目实战，这里带来的是**SRC资料&HW资料**，毕竟实战是检验真理的唯一标准嘛~
#### 面试题
归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友，可以点击这里获取](https://bbs.csdn.net/topics/618540462)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
