A Word-Complexity Lexicon and A Neural Readability Ranking Model for Lexical Simplification-paper

https://github.com/mounicam/lexical_simplification

提供了SimplePPDBpp: SimplePPDB++ resource consisting of around 14.1 million paraphrase rules along with their readability scores.   --- 非英文

主要贡献：
1、创造了人为评分的15000个英文单词复杂度
2、提出了a novel neural readability ranking model with a Gaussian-based feature vectorization layer
3、通过把PPDB输入到2中的模型中，创造了SimplePPDB++，即10million多的简化句子

皮尔逊系数
from scipy.stats import pearsonr

2 建立人类评分的单词复杂度词汇表
15000个英文单词
11个非native English speaker且是不同母语的人去评分，6-point Likert scale
含有大写字母的单词都一律选最常见的形式
每个单词有5-7个人评分
大多数人给1000个单词评分花大约2-2.5小时
计算了每个人和其他人评分平均值的pearson correlation
最终采用的是平均得分，抛弃了3%左右的和剩下评分均值差值大于2的评分

3 针对单词和句子的可读性排序模型
这个模型可以把创造的单词复杂度词汇表和上下文（如果可以）整合起来提高性能。模型使用了基于Gaussian的向量化层来更有效的探索numerical features，效果超过了所有词汇简化的方法（无论有没有词汇复杂度单词表）

3.13.1 Neural Readability Ranker (NRR) 
输入：两个单词或者两个短语pair
输出：正数，前者更难，负数，后者更难
1、输入层：特征提取层
输入的lexical和基于corpus的特征
也将基于单词复杂度的词汇表投射到模型中，作为一个带有一个二值indicator的numerical feature
2、基于Gaussian特征的向量化层，通过一系列Gaussian radial basis functions，将每个numerical特征，例如lexicon得分和n-gram概率，转换为向量表示
3、带有task-specific的输出几点的回归型feedforward的神经网络让模型去适应不同的lexical简化任务

3.2 features
我们集合了单词复杂度词汇表的评分、lexical and corpus特征和collocation特征。
将词汇复杂度单词表映射到模型中每个单词或者短语会得到两个特征：0-1二值特征，代表着单词是否在词汇表中出现（含有多个词的短语中最长的单词）；复杂度得分。对于不在单词表中的单词，这两个特征都为0.我们也会算lemmatized之后的单词的复杂度得分。还提取了以下特征：短语的长度-单词和字符，音节的个数，Google Ngram corpus的频率，simple wiki相对于nomal wiki的相对频率，5-gram语言模型在SubIMDB语料上的ngram概率。对一个单词来说，我们取这个单词左右大小为2的窗口内所有可能的n-grams的语言模型概率；对于一个短语来说，将这个短语拆分为可能的n-grams，计算特定上下文窗口的平均概率。
对于输入的单词对和短语对，f代表单词或短语的各自的特征集合；f(<>)代表pair的特征，包括余弦相似度和word2vec的差值。对于含有多个单词的短语的embedding是短语中所有单词embedding的平均。现在Google news corpus上预训练得到300维的embedding，这个已经在word2vec包中公开了。

3.3 vectorizing numerical features via Gaussian Binning
和别的lexical简化方法一样，我们的模型也是主要基于numerical features。即使这些连续的特征会直接喂给网络，充分利用特征值不同区间之间的微妙相关性也是很有用的。
我们采用平滑的binning方法，并且通过多重高斯径向基函数将每个numerical feature投射到一个向量表示。对于每一个特征f，我们把它的数值范围平均分为k个bins，然后每个bin应用一个高斯函数，其中均值是每个bin的中心位置，标准差是根据bin的宽度定义的，γ是可调节的超参数。给定一个特征值f，距离每个bin的距离的计算方式就是一个高斯函数，最后归一化投射为一个k维的向量记为f->。
除了word2vec向量外，我们向量化了所有的特征，然后将它们连接起来作为输入。
图2：t-SNE可视化了复杂度得分，范围在1.0-5.0，用我们的NRR模型应用高斯径向基函数将从单词复杂度词汇表的随机选出的300个单词向量化为10维后的表示，可以看出不同的特征值范围聚集在一起。
3.4 training and implementation details
我们使用pytorch来执行NRR模型，包括输入层、每个层含有八个节点的3个隐藏层，tanh激活函数、单一节点的线性输出层。目标函数是最小化MSE，即pair的真实复杂度得分和预测得分的差值平方和的均值。用Adam算法优化，dropout为0.2来避免过拟合。4.1和4.2的实验中，分别将速度设置为0.0005和0.001。对于Gaussian binning层，我们将bins的k值设置为10，γ设置为0.2而不是额外的参数调整。每次试验都是100个peochs。

