关键词权重这一因素也常常被商家们所提起，它是我们在运营店铺时需要去考虑的一个关键性的因素。如果要给宝贝取标题也是关乎权重的，那么拼多多关键词权重是什么?如何拼多多关键词权重提高?

　　关键词权重指的是某个关键词的综合排名指数。关键词权重是影响你商品排名的关键，如果你的这个商品排名太过落后，那就可惜了，连展示的机会都没有了。

　　同时也是也是搜索引擎里面的关键依据。可以说是无权重，无排名。产品高权重的话，那你肯定就是高排名;相反，那些没有权重的商品，连在搜索引擎里都搜不到，更何况还在搜索前列。

　　如何提高?

　　1、拼多多选款应该要放在首位，我们要根据数据的反馈，什么种类的商品好卖，然后再结合着市场的流行元素来进行选款。

　　2、基础优化应该要放在其次，商家想要有流量，就必须要做好优化标题，主图和详情页等，因为标题决定了商品关键词的排名和要面对的人群，主图则决定着商家的流量，假设商家的主图没有做好，就算位置好了也会没有人点击查看的，这样的时间一但持续过久，排名就会被别人挤下去了，最后详情页也是会影响买家的支付转化率的，同时也可以避免与买家的不必要纠纷，所以这方面的优化要做好。

　　3、就是商家的运营方式了，商家们可以选择两到三款，一个做爆款，另外的可以作为辅助款，一但爆款有问题了我们还可以有辅助款顶上去，这样的话店铺也不会一下子就垮下来，这也是每个平台的趋势，不管哪个平台，考验的还是店铺的综合运营能力。

词频

语言材料中词的使用频率

在新词发现、热词发现等场景，词频越高，权重越高。

词频统计可以按 句子级、 段落级、 篇章级等

篇章级，词在整篇文章中，没出现算零次，出现了算一次
句子级，词在整个句子中，没出现算零次，出现了算一次
最细级，出现多少次就算多少次

TFIDF

TF（Term Frequency）：词频
$TF=\frac{该词频数}{文档词语总数}$

IDF（Inverse Document Frequency）：逆文本频率指数
$IDF=\log (\frac{文档总数}{出现该词文档数+1})$

TFIDF缺点

1. 文档类型单一时，IDF将失去意义。例如，语料都是汽车主题，理应获得更高权重的汽车相关术语的IDF反而不高
2. 在具有时效性的文本中，网络热词会阶段性频繁出现，这些热词理应要有较高权重，但阶段性IDF赋予的权重反而较低。

from collections import Counter
from math import log10
from re import split
from jieba.posseg import dt
FLAGS = set('a an b f i j l n nr nrfg nrt ns nt nz s t v vi vn z eng'.split())

def cut(text):
    for sentence in split('[^a-zA-Z0-9\u4e00-\u9fa5]+', text.strip()):
        for w in dt.cut(sentence):
            if len(w.word) > 1 and w.flag in FLAGS:
                yield w.word

class TFIDF:
    def __init__(self):
        self.idf = None
        self.idf_max = None

    def fit(self, texts):
        texts = [set(cut(text)) for text in texts]
        lent = len(texts)
        words = set(w for t in texts for w in t)
        self.idf = {w: log10(lent/(sum((w in t)for t in texts)+1)) for w in words}
        self.idf_max = log10(lent)
        return self

    def get_idf(self, word):
        return self.idf.get(word, self.idf_max)

    def extract(self, text, top_n=10):
        counter = Counter()
        for w in cut(text):
            counter[w] += self.get_idf(w)
        return [i[0] for i in counter.most_common(top_n)]

tfidf = TFIDF().fit(['奶茶', '巧克力奶茶', '巧克力酸奶', '巧克力', '巧克力']*2)
print(tfidf.extract('酸奶巧克力奶茶'))

词在文中位置

下面提供两种位置权重

粗粒度

细粒度

"""https://blog.csdn.net/Yellow_python/article/details/104580509"""
from sklearn.gaussian_process import GaussianProcessRegressor
from jieba import lcut