4 lexical simplification application
lexical简化研究传统上都是研究多个子任务和数据集，我们一系列实验可以证明我们新创造从词汇表和NRR模型的有效性。

4.1 substitution ranking
给定一个含有特征复杂单词的句子（When you think about it, that’s pretty terrible）和一组待定的替换组{bad, awful,deplorable}，substitution ranking任务的目标是根据替换组的简化程度来排序。无论有没有使用单词复杂度词汇表，我们提出的NRR模型的效果要比这个任务所有目前的神经网络模型要好。
Data---
我们使用了English lexical simplification shared-task来评估，训练集包含300个例子，测试集包含1710个例子，一共有201个目标单词（大多数是多义词），每个单词会在10个不同的句子中出现。{bad, awful,deplorable}这样的一组至少会包含2个，平均会有5个candidates来排序。数据集中一共有10034个candidates，88.5%都包含在了我们的单词复杂度词汇表中，9.9%是含有多个单词的短语（3438个不同的candidates，其中81.8%是单词，20.2是多个单词）。
Task-specific setup of the NRR model---
我们用每一个candidates的pair所有输入来训练NRR模型，单词的排序左右groundtruth label。对于每一个pair，我们也把另一个训练实例（相反的顺序而已）作为输入，相反的排序作为输出。给定一个测试实例，candidate集合C，我们如下来对candidate排序：对于每一个candidates的pair，模型预测相对复杂度S（Ca-Cb）;然后通过整合pairwise scores并且对这些candidates增序排序，对于每一个candidate计算a single score R（Ca）。
comparison to existing methods---
我们比较了现在的一些在SemEval 2012数据集上进行substitution ranking结果最好的神经网络模型。我们的baselines也包含了几个其他已有的方法，。。。得分涉及到了统计数据、语义相似度、wordNet、监督SVM模型。。。。。所有这些方法都可以在the LEXenstein toolkit中实现，我们也使用它来做实验的比较。
results---
性能评估：precison of the simplest candidate ~P@1 和 Pearson correlation
P@1衡量了方法的实用性，Pearson衡量了系统排序和人类评分的相关性有多大。
我们用到了3.2中除了word2vec embedding特征以外的所有特征，这是为了避免在小的训练集的过拟合。
我们使用paired bootstrap test因为它可以应用到任何性能评估中。
我们使用了ablation experiments来展示用基于高斯的特征向量化层+binning和单词复杂度单词表+WC的有效性。

4.2 simplePPDB++
将NRR模型应用到PPDB数据集中对单词和短语排序，然后得到了很好的简化。simplePPDB++包含了13.1百万个单词和短语规则。接下来会和使用了3-way的逻辑回归分类器得到的simplePPDB比较，并展示simplePPDB++在substitution generation任务中的有效性。
Task-specific setup of NRR model.---
11829个手动标注的句子规则作为simplePPDB用来训练和测试，26.5%标注为简单，26.5%标注为复杂，47%标注为没有区别。三个类别用-1、0、1表示，预测的时候，阈值用交叉验证选择的是-0.4和0.4.

comparison to existing methods---
我们使用生成simplePPDB++的NRR模型和simplePPDB比较，后者是使用了多分类逻辑回归模型。我们也是用了几个别的baselines，包括了使用仅仅含有word2vec embedding特征的逻辑回归的W2V。

results--
比较了10折交叉验证accuracy和precision。我们的模型仅仅使用Gaussian binning即NRR（all+binning）的效果也比simplePPDB使用all这些特征再加上另外的离散特征例如pos tags、character unigram和bigrams要好，无论是precision还是accuracy。

4.3 substitution generation
substitution generation是lexicon简化中最具有挑战性的问题，涉及到对每个目标复杂单词或者短语产生candidate substitutions，并且排序。关键点不仅仅是更好的排序，而且还有产生大量的简化的substitutions。

Data---
数据来源于。。。包含100个不同单词或者短语，这些是从NewselaSimlification语料中采样得到的，随后进行了同样的评估过程。我们要求两个标注者评估生成的substitution是否为好的简化版本。

comparison to existing methods--
别的好方法包括：Glove中有最高相似度评分的、Simple Wikipedia and normal Wikipedia parallel corpus and automatic word
alignment 、 synonyms of word in WordNet同义词
指标： mean average precision即MAE，PPS即每个target产生的substitution的个数和P@1

4.4 complex word identification
CWI就是爱句子中找出需要简化的单词。这个步骤可以通过避免例如忽略南辞或者过度简化简单次所导致的错误来改进系统，这部分我们将利用我们的单词复杂度词汇表来帮助CWI。
data---
CWI SemEval 2016 ，广泛用来评估CWI系统，包含来自wikipedia的2237个训练实例和88221个测试实例
CWIG3G2 ，英语单语CWI 2018, 包含27299个训练集，3328个development，4252个测试实例，来自Wikipedia和新闻。我们的复杂度单词表在两个数据集中的占比都很高。

comparison to existing methods---
i、the nearest centroid classifier ，使用了短语长度，senses个数、pos tags、word2vec余弦相似度，simple Wikipedia中的ngram频率以及Google 1T corpus作为特征
ii、SV000gg， 词汇、形态、搭配和

语义特征的组合训练的二值分类器的组合。

utilizing the word-complexity lexicon--
将难度单词表作为额外的特征，提高了上述两种的性能，并将我们的改进用到了LEXenstein toolkit中。

results---
将SV000GG+WC、NC+WC、和lexicon only即WC+only与htreshold-based的方法比较。
评估：F-score and accuracy as well as G-score, the harmonic mean of accuracy and recall. G-score is the official metric of the CWI task
of Semeval 2016

5 related work
lexical simplification：之前的工作都是依赖于lexical、基于语料的特征。对于complex word identification，有两个研究路线：i、学习一个大语料的frequency-based threshold ii、训练分类器的组合，结合了lexical和语言模型特征。substitution ranking也是相似的趋势。
直到最近，才开始使用神经网络来做简化任务。2017第一次有lexical simplification的网络模型。 我们的NRR模型是第一个pairwise neural ranking model来向量化numerical features，并且使用一个包含15000个英文单词的单词复杂度词汇表来embed人们的评分。
除了lexical simplication，另一个相关的研究路线是sentence simplification，使用到了统计学或者neural机器翻译方法。将PPDB中的句子规则整合到statistical MT中，来进行sentence simplification和双语翻译是可行的，但是如何将simplePPDB++放入到neural MT中是一个开放性研究问题。

leica for simplification简化词典--
之前有很多手动建立的简化词典，但是我们的复杂度词汇表是第一个带有人类评分的，而且在自动简化系统上具有substantial improvement。同时，我们受到了word-emotion lexicon和word-happiness lexicon的启发。

vectorizing features：feature binning是一个标准的特征工程和数据处理的方法来讲连续的数据离散化，更常见的用于no-neural机器学习模型中。我们的工作受到了一下工作的启发：entity linking that discussed feature quantization for neural models、neural dependency parsing with embeddings of POS tags as features

6、conclusion

拓展
1、http://yangapku.github.io/2016/05/14/LEXenstein_1/
LEXenstein是一套用于英文词汇简化的工具库，可以完整覆盖简化任务的整个流程。该工具用python实现，推荐在linux+python2.x环境下运行。
其他工具
SVM-Rank (用于有监督排序)
Stanford-Tagger (分词器)
Morph Adorner Toolkit (词形态分析器)