X = [[0], [.1], [.2], [.3], [.4], [.5], [.6], [.7], [.8], [.9], [1]]
Y = [[1], [.2], [.04], [.02], [.01], [0], [0], [.01], [.03], [.1], [.5]]

class GPR:
    """高斯过程回归"""
    def __init__(self):
        self.model = GaussianProcessRegressor()
        self.model.fit(X, Y)

    def predict(self, position):
        return self.model.predict([[position]])[0]

    def extract(self, text, judge):
        words = lcut(text)
        le = len(words) - 1
        entities = [(self.predict(i/le)[0], words[i]) for i in range(le+1) if judge(words[i])]
        return entities

def visualization():
    from matplotlib import pyplot as mp
    w = [[i / 500] for i in range(501)]
    z = GPR().model.predict(w)
    mp.scatter(X, Y, s=66, color='g')
    mp.scatter(w, z, s=6, color='r')
    mp.show()

"""实体抽取并返回权重"""
print(GPR().extract('剑圣联合守望者斩杀大法师', lambda x: x in {'剑圣', '大法师', '守望者'}))
"""权重分布可视化"""
visualization()

示例句子：剑圣联合守望者斩杀大法师

文章总长度

文章越长，单个词对文章的贡献值越低。下面提供几个公式：

词长

下面提供两种词长权重

词跨度

词频=1时，权重=1；
词频>1时，下面提供两种词跨度权重

简单版
$权重=1+\frac{尾词位置-首词位置}{总长}$

复杂版
$权重={\prod }_{i=1}^{n-1}(1+\frac{词位{置}_{i+1}-词位{置}_i}{总长})$

def span1(text):
    """词跨度 + 词频"""
    words = list(text)  # 分词并返回列表，此处暂时用list
    reversed_words = words[::-1]
    le = len(words)
    return {w: 2-((words.index(w)+reversed_words.index(w)+1)/le) for w in set(words)}

def span2(text):
    c, position = dict(), dict()
    words = list(text)  # 分词并返回列表，此处暂时用list
    length = len(words)
    for i in range(length):
        word = words[i]
        if word not in c:
            c[word] = 1
        else:
            c[word] *= 1 + ((i - position[word]) / length)
        position[word] = i
    return c

_text = '清水水水水水水水里清'
print(span1(_text))
print(span2(_text))

句子示例：清水水水水水水水里清

词性

通常，实词>虚词，名词权重较高。
对于如何设定权重值，我们可以找些标注数据来建立一个词性权重模型。

词与主题的关系

给予主题相关的词更高的权重

例如，文中【车主打开车盖，用苹果照了一下水箱】句子属于【汽车主题】，同为名词的【水箱】权重要比【苹果】高。

from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfVectorizer
from re import split
from jieba import cut
from collections import Counter
from numpy import argmax
from pandas import DataFrame

def segment(text):
    for phrase in split('[^a-zA-Z\u4e00-\u9fa5]+', text.strip()):
        for word in cut(phrase):
            yield word

def clf_word(texts, labels, clf=MultinomialNB()):
    """词分类，逻辑回归，存EXCEL"""
    # 向量化
    vectorizer = TfidfVectorizer(tokenizer=segment)
    x = vectorizer.fit_transform(texts)
    # 建模
    clf.fit(x, labels)
    classes = clf.classes_
    print(clf.__class__.__name__, clf.score(x, labels), *classes)
    # 词分类
    c = Counter(w for t in texts for w in segment(t)).most_common()
    ls = []
    for word, freq in c:
        predict_proba = clf.predict_proba(vectorizer.transform([word]))[0]  # 概率
        label = classes[argmax(predict_proba)]  # 类别
        ls.append([freq, word, label, *predict_proba])
    df = DataFrame(ls, columns=['freq', 'word', 'label', *classes])
    df.to_excel('a.xlsx', index=False)  # 存excel