代码分析：

https://github.com/mounicam/lexical_simplification/tree/master/neural_readability_ranker/features

1、lexical_simplification/neural_readability_ranker/features/
1)word2vec:
from sklearn.metrics.pairwise import cosine_similarity
--return cosine_similarity([f1], [f2])[0][0]

embeddings
---np.array([self.word2vec.word_vec(word) for word in word2vec_words])

模型的导入
--self.word2vec = gensim.models.KeyedVectors.load_word2vec_format(word2vec_file, binary=True)
--例如加载Google训练的词向量 import gensim model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin',binary=。。。)

2）WikiFrequency
有wiki frequency的文件

**3）syllable_counter
发音词典:nltk.corpus.cmudict.dict(),用来输出每个英文单词的发音

4）PPDBScores
有PPDB给两个短语的相对难度打分的文件

**5）ngram_probabilities
import kenlm
--举例
首先来训练语言模型。这里文本数据是50万微信公众号的文章，约2GB大小，训练语言模型用的是传统的“统计首先来训练语言模型。这里文本数据是50万微信公众号的文章，约2GB大小，训练语言模型用的是传统的“统计+平滑”的方法，使用kenlm这个工具来训练。
kenlm是一个C++编写的语言模型工具，具有速度快、占用内存小的特点，也提供了Python接口。首先下载编译它：
wget -O - http://kheafield.com/code/kenlm.tar.gz |tar xz
cd kenlm
./bjam -j4
python setup.py install
接着训练语言模型。kenlm的输入很灵活，不用预先生成语料文本，而可以通过管道的方式传递。比如先编写一个p.py

import pymongo
db = pymongo.MongoClient().weixin.text_articles

for text in db.find(no_cursor_timeout=True).limit(500000):
print ' '.join(text['text']).encode('utf-8')
我的文章放在MongoDB中，所以是上面的格式，如果你的数据放在其他地方，请做相应修改，其实很简单，就是把你要训练的文本分好词（用空格隔开，如果你是做基于字的模型，就把模型的每个字用空格隔开），然后逐一print出来。
然后就可以训练语言模型了，这里训练一个4-gram的语言模型：

python p.py|./kenlm/bin/lmplz -o 4 > weixin.arpa
./kenlm/bin/build_binary weixin.arpa weixin.klm
arpa是通用的语言模型格式，klm是kenlm定义的二进制格式，klm格式占用空间更少。最后我们就可以在Python中载入了

import kenlm
model = kenlm.Model('weixin.klm')
model.score('微 信', bos=False, eos=False)
'''
score函数输出的是对数概率，即log10(p('微 信'))，其中字符串可以是gbk，也可以是utf-8
bos=False, eos=False意思是不自动添加句首和句末标记符
'''

6）lexicon
from nltk import WordNetLemmatizer
from nltk.stem.lancaster import LancasterStemmer
from nltk.stem.snowball import SnowballStemmer
得到word不同形式，查看是否在lexicon表中

7）GoogleFrequency
有Google frequency的文件

8）gaussian_binner
x = [[1,2,3],[4,5,6],[7,8,9]]
x = np.array(x)
for index in range(0, 3):
dimension = x[:,index]
print('index....',index)
print('dimension....',dimension)#[1,4,7]
bin_divisions = np.histogram(dimension, bins=5)[1]
print('bin_divisions....',bin_divisions)#array([1. , 2.2, 3.4, 4.6, 5.8, 7. ]))
#('bin_1....', array([1, 0, 1, 0, 1]))
即histogram的功能是将将1-7的范围分为7等分

sigma其实也就是间距*w，其中w设置为0.2

>>> b = np.array([[1, 2], [3, 4]])
>>> np.tile(b, 2) #沿X轴复制2倍
array([[1, 2, 1, 2],
[3, 4, 3, 4]])
>>> np.tile(b, (2, 1))#沿X轴复制1倍（相当于没有复制），再沿Y轴复制2倍
array([[1, 2],
[3, 4],
[1, 2],
[3, 4]])