if __name__ == '__main__':
    from data9 import X, Y  # 导入新闻9分类语料
    clf_word(X, Y)

否定句

在特定否定语境中，关键词权重要变零

例句：大力发展智能冰箱、智能空调、智能热水器等高新技术（不含智能手机和智能电视）
抽出实体及其权重：【智能冰箱：2】【智能空调：2】【智能热水器：2】【智能手机：-1】【智能电视：-1】

{'不包含': -1, '不包括': -1, '不含': -1, '除外': -1, '包含': 1, '包括': 1}
re.compile(r'(?<![无没])不[^a-zA-Z\W\d_限无没]|除外')

自然衰减权重

• 出现某些特定词时，特定词后（可能跨句甚至跨段）的单词权重提高，并自然衰减

以下情况不列入支持
1、XXXXXXXX
2、XXXXXXXX

申请人条件如下：
1、XXXXXXXX
2、XXXXXXXX

from matplotlib import pyplot as mp
# 特定词
x2y = {'b': 20, 'c': 10, 'd': 30}
# 造数据
length = 100
x = ['a'] * length
x[15], x[30], x[75] = 'b', 'c', 'd'
# 计算权重
y = [0] * length
for i in range(length):
    if x[i] in x2y:
        weight = x2y[x[i]]
        for j in range(i + 1, length):
            y[j] += max(0, weight - abs(i - j))
mp.plot(y)
mp.show()

TextRank

from collections import defaultdict
from jieba.posseg import dt

ALLOW_POS = frozenset(('ns', 'n', 'vn', 'v'))


class WeightedUndigraph:
    d = 0.85

    def __init__(self):
        self.graph = defaultdict(list)

    def add_edge(self, start, end, weight):
        self.graph[start].append((start, end, weight))
        self.graph[end].append((end, start, weight))

    def rank(self):
        ws = defaultdict(float)
        outSum = defaultdict(float)

        wsdef = 1.0 / (len(self.graph) or 1.0)
        for n, out in self.graph.items():
            ws[n] = wsdef
            outSum[n] = sum((e[2] for e in out), 0.0)

        for x in range(10):  # 10次迭代
            for n in sorted(self.graph.keys()):  # 排序更稳定
                s = 0
                for e in self.graph[n]:
                    s += e[2] / outSum[e[1]] * ws[e[1]]
                ws[n] = (1 - self.d) + self.d * s

        min_rank, max_rank = min(ws.values()), max(ws.values())
        for n, w in ws.items():
            ws[n] = (w - min_rank / 10.0) / (max_rank - min_rank / 10.0)  # 统一权重，无需乘以100
        return ws


class TextRank:
    def __init__(self):
        self.tokenizer = dt
        self.allow_pos = ALLOW_POS
        self.span = 5

    def flag_filter(self, wp):
        return (wp.flag in self.allow_pos) and (len(wp.word.strip()) >= 2)

    def text_rank(self, sentence, n=20, with_weight=False, allow_pos=ALLOW_POS, with_flag=False):
        """
        Parameter:
            - n: 返回关键词数量
            - with_weight: 是否返回权重
            - allow_pos: 允许的词性
            - with_flag: 是否返回词性
        """
        self.allow_pos = frozenset(allow_pos)
        g = WeightedUndigraph()
        cm = defaultdict(int)
        words = tuple(self.tokenizer.cut(sentence))
        for i, wp in enumerate(words):
            if self.flag_filter(wp):
                for j in range(i + 1, i + self.span):
                    if j >= len(words):
                        break
                    if not self.flag_filter(words[j]):
                        continue
                    if allow_pos and with_flag:
                        cm[(wp, words[j])] += 1
                    else:
                        cm[(wp.word, words[j].word)] += 1
        for terms, w in cm.items():
            g.add_edge(terms[0], terms[1], w)
        nodes_rank = g.rank()
        if with_weight:
            tags = sorted(nodes_rank.items(), key=lambda x: x[1], reverse=True)
        else:
            tags = sorted(nodes_rank, key=nodes_rank.__getitem__, reverse=True)
        return tags[:n] if n else tags