最后是将提取index列的特征，复制bin数目+2列，在-均值/和

测试代码：
import numpy as np
x = [[1,2,3,4,5,6,7],[8,9,10,11,12,13,14],[15,16,17,18,19,20,21]]
x = np.array(x)
bin_values = []
sigmas = []

def gaussian(diff, sig):
return np.exp(-np.power(diff, 2.) / (2 * sig * sig))

for index in range(0, 3):
dimension = x[:,index]
print('index....',index)
print('dimension....',dimension)#[1,4,7]
bin_divisions = np.histogram(dimension, bins=5)[1]
bin_1 = np.histogram(dimension, bins=5)[0]
#print('bin_divisions....',bin_divisions)#array([1. , 2.2, 3.4, 4.6, 5.8, 7. ]))
#print('bin_1....',bin_1)#array([1. , 2.2, 3.4, 4.6, 5.8, 7. ]))
bin_means = [(bin_divisions[i] + bin_divisions[i+1]) / 2.0 for i in range(0, len(bin_divisions) - 1)]
#print('bin_means....',bin_means)
half_width = abs(bin_divisions[1] - bin_divisions[0]) / 2.0
#print('half_width....',half_width)
bin_means[0:0] = [bin_divisions[0] - half_width]
#print('bin_means....',bin_means)
bin_means.append(bin_divisions[len(bin_divisions) - 1] + half_width)
#print('bin_means....',bin_means)
bin_values.append(bin_means)
sigmas.append(abs(bin_divisions[1] - bin_divisions[0]) * 0.2)

expanded_features = [x[:, 3:]]
print(x[:,3:])
print(expanded_features)
#self.sigmas.append(abs(bin_divisions[1] - bin_divisions[0]) * self.width)

for index in range(0, 3):
bin_means = np.array(bin_values[index])
print('bin_means....',bin_means)
projected_features = gaussian(np.tile(x[:, index], (7, 1)).T - bin_means,sigmas[index])
print('projected....',projected_features)
sum_f = np.sum(projected_features, axis=1)
print('sum_f....',sum_f)
sum_f[sum_f == 0] = 0.000001
projected_features = (projected_features.T / sum_f).T
print('projected....',projected_features)
expanded_features.append(projected_features)
print('expanded....',expanded_features)
print(np.concatenate(expanded_features, axis=1))

(py2) root@wfcb:~/yyy/paper# python try.py
('index....', 0)
('dimension....', array([ 1, 8, 15]))
('index....', 1)
('dimension....', array([ 2, 9, 16]))
('index....', 2)
('dimension....', array([ 3, 10, 17]))
[[ 4 5 6 7]
[11 12 13 14]
[18 19 20 21]]
[array([[ 4, 5, 6, 7],
[11, 12, 13, 14],
[18, 19, 20, 21]])]
('bin_means....', array([-0.4, 2.4, 5.2, 8. , 10.8, 13.6, 16.4]))
('projected....', array([[4.39369336e-002, 4.39369336e-002, 6.10193668e-013,
1.17691094e-034, 3.15251716e-067, 1.17276033e-110,
6.05897318e-165],
[1.38634329e-049, 1.92874985e-022, 3.72665317e-006,
1.00000000e+000, 3.72665317e-006, 1.92874985e-022,
1.38634329e-049],
[6.05897318e-165, 1.17276033e-110, 3.15251716e-067,
1.17691094e-034, 6.10193668e-013, 4.39369336e-002,
4.39369336e-002]]))
('sum_f....', array([0.08787387, 1.00000745, 0.08787387]))
('projected....', array([[5.00000000e-001, 5.00000000e-001, 6.94397193e-012,
1.33931848e-033, 3.58754799e-066, 1.33459511e-109,
6.89507970e-164],
[1.38633296e-049, 1.92873547e-022, 3.72662540e-006,
9.99992547e-001, 3.72662540e-006, 1.92873547e-022,
1.38633296e-049],
[6.89507970e-164, 1.33459511e-109, 3.58754799e-066,
1.33931848e-033, 6.94397193e-012, 5.00000000e-001,
5.00000000e-001]]))
('expanded....', [array([[ 4, 5, 6, 7],
[11, 12, 13, 14],
[18, 19, 20, 21]]), array([[5.00000000e-001, 5.00000000e-001, 6.94397193e-012,
1.33931848e-033, 3.58754799e-066, 1.33459511e-109,
6.89507970e-164],
[1.38633296e-049, 1.92873547e-022, 3.72662540e-006,
9.99992547e-001, 3.72662540e-006, 1.92873547e-022,
1.38633296e-049],
[6.89507970e-164, 1.33459511e-109, 3.58754799e-066,
1.33931848e-033, 6.94397193e-012, 5.00000000e-001,
5.00000000e-001]])])
('bin_means....', array([ 0.6, 3.4, 6.2, 9. , 11.8, 14.6, 17.4]))
('projected....', array([[4.39369336e-002, 4.39369336e-002, 6.10193668e-013,
1.17691094e-034, 3.15251716e-067, 1.17276033e-110,
6.05897318e-165],
[1.38634329e-049, 1.92874985e-022, 3.72665317e-006,
1.00000000e+000, 3.72665317e-006, 1.92874985e-022,
1.38634329e-049],
[6.05897318e-165, 1.17276033e-110, 3.15251716e-067,
1.17691094e-034, 6.10193668e-013, 4.39369336e-002,
4.39369336e-002]]))
('sum_f....', array([0.08787387, 1.00000745, 0.08787387]))
('projected....', array([[5.00000000e-001, 5.00000000e-001, 6.94397193e-012,
1.33931848e-033, 3.58754799e-066, 1.33459511e-109,
6.89507970e-164],
[1.38633296e-049, 1.92873547e-022, 3.72662540e-006,
9.99992547e-001, 3.72662540e-006, 1.92873547e-022,
1.38633296e-049],
[6.89507970e-164, 1.33459511e-109, 3.58754799e-066,
1.33931848e-033, 6.94397193e-012, 5.00000000e-001,
5.00000000e-001]]))
('expanded....', [array([[ 4, 5, 6, 7],
[11, 12, 13, 14],
[18, 19, 20, 21]]), array([[5.00000000e-001, 5.00000000e-001, 6.94397193e-012,
1.33931848e-033, 3.58754799e-066, 1.33459511e-109,
6.89507970e-164],
[1.38633296e-049, 1.92873547e-022, 3.72662540e-006,
9.99992547e-001, 3.72662540e-006, 1.92873547e-022,
1.38633296e-049],
[6.89507970e-164, 1.33459511e-109, 3.58754799e-066,
1.33931848e-033, 6.94397193e-012, 5.00000000e-001,
5.00000000e-001]]), array([[5.00000000e-001, 5.00000000e-001, 6.94397193e-012,
1.33931848e-033, 3.58754799e-066, 1.33459511e-109,
6.89507970e-164],
[1.38633296e-049, 1.92873547e-022, 3.72662540e-006,
9.99992547e-001, 3.72662540e-006, 1.92873547e-022,
1.38633296e-049],
[6.89507970e-164, 1.33459511e-109, 3.58754799e-066,
1.33931848e-033, 6.94397193e-012, 5.00000000e-001,
5.00000000e-001]])])
('bin_means....', array([ 1.6, 4.4, 7.2, 10. , 12.8, 15.6, 18.4]))
('projected....', array([[4.39369336e-002, 4.39369336e-002, 6.10193668e-013,
1.17691094e-034, 3.15251716e-067, 1.17276033e-110,
6.05897318e-165],
[1.38634329e-049, 1.92874985e-022, 3.72665317e-006,
1.00000000e+000, 3.72665317e-006, 1.92874985e-022,
1.38634329e-049],
[6.05897318e-165, 1.17276033e-110, 3.15251716e-067,
1.17691094e-034, 6.10193668e-013, 4.39369336e-002,
4.39369336e-002]]))
('sum_f....', array([0.08787387, 1.00000745, 0.08787387]))
('projected....', array([[5.00000000e-001, 5.00000000e-001, 6.94397193e-012,
1.33931848e-033, 3.58754799e-066, 1.33459511e-109,
6.89507970e-164],
[1.38633296e-049, 1.92873547e-022, 3.72662540e-006,
9.99992547e-001, 3.72662540e-006, 1.92873547e-022,
1.38633296e-049],
[6.89507970e-164, 1.33459511e-109, 3.58754799e-066,
1.33931848e-033, 6.94397193e-012, 5.00000000e-001,
5.00000000e-001]]))
('expanded....', [array([[ 4, 5, 6, 7],
[11, 12, 13, 14],
[18, 19, 20, 21]]), array([[5.00000000e-001, 5.00000000e-001, 6.94397193e-012,
1.33931848e-033, 3.58754799e-066, 1.33459511e-109,
6.89507970e-164],
[1.38633296e-049, 1.92873547e-022, 3.72662540e-006,
9.99992547e-001, 3.72662540e-006, 1.92873547e-022,
1.38633296e-049],
[6.89507970e-164, 1.33459511e-109, 3.58754799e-066,
1.33931848e-033, 6.94397193e-012, 5.00000000e-001,
5.00000000e-001]]), array([[5.00000000e-001, 5.00000000e-001, 6.94397193e-012,
1.33931848e-033, 3.58754799e-066, 1.33459511e-109,
6.89507970e-164],
[1.38633296e-049, 1.92873547e-022, 3.72662540e-006,
9.99992547e-001, 3.72662540e-006, 1.92873547e-022,
1.38633296e-049],
[6.89507970e-164, 1.33459511e-109, 3.58754799e-066,
1.33931848e-033, 6.94397193e-012, 5.00000000e-001,
5.00000000e-001]]), array([[5.00000000e-001, 5.00000000e-001, 6.94397193e-012,
1.33931848e-033, 3.58754799e-066, 1.33459511e-109,
6.89507970e-164],
[1.38633296e-049, 1.92873547e-022, 3.72662540e-006,
9.99992547e-001, 3.72662540e-006, 1.92873547e-022,
1.38633296e-049],
[6.89507970e-164, 1.33459511e-109, 3.58754799e-066,
1.33931848e-033, 6.94397193e-012, 5.00000000e-001,
5.00000000e-001]])])
[[4.00000000e+000 5.00000000e+000 6.00000000e+000 7.00000000e+000
5.00000000e-001 5.00000000e-001 6.94397193e-012 1.33931848e-033
3.58754799e-066 1.33459511e-109 6.89507970e-164 5.00000000e-001
5.00000000e-001 6.94397193e-012 1.33931848e-033 3.58754799e-066
1.33459511e-109 6.89507970e-164 5.00000000e-001 5.00000000e-001
6.94397193e-012 1.33931848e-033 3.58754799e-066 1.33459511e-109
6.89507970e-164]
[1.10000000e+001 1.20000000e+001 1.30000000e+001 1.40000000e+001
1.38633296e-049 1.92873547e-022 3.72662540e-006 9.99992547e-001
3.72662540e-006 1.92873547e-022 1.38633296e-049 1.38633296e-049
1.92873547e-022 3.72662540e-006 9.99992547e-001 3.72662540e-006
1.92873547e-022 1.38633296e-049 1.38633296e-049 1.92873547e-022
3.72662540e-006 9.99992547e-001 3.72662540e-006 1.92873547e-022
1.38633296e-049]
[1.80000000e+001 1.90000000e+001 2.00000000e+001 2.10000000e+001
6.89507970e-164 1.33459511e-109 3.58754799e-066 1.33931848e-033
6.94397193e-012 5.00000000e-001 5.00000000e-001 6.89507970e-164
1.33459511e-109 3.58754799e-066 1.33931848e-033 6.94397193e-012
5.00000000e-001 5.00000000e-001 6.89507970e-164 1.33459511e-109
3.58754799e-066 1.33931848e-033 6.94397193e-012 5.00000000e-001
5.00000000e-001]]