_t = '越来越多的国产汽车出现在大众的眼中，国产汽车的整体性能也在不断优化，但和老牌的欧美汽车相比还存在着一定的差距'
print(TextRank().text_rank(_t, with_weight=True, with_flag=True))

内联权重

聚类排除离群点

待开发

上下文特征向量

待开发

最尾补充一些失败实验

失败1：
尝试用词向量分布的离散程度来计算权重但失败，结果如下：
高频词向量[5 5 5 5 5 5 0 -5 -5 -5]离散程度高
中频词向量[4 3 3 3 3 3 0 -3 -3 -3]离散程度中
低频词向量[3 1 1 1 1 1 0 -1 -1 -1]离散程度低

from re import split, fullmatch
from gensim.models import Word2Vec
from jieba import cut
from numpy import var
from pandas import DataFrame

def lcut(text):
    return [w for s in split('[\n。…；;!！?？]+', text)for w in cut(s)if fullmatch('[a-zA-Z\u4e00-\u9fa5]+', w)]

def word2vector(texts):
    """词向量建模"""
    sentences = [lcut(t) for t in texts]
    wv = Word2Vec(sentences, size=75, window=10, sg=1).wv
    DataFrame([(w, var(wv[w]), *wv[w]) for w in wv.index2word], columns=[
        'word', 'weight', *(str(i) for i in range(75))]).to_excel('b.xlsx', index=False)

from data9 import X  # 新闻9分类，不导入标签
word2vector(X)

失败2：
词特征分布的离散程度：特征分布离散程度越高的词，权重应更高。
例如，两个IDF相同的词，第一个词集中分布在某类文档中，第二个词分散在不同类型的文档中，则第一个词的权重理应更高。

尝试用长文切短的主题模型来获取单词的主题分布离散程度，但结果失败，多数单词主题分布匀散，某些停词反而具有更为集中的主题分布。

from gensim import corpora, models
import re, jieba, numpy as np, pandas as pd

def word_lda(texts, num_topics=50):
    # 分词
    words_ls = [[w for w in jieba.cut(s) if re.fullmatch('[a-zA-Z\u4e00-\u9fa5]+', w)]
                for t in texts for s in re.split('[\n。…；;!！?？]+', t)]
    # 构造词典
    dictionary = corpora.Dictionary(words_ls)
    # 基于词典，使【词】→【稀疏向量】，并将向量放入列表，形成【稀疏向量集】
    corpus = [dictionary.doc2bow(words) for words in words_ls]
    # lda模型，num_topics设置主题的个数
    lda = models.ldamodel.LdaModel(corpus=corpus, id2word=dictionary, num_topics=num_topics)
    # 主题概率矩阵
    matrix = lda.state.get_lambda()
    matrix = matrix / np.sum(matrix, axis=0)
    # 按照主题概率聚类，并存excel
    pd.DataFrame({
        'word': [dictionary[i] for i in range(len(dictionary))],
        'topic': np.argmax(matrix, axis=0),
        'probability': np.max(matrix, axis=0),
    }).sort_values(by=['topic', 'probability'], ascending=False).to_excel('word_lda.xlsx', index=False)

from data9 import X  # 新闻9分类，不导入标签
word_lda(X)

TF（Term frequency）-词频，IDF（Inverse document frequency）-逆文本频率

TF-IDF是一种度量关键词权重的方法。主要的应用场景：（1）搜索（2）关键词提取（可用于文本分类）

刚开始的时候利用的是词频来确定关键词的权重，即 词语在语料库中出现的频率。

记作                                                                 

关键词w出现的次数除以语料库中单词总个数。

但是这种方法有一个问题，就是像“的”这种词，出现的频率特别高，但是对于最终关键词提取并没有什么作用，这类属于停用词（stop word）要去掉；还有一些词语，比如在对新闻分类的时候，“报道”这种词出现的频率也很高，每一篇文章中，并不能用这种词作为文章的关键词。

解决方案：某个词语只出现在小部分的文章中，那么它的权重应该大，作为分类关键词或者搜索关键词，是很有帮助的。这种计算权重的方法就是逆文本频率。

公式为：                                                                             

D为文章个数，为出现词w的文章个数。

在《数学之美》这本书中，作者给出的解释是“IDF的概念就是一个特定条件下关键词的概率分布的交叉熵”。

可以这么理解这句话，因为交叉熵是用来衡量P（目标概率分布）与Q（训练概率分布）的，公式如下：

若Q能够很好地表示P，那么应该尽可能的小。那么在，如果一个关键词能够很好地表示这个文本的话，那么这个概率应该尽可能的大。（），即某个词语如果只在少数文章中出现那么它的概率应该大。

最终关键词的权重利用的是词频*逆文本频率得到，TF*IDF。

TF-IDF的信息论依据

一个文章中，每个关键词的权重应该能够反应可以为最终结果提供多少的信息量，即可以利用信息熵来表示。

N为语料库的大小，可以省略，故

                                                                                                           (1)

两个词出现的频率相同，一个是一篇文章中反复出现，一个是多篇文章中出现一两次，那么第一种情况应该权重更大，因此应该更改上式。

假设：（1）每篇文章大小(共D篇)相同，均有M 个词，即  

（2）一个词在一篇文章中无论出现多少次，它对于文章贡献相同，即,c(w)<M

故 由（1）得，

                                                            （2）

所以由（1）（2）得：

一个词的信息量越多，那么I(w)越多，由于c(w)<M，所以一个词在文献中出现的平均次数越多，那么第二项越小，整体越大。

上述内容主要从《数学之美》-第11章整体出。

代码：主要利用了sklearn.feature_extraction.text中的几个模型。

第一种方式：CountVectorizer  + TfidfTransformer  

import jieba
from sklearn.feature_extraction.text import TfidfTransformer  
from sklearn.feature_extraction.text import CountVectorizer  

corpus = ['证明你有来过','只看见沙漠','背影是假的人是真的']
dataset = []
for sen in corpus:
    dataset.append(' '.join(jieba.lcut(sen))) 

## 必须转成 ['证明 你 有 来过']这样形式才可以利用这个包处理

vectorizer = CountVectorizer() #IF-统计词频
data_vectorizer = vectorizer.fit_transform(dataset)
transformer = TfidfTransformer() #IF-IDF
tfidf = transformer.fit_transform(data_vectorizer) 
print(tfidf) 
### output：
### (0, 4)        1.0
### (1, 1)        0.7071067811865476
### (1, 0)        0.7071067811865476
### (2, 3)        0.7071067811865476
### (2, 2)        0.7071067811865476
### 表示矩阵每个位置的IF-IDF是多少
tfidf = tfidf.toarray() #tfidf转成矩阵
print(tfidf)

### output:
### [[0.         0.         0.         0.         1.        ]
###  [0.70710678 0.70710678 0.         0.         0.        ]
###  [0.         0.         0.70710678 0.70710678 0.        ]]
### a[i][j]表示词汇表中的索引为j的词在i个句子中的IF-IDF值

有0的位置，是因为参数设置的问题，词袋中只统计了词字数大于2的词。

第二种方式：TfidfVectorizer （TfidfVectorizer = CountVectorizer  + TfidfTransformer  ）

from sklearn.feature_extraction.text import TfidfVectorizer

tfidf = TfidfVectorizer() #初始化

tfidf.fit(dataset) 
#print(tfidf.get_feature_names()) ##词袋
#print(tfidf.vocabulary_) ## 词汇表
corpus_vector = tfidf.transform(dataset).toarray()
print(corpus_vector)

第二种方式比较好用，初始化的时候可以有很多种参数设置，这里不再赘述，附几个我认为比较好的参数讲解。

（1）https://blog.csdn.net/laobai1015/article/details/80451371

（2）https://blog.csdn.net/blmoistawinde/article/details/80816179