CN102681973A - 交易系统中买卖双方信用的等级排序方法 - Google Patents

Abstract

本发明公开了一种交易系统中买卖双方信用的等级排序方法，步骤一、原始数据预处理；设第j个卖家为第i个买家的信用评分为v_i，j，则将所有的卖家给买家的信用评分存储到二维存储矩阵V中；设第i个买家为第j个卖家的信用评分为u_j，i，则将所有的买家给卖家的信用评分存储到二维存储矩阵U中；步骤二、计算两个核心矩阵A和B，其中，A为一个N行N列的正方形存储矩阵，它由所述的存储矩阵V和U中的数值经过矩阵相乘运算得到；B为一个M行M列的正方形存储矩阵，它是由所述的存储矩阵U和V中的数值经过矩阵相乘运算得到；步骤三、进行迭代运算，分别计算买家和卖家的信用排序值。本发明能够得到买卖双方更为合理的信用等级排序。

Description

交易系统中买卖双方信用的等级排序方法

技术领域

本发明涉及一种交易系统中买卖双方信用的等级排序方法。

背景技术

现在网络交易中的信用评分，主要是依靠买、卖双方互相打分统计出来的。比如对某一个卖家的信用评分，往往是通过累计所有购买过他的货物的买家对他的评分，然后平均得到的。

由于网络交易的特殊性，有些卖(或买)家能够通过不正当的方法，抬高自己的信用等级。这些手段有：使用虚假的买(卖)家户名，为自己打高分等。

发明内容

本发明要解决的技术问题是提供一种交易系统中买卖双方信用的等级排序方法，能够得到买卖双方更为合理的信用等级排序。

为解决上述技术问题，本发明的交易系统中买卖双方信用的等级排序方法如下步骤：

步骤一、原始数据预处理；

设第j个卖家为第i个买家的信用评分为v_i，j，则将所有的卖家给买家的信用评分存储到二维存储矩阵V中；

设第i个买家为第j个卖家的信用评分为u_j，i，则将所有的买家给卖家的信用评分存储到二维存储矩阵U中；

步骤二、计算两个核心矩阵A和B，其中，A为一个N行N列的正方形存储矩阵，它由所述的存储矩阵V和U中的数值经过矩阵相乘运算得到；B为一个M行M列的正方形存储矩阵，它是由所述的存储矩阵U和V中的数值经过矩阵相乘运算得到；

步骤三、进行迭代运算，分别计算买家和卖家的信用排序值。

本发明的方法通过建立合理的数学模型，用精简的数学计算，可以得到买卖双方的信用等级排序；为交易平台提供可靠的参考数据，特别适用于网络上的交易系统。

采用本发明的最大好处是：不是简单地将每个买家或卖家得到的信用评分累加、或者累加后平均的结果，用来作为信用排序的依据，而是兼顾了评分者自己的排序值(Rank值，或称信用值)，将评分者的排序值作为权重乘上其打出的分数作为合理的评分值，累计到被评价者的总分中去。本发明通过巧妙的数学工具来计算，得到更为合理的全部参与者的排序值。

附图说明

下面结合附图与具体实施方式对本发明作进一步详细的说明：

附图是本发明的方法控制流程图。

具体实施方式

本发明的方法基本构思是，假设某个集合内有N个买家，他们的Rank值为s＝[s₁ s₂ s₃，...，s_N]^T，另外有M个卖家：他们的Rank值为t＝[t₁ t₂ t₃，...，t_M]^T。经过一段时间的买卖交易互动之后，相互打了原始的分数。

设第j个卖家为第i个买家的信用评分为v_i，j，则所有的卖家给买家的信用评分可写成如下矩阵形式：

$V=\left[\begin{array}{cccccc}{v}_{\mathrm{1,1}}& v_{1,2}& ...& v_{1,j}& ...& v_{1,M}\\ v_{\mathrm{2,1}}& v_{\mathrm{2,2}}& ...& v_{2,j}& ...& v_{2,M}\\ ...& & & & & \\ v_{i,1}& v_{i,2}& ...& v_{i,j}& ...& v_{i,M}\\ ...& & & & & \\ v_{N,1}& v_{N,2}& ...& v_{N,j}& ...& v_{N,M}\end{array}\right]$

设第i个买家为第j个卖家的信用评分为u_j，i，则所有的买家给卖家的信用评分也可写成如下的矩阵形式：

$U=\left[\begin{array}{cccccc}{u}_{\mathrm{1,1}}& u_{1,2}& ...& u_{1,i}& ...& u_{1,N}\\ u_{\mathrm{2,1}}& u_{\mathrm{2,2}}& ...& u_{2,i}& ...& u_{2,N}\\ ...& & & & & \\ u_{j,1}& u_{j,2}& ...& u_{j,i}& ...& u_{j,N}\\ ...& & & & & \\ u_{M,1}& u_{M,2}& ...& u_{M,i}& ...& u_{M,N}\end{array}\right]$

如果矩阵V中第i行和矩阵U中第i列全为0，则表示没有任何人给第i个买家评分，该第i个买家也没给任何其它卖家评分。可以在矩阵中删除此买家，即同时删除V中第i行和U中第i列，该买家的Rank值置为0。

类似地，如果矩阵U中第j行和矩阵V第j列全为0，则表示没有任何人给第j个卖家打分，该第j个卖家也没给任何其它买家打分。可以在矩阵中删除此卖家，即同时删除U中第j行和V中第j列，该卖家的Rank值置为0。

根据上述数据，需要求解卖家的信用等级排序列向量t(M×1)和买家的信用等级排序列向量s(N×1)。

如果将卖家自身的Rank值t做为对买家评分时的权重值，对整个V进行加权累加处理，应该得到买家的Rank值s；反之亦然：如果将买家自身的Rank值s做为对卖家评分时的权重值，对整个U进行加权累加处理，应该得到卖家的Rank值t。也就是同时满足下式：

s＝c₁Vt              (1)

t＝c₂Us              (2)

其中，c₁和c₂是两个常数。简言之，需要解的数学问题是：已知V、U，求解s和t。

解法：从数学上，将公式(1)带入公式(2)，可得：

s＝c₁c₂VUs

$\frac{1}{c_1{c}_2}s=\mathrm{VUs}---\left(3\right)$

可见s是N阶方阵“VU”的特征向量，

是矩阵VU的特征值。

同样，将公式(2)带入公式(1)，可得：

t＝c₁c₂UVt

$\frac{1}{c_1{c}_2}t=\mathrm{UVt}---\left(4\right)$

其中，t是M阶方阵“UV”的特征向量，

是矩阵UV的特征值。

由此可以看出，只要求解N阶方阵“VU”和M阶方阵“UV”的特征值和特征向量即可；并且需要的解

是绝对值最大的特征值对应的特征向量。

解特征向量的算法有很多种，例如可以用乘幂法来迭代求解。乘幂法的数学原理是：若求某个N阶方阵A的特征值和特征向量，任取一个长为N、非零初始列向量r⁽⁰⁾，经过矩阵A和列向量r的反复乘积运算，构造如下的列向量序列：

r⁽⁰⁾

r⁽¹⁾＝Ar⁽⁰⁾

r⁽²⁾＝Ar⁽¹⁾                (5)

...

r^(k+1)＝Ar^(k)

其中，k表示迭代运算的次数，当k增大时，列向量序列r^(k)将收敛到矩阵A绝对值最大的特征值所对应的特征向量。当r^(k)与r^(k+1)的误差很小时，即可完成特征向量的求解。

具体算法如下，令方阵“VU”或“UV”为A，A的矩阵的阶数为N，取：

经过下式运算：

k＝0；

Loop while δ＞E

   r^(k+1)＝Ar^(k)

$r^{(k+1)}=\frac{r^{(k+1)}}{\left|\right|r^{(k+1)}\left|\right|}$

   δ＝||r^(k+1)-r^(k)||

   k＝k+1；

end

特征向量≈r^(k+1)

上式中，对每次得到的列向量r^(k)进行归一化操作，即：

$r^{(k+1)}=\frac{r^{(k+1)}}{\left|\right|r^{(k+1)}\left|\right|}$

$\left|\right|r^{(k+1)}\left|\right|=\left|\right|{\left[\begin{array}{c}{r}_1^{(k+1)}\\ r_2^{(k+1)}\\ \·\·\·\\ r_N^{(k+1)}\end{array}\right]}_{N\×1}\left|\right|=\underset{n=1}{\overset{N}{\mathrm{\Σ}}}|r_n^{(k+1)}|=|r_1^{(k+1)}|+|r_2^{(k+1)}|+...+|r_N^{(k+1)}|$

其中，“||||”为列向量的1范数，即列向量中所有元素的绝对值之和。

在第k+1次循环中计算r^(k+1)和前次结果r^(k)之差向量的范数δ，判断其是否小于设定容忍的误差门限E，如果不是小于，则继续下一次迭代运算；如果是小于，则停止迭代运算，输出r^(k+1)作为矩阵A的特征向量，即得到的Rank值。

如果矩阵A是“VU”，则Rank值代表的是s；如果矩阵A是“UV”则Rank值代表的是t。经过两次相同的算法运算，就得到了对买卖双方信用评价的排序s和t。

另外，通过设定误差门限E，能够得到足够精度的信用排序结果。要求精度越高，运算量也越大。比如：可以取E＝0.001，即误差在千分之一。

参见图1所示，所述交易系统中买卖双方信用的等级排序方法控制流程如下：

步骤一、原始数据预处理。

假设某个由N个买家和M个卖家组成的集合内，经过一段时间的买卖交易之后，每次交易的买卖双方相互打了原始的信用分数(分数取在一定的区间内，比如0～100，或0～10等，分数越高表示其信用越好，评价越高)。

设第j个卖家为第i个买家的信用评分为v_i，j，则所有的卖家给买家的评分可存储到如下二维存储矩阵V中：

$V=\left[\begin{array}{cccccc}{v}_{\mathrm{1,1}}& v_{1,2}& ...& v_{1,j}& ...& v_{1,M}\\ v_{\mathrm{2,1}}& v_{\mathrm{2,2}}& ...& v_{2,j}& ...& v_{2,M}\\ ...& & & & & \\ v_{i,1}& v_{i,2}& ...& v_{i,j}& ...& v_{i,M}\\ ...& & & & & \\ v_{N,1}& v_{N,2}& ...& v_{N,j}& ...& v_{N,M}\end{array}\right]$

设第i个买家为第j个卖家的信用评分为u_j，i，所有的买家给卖家的信用评分也可存储到如下的二维存储矩阵U中：

$U=\left[\begin{array}{cccccc}{u}_{\mathrm{1,1}}& u_{1,2}& ...& u_{1,i}& ...& u_{1,N}\\ u_{\mathrm{2,1}}& u_{\mathrm{2,2}}& ...& u_{2,i}& ...& u_{2,N}\\ ...& & & & & \\ u_{j,1}& u_{j,2}& ...& u_{j,i}& ...& u_{j,N}\\ ...& & & & & \\ u_{M,1}& u_{M,2}& ...& u_{M,i}& ...& u_{M,N}\end{array}\right]$

上述两个矩阵给出了N个买家和M个卖家所有的任意两两组合(交易)的可能，如果某一买家i和卖家j没有交易，则双方没有互相打分，矩阵中的相应的v_i，ju_j，i都填0。

本发明的目标就是：从上述两个矩阵的数据，计算出N个买家的排序值：s＝[s₁ s₂ s₃，...，s_N]^T和M个卖家的排序值t＝[t₁ t₂ t₃，...，t_M]^T。

步骤二、计算两个核心矩阵A和B。

其中，A为一个N行N列的正方形存储矩阵，它是由前述的存储矩阵V和U中的数值经过矩阵相乘运算得到的。

$A=\mathrm{VU}=\left[\begin{array}{cccccc}{v}_{\mathrm{1,1}}& v_{1,2}& ...& v_{1,j}& ...& v_{1,M}\\ v_{\mathrm{2,1}}& v_{\mathrm{2,2}}& ...& v_{2,j}& ...& v_{2,M}\\ ...& & & & & \\ v_{i,1}& v_{i,2}& ...& v_{i,j}& ...& v_{i,M}\\ ...& & & & & \\ v_{N,1}& v_{N,2}& ...& v_{N,j}& ...& v_{N,M}\end{array}\right]\×\left[\begin{array}{cccccc}{u}_{\mathrm{1,1}}& u_{\mathrm{1,2}}& ...& u_{1,i}& ...& u_{1,N}\\ u_{\mathrm{2,1}}& u_{\mathrm{2,2}}& ...& u_{2,i}& ...& u_{2,N}\\ ...& & & & & \\ u_{j,1}& u_{j,2}& ...& u_{j,i}& ...& u_{j,N}\\ ...& & & & & \\ u_{M,1}& u_{M,2}& ...& u_{M,i}& ...& u_{M,N}\end{array}\right]$

$=\left[\begin{array}{cccccc}{a}_{\mathrm{1,1}}& a_{\mathrm{1,2}}& ...& a_{1,n}& ...& a_{1,N}\\ a_{\mathrm{2,1}}& a_{\mathrm{2,2}}& ...& a_{2,n}& ...& a_{2,N}\\ ...& & & & & \\ a_{k,1}& a_{k,2}& ...& a_{k,n}& ...& a_{k,N}\\ ...& & & & & \\ a_{N,1}& a_{N,2}& ...& a_{N,n}& ...& a_{N,N}\end{array}\right]$

A中的第k行第n列的存储元素计算方法如下：

$a_{k,n}=\underset{j=1}{\overset{M}{\mathrm{\Σ}}}(v_{k,j}\×u_{j,n}),k=\mathrm{1,2},...,N,n=\mathrm{1,2},...N$

上式展开就是如下相乘和累加运算：

a_1，1＝v_1，1×u_1，1+v_1，2×u_2，1+v_1，3×u_3，1+...+v_1，M×u_M，1

a_2，1＝v_2，1×u_1，1+v_2，2×u_2，1+v_2，3×u_3，1+...+v_2，M×u_M，1

a_1，2＝v_1，1×u_1，2+v_1，2×u_2，2+v_1，3×u_3，2+...+v_1，M×u_M，2

a_k，n＝v_k，1×u_1，n+v_k，2×u_2，n+v_k，3×u_3，n+...+v_k，M×u_M，n

a_N，N＝v_N，1×u_1，N+v_N，2×u_2，N+v_N，3×u_3，N+...+v_N，M×u_M，N

类似地，B为一个M行M列的正方形存储矩阵，它是由前述的存储矩阵U和V中的数值经过矩阵相乘运算得到的。

$B=\mathrm{UV}=\left[\begin{array}{cccccc}{u}_{\mathrm{1,1}}& u_{1,2}& ...& u_{1,i}& ...& u_{1,N}\\ u_{\mathrm{2,1}}& u_{\mathrm{2,2}}& ...& u_{2,i}& ...& u_{2,N}\\ ...& & & & & \\ u_{j,1}& u_{j,2}& ...& u_{j,i}& ...& u_{j,N}\\ ...& & & & & \\ u_{M,1}& u_{M,2}& ...& u_{M,i}& ...& u_{M,N}\end{array}\right]\×\left[\begin{array}{cccccc}{v}_{\mathrm{1,1}}& v_{\mathrm{1,2}}& ...& v_{1,j}& ...& v_{1,M}\\ v_{\mathrm{2,1}}& v_{\mathrm{2,2}}& ...& v_{2,j}& ...& v_{2,M}\\ ...& & & & & \\ v_{i,1}& v_{i,2}& ...& v_{i,j}& ...& v_{i,M}\\ ...& & & & & \\ v_{N,1}& v_{N,2}& ...& v_{N,j}& ...& v_{N,M}\end{array}\right]$

$=\left[\begin{array}{cccccc}{b}_{\mathrm{1,1}}& b_{\mathrm{1,2}}& ...& b_{1,m}& ...& b_{1,M}\\ b_{\mathrm{2,1}}& b_{\mathrm{2,2}}& ...& b_{2,m}& ...& b_{2,M}\\ ...& & & & & \\ b_{l,1}& b_{l,2}& ...& b_{l,m}& ...& b_{l,M}\\ ...& & & & & \\ b_{M,1}& b_{M,2}& ...& b_{M,m}& ...& b_{M,M}\end{array}\right]$

B中的第l行第m列的存储元素计算方法如下：

$b_{l,m}=\underset{i=1}{\overset{N}{\mathrm{\Σ}}}(u_{l,i}\×v_{i,m}),l=\mathrm{1,2},...,M,m=\mathrm{1,2},...M$

上式展开就是如下相乘和累加运算：

b_1，1＝u_1，1×v_1，1+u_1，2×v_2，1+u_1，3×v_3，1+...+u_1，N×v_N，1

b_2，1＝u_2，1×v_1，1+u_2，2×v_2，1+u_2，3×v_3，1+...+u_2，N×v_N，1

b_1，2＝u_1，1×v_1，2+u_1，2×v_2，2+u_1，3×v_3，2+...+u_1，N×v_N，2

b_l，m＝u_l，1×v_1，m+u_l，2×v_2，m+u_l，3×v_3，m+...+u_l，N×v_N，m

b_M，M＝u_M，1×v_1，M+u_M，2×v_2，M+u_M，3×v_3，M+...+u_M，N×v_N，M

步骤三、进行迭代运算，分别计算买家和卖家的信用排序值。

迭代运算分为两个部分，一是计算买家的信用排序值，使用存储矩阵A；二是计算卖家的信用排序值，使用存储矩阵B。

1、计算买家的信用排序。

1.1、设定迭代起始值。

假设是第一次进行迭代计算，即还没有经过迭代运算，关于N个买家的排序初始值，取N长度、内容相同的初始向量存储在某一行存储单元s内：

$s^{\left(0\right)}=\begin{array}{c}\left[\begin{array}{cccc}{s}_1^{\left(0\right)}& s_2^{\left(0\right)}& ...& s_N^{\left(0\right)}\end{array}\right]=\left[\begin{array}{cccc}\frac{1}{N}& \frac{1}{N}& ...& \frac{1}{N}\end{array}\right]\end{array}$

其中，每一个存储的数据都相同，都是

共N个。“s⁽⁰⁾”中的0标记为迭代次数。

如果不是第一次进行迭代计算，而是进行第m次迭代计算，则同样将第m-1次迭代计算的结果：

保留在行存储器s中。

1.2、迭代计算，将A乘以s，即

$s^{\left(m\right)}=A{s}^{(m-1)T}=\left[\begin{array}{cccccc}{a}_{\mathrm{1,1}}& a_{\mathrm{1,2}}& ...& a_{1,n}& ...& a_{1,N}\\ a_{\mathrm{2,1}}& a_{\mathrm{2,2}}& ...& a_{2,n}& ...& a_{2,N}\\ ...& & & & & \\ a_{k,1}& a_{k,2}& ...& a_{k,n}& ...& a_{k,N}\\ ...& & & & & \\ a_{N,1}& a_{N,2}& ...& a_{N,n}& ...& a_{N,N}\end{array}\right]\×\left[\begin{array}{c}{s}_1^{(m-1)}\\ s_2^{(m-1)}\\ .\\ .\\ s_N^{(m-1)}\end{array}\right]$

$=\left[\begin{array}{cccccc}{s}_1^{\left(m\right)}& s_2^{\left(m\right)}& ...& s_n^{\left(m\right)}& ...& s_N^{\left(m\right)}\end{array}\right]$

其中：

$s_1^{\left(m\right)}=\underset{n=1}{\overset{N}{\mathrm{\Σ}}}(a_{1,n}\×s_n^{(m-1)})=(a_{\mathrm{1,1}}\×s_1^{(m-1)}+a_{\mathrm{1,2}}\×s_2^{(m-1)}+...+a_{1,n}\×s_n^{(m-1)}+...+a_{1,N}\×s_N^{(m-1)})$

$s_2^{\left(m\right)}=\underset{n=1}{\overset{N}{\mathrm{\Σ}}}(a_{2,n}\×s_n^{(m-1)})=(a_{2,1}\×s_1^{(m-1)}+a_{\mathrm{2,2}}\×s_2^{(m-1)}+...+a_{2,n}\×s_n^{(m-1)}+...+a_{2,N}\×s_N^{(m-1)})$

...

$s_N^{\left(m\right)}=\underset{n=1}{\overset{N}{\mathrm{\Σ}}}(a_{N,n}\×s_n^{(m-1)})=(a_{N,1}\×s_1^{(m-1)}+a_{N,2}\×s_2^{(m-1)}+...+a_{N,n}\×s_n^{(m-1)}+...+a_{N,N}\×s_N^{(m-1)})$

1.3、进行归一化处理。

$f^{\left(m\right)}=\underset{n=1}{\overset{N}{\mathrm{\Σ}}}\left|s_n^{\left(m\right)}\right|=\left|s_1^{\left(m\right)}\right|+\left|s_2^{\left(m\right)}\right|+...+\left|s_n^{\left(m\right)}\right|+...+\left|s_N^{\left(m\right)}\right|$

$s^{\left(m\right)}=\frac{1}{f^{\left(m\right)}}\left[\begin{array}{cccccc}{s}_1^{\left(m\right)}& s_2^{\left(m\right)}& ...& s_n^{\left(m\right)}& ...& s_N^{\left(m\right)}\end{array}\right]=\left[\begin{array}{cccccc}\frac{s_1^{\left(m\right)}}{f^{\left(m\right)}}& \frac{s_2^{\left(m\right)}}{f^{\left(m\right)}}& ...& \frac{s_n^{\left(m\right)}}{f^{\left(m\right)}}& ...& \frac{s_N^{\left(m\right)}}{f^{\left(m\right)}}\end{array}\right]$

为节省存储空间起见，将第m次迭代后的覆盖到上次迭代的同一个行存储单元

中，并作为下一次迭代的起始值。

1.4、计算迭代后的误差δ^(m)。

误差δ^(m)表示的是第m次迭代后得到的s^(m)和第m-1次迭代后得到的s^(m-1)的差距，由下式得到：

${\mathrm{\δ}}^{\left(m\right)}=\underset{n=1}{\overset{N}{\mathrm{\Σ}}}|s_n^{\left(m\right)}-s_n^{(m-1)}|=|s_1^{\left(m\right)}-s_1^{(m-1)}|+|s_2^{\left(m\right)}-s_2^{(m-1)}|+...+|s_N^{\left(m\right)}-s_N^{(m-1)}|$

1.5、判断是否停止迭代运算。

如果第m迭代后的误差δ^(m)小于设定的误差门限E，即可停止迭代。如果误差δ^(m)不小于E，则返回步骤1.2继续进行迭代计算，一直到满足误差δ^(m)小于E为止。

设定误差门限E＝0.001，即误差在千分之一，则表示第m次迭代后s更新(或改变)部分的绝对值仅占s绝对值千分之一。

1.6、输出N个买家的排序值。

满足停止迭代的条件后，得到的

即是N个买家的信用排序值，信用排序值越大表示其等级越高。

2、计算卖家的信用排序排序。

卖家的信用排序计算和买家很相似，仅仅是数据大小，长度不同。

2.1、设定迭代起始值。

假设是第一次进行迭代计算，即还没有经过迭代运算，关于M个卖家的排序初始值，取M长度、内容相同的初始向量存储在某一行存储单元t内：

$t^{\left(0\right)}=\left[\begin{array}{cccc}{t}_1^{\left(0\right)}& t_2^{\left(0\right)}& ...& t_M^{\left(0\right)}\end{array}\right]=\left[\begin{array}{cccc}\frac{1}{M}& \frac{1}{M}& ...& \frac{1}{M}\end{array}\right]$

其中每一个存储的数据都相同，都是

共M个。“t⁽⁰⁾”中的0标记为迭代次数。

如果不是第一次进行迭代计算，而是进行第n次迭代计算，则同样将第n-1次迭代计算的结果：

保留在行存储器t中。

2.2、迭代计算，将B乘以t，即

$t^{\left(n\right)}=B{t}^{(n-1)T}=\left[\begin{array}{cccccc}{b}_{\mathrm{1,1}}& b_{\mathrm{1,2}}& ...& b_{1,m}& ...& b_{1,M}\\ b_{\mathrm{2,1}}& b_{\mathrm{2,2}}& ...& b_{2,m}& ...& b_{2,M}\\ ...& & & & & \\ b_{l,1}& b_{l,2}& ...& b_{l,m}& ...& b_{l,M}\\ ...& & & & & \\ b_{M,1}& b_{M,2}& ...& b_{M,m}& ...& b_{M,M}\end{array}\right]\×\left[\begin{array}{c}{t}_1^{(n-1)}\\ t_2^{(n-1)}\\ .\\ .\\ t_M^{(n-1)}\end{array}\right]$

$=\left[\begin{array}{cccccc}{t}_1^{\left(n\right)}& t_2^{\left(n\right)}& ...& t_l^{\left(n\right)}& ...& t_M^{\left(n\right)}\end{array}\right]$

其中：

$t_1^{\left(n\right)}=\underset{m=1}{\overset{M}{\mathrm{\Σ}}}(b_{1,m}\×t_m^{(n-1)})=(b_{\mathrm{1,1}}\×t_1^{(n-1)}+b_{\mathrm{1,2}}\×t_2^{(n-1)}+...+b_{1,m}\×t_m^{(n-1)}+...+b_{1,M}\×t_M^{(n-1)})$

$t_2^{\left(n\right)}=\underset{m=1}{\overset{M}{\mathrm{\Σ}}}(b_{2,m}\×t_m^{(n-1)})=(b_{2,1}\×t_1^{(n-1)}+b_{2,2}\×t_2^{(n-1)}+...+b_{2,m}\×t_m^{(n-1)}+...+b_{2,M}\×t_M^{(n-1)})$

...

$t_M^{\left(n\right)}=\underset{m=1}{\overset{M}{\mathrm{\Σ}}}(b_{M,m}\×t_m^{(n-1)})=(b_{M,1}\×t_1^{(n-1)}+b_{M,2}\×t_2^{(n-1)}+...+b_{M,m}\×t_m^{(n-1)}+...+b_{M,M}\×t_M^{(n-1)})$

2.3、进行归一化处理。

$f^{\left(n\right)}=\underset{m=1}{\overset{M}{\mathrm{\Σ}}}\left|t_m^{\left(n\right)}\right|=\left|s_1^{\left(n\right)}\right|+\left|s_2^{\left(n\right)}\right|+...+\left|s_m^{\left(n\right)}\right|+...+\left|s_M^{\left(n\right)}\right|$

$t^{\left(n\right)}=\frac{1}{f^{\left(n\right)}}\left[\begin{array}{cccccc}{s}_1^{\left(1\right)}& s_2^{\left(n\right)}& ...& s_m^{\left(n\right)}& ...& s_M^{\left(n\right)}\end{array}\right]=\left[\begin{array}{cccccc}\frac{t_1^{\left(n\right)}}{f^{\left(n\right)}}& \frac{t_2^{\left(n\right)}}{f^{\left(n\right)}}& ...& \frac{t_m^{\left(n\right)}}{f^{\left(n\right)}}& ...& \frac{t_M^{\left(n\right)}}{f^{\left(n\right)}}\end{array}\right]$

为节省存储空间起见，将第n次迭代后的

覆盖到上次迭代的同一个行存储单元

中，并作为下一次迭代的起始值。

2.4、计算迭代后的误差δ⁽ⁿ⁾

误差δ⁽ⁿ⁾表示的是第n次迭代后得到的t⁽ⁿ⁾和第n-1次得到的t^(n-1)的差距，由下式得到：

${\mathrm{\δ}}^{\left(n\right)}=\underset{m=1}{\overset{M}{\mathrm{\Σ}}}|t_m^{\left(n\right)}-t_m^{(n-1)}|=|t_1^{\left(n\right)}-t_1^{(n-1)}|+|t_2^{\left(n\right)}-t_2^{(n-1)}|+...+|t_M^{\left(n\right)}-t_M^{(n-1)}|$

2.5、判断是否停止迭代。

如果第n迭代后的误差δ⁽ⁿ⁾小于设定的误差门限E，即可停止迭代。如果误差δ⁽ⁿ⁾不小于E，则返回步骤2.2，一直到满足误差δ⁽ⁿ⁾小于E为止。

设定误差门限E＝0.001，即误差在千分之一，则表示第n次迭代后t更新(或改变)部分的绝对值仅占t绝对值千分之一。

2.6、输出M个卖家的信用排序值。

满足迭代的停止条件后，得到的

即是M个卖家的信用排序值，值越大表示其等级越高。

实施例

某个购物网站在一段时间内有5个买家和4个卖家相互交易，相互的信用评分如下表1所示。表1中每一栏都有两个数字，前者表示卖家对买家的信用评分，后者表示买家对卖家的信用评分，以十分制表示，最高10分，最低0分，当然也可以采用其它计分制。

从表1中能直观看到，买家3得到的评分较高，买家4的得分较低；买家5仅有一个评分，来自卖家2，评分为8分；卖家2得到的评分较高，卖家1得分较小；但无论如何，从表中没法直接得到一个量化的排序值来。而采用本发明的方法能够合理的给出。

表1

按照本发明对数据的处理方式，得到矩阵V和U：

$V=\left[\begin{array}{cccc}6& 4& 4& 3\\ 0& 6& 0& 7\\ 10& 9& 10& 10\\ 3& 4& 4& 2\\ 0& 8& 0& 0\end{array}\right]$ $U=\left[\begin{array}{ccccc}3& 0& 4& 4& 0\\ 8& 10& 9& 10& 9\\ 6& 0& 5& 8& 0\\ 5& 9& 4& 5& 0\end{array}\right]$

相应得到两个矩阵A和B：

$A=V\×U=\left[\begin{array}{cccc}6& 4& 4& 3\\ 0& 6& 0& 7\\ 10& 9& 10& 10\\ 3& 4& 4& 2\\ 0& 8& 0& 0\end{array}\right]\×\left[\begin{array}{ccccc}3& 0& 4& 4& 0\\ 8& 10& 9& 10& 9\\ 6& 0& 5& 8& 0\\ 5& 9& 4& 5& 0\end{array}\right]$

$=\left|\begin{array}{ccccc}89& 67& 92& 111& 36\\ 83& 123& 82& 95& 54\\ 212& 180& 211& 260& 81\\ 75& 58& 76& 94& 36\\ 64& 80& 72& 80& 72\end{array}\right|$

$B=U\×V=\left[\begin{array}{ccccc}3& 0& 4& 4& 0\\ 8& 10& 9& 10& 9\\ 6& 0& 5& 8& 0\\ 5& 9& 4& 5& 0\end{array}\right]\×\left[\begin{array}{cccc}6& 4& 4& 3\\ 0& 6& 0& 7\\ 10& 9& 10& 10\\ 3& 4& 4& 2\\ 0& 8& 0& 0\end{array}\right]$

$=\left|\begin{array}{cccc}70& 64& 68& 57\\ 168& 285& 162& 204\\ 110& 101& 106& 84\\ 85& 130& 80& 128\end{array}\right|$

A、计算买家的信用排序值，依照迭代算法，取初始排序值s为：

s⁽⁰⁾＝[0.2 0.2 0.2 0.2 0.2]^T

一次迭代后得到：

$s^{\left(1\right)}=A\×s^{\left(0\right)}$

$=\left|\begin{array}{ccccc}89& 67& 92& 111& 36\\ 83& 123& 82& 95& 54\\ 212& 180& 211& 260& 81\\ 75& 58& 76& 94& 36\\ 64& 80& 72& 80& 72\end{array}\right|\×\left[\begin{array}{c}0.2\\ 0.2\\ 0.2\\ 0.2\\ 0.2\end{array}\right]=\left[\begin{array}{c}79\\ 87\\ 188.8\\ 67\\ 73\end{array}\right]$

经过归一化操作：

f⁽¹⁾＝79+87+188.8+67+73＝496.6

s⁽¹⁾＝[79 87 188.8 67.8 73.6]^T/496.6

    ＝[0.1591 0.176 0.3802 0.1365 0.1482]^T

误差δ⁽¹⁾为：

${\mathrm{\δ}}^{\left(1\right)}=\underset{n=1}{\overset{5}{\mathrm{\Σ}}}|s_n^{\left(1\right)}-s_n^{\left(0\right)}|$

$=|0.1591-0.2|+|0.176-0.2|+|0.3802-0.2|+|0.1365-0.2|+|0.1482-0.2|$

$=0.3604$

因为δ⁽¹⁾＞设定的误差门限E＝0.001，需要进行第二次迭代运算：

$s^{\left(2\right)}=A\×s^{\left(1\right)}$

$=\left|\begin{array}{ccccc}89& 67& 92& 111& 36\\ 83& 123& 82& 95& 54\\ 212& 180& 211& 260& 81\\ 75& 58& 76& 94& 36\\ 64& 80& 72& 80& 72\end{array}\right|\×\left[\begin{array}{c}0.1591\\ 0.176\\ 0.3802\\ 0.1365\\ 0.1482\end{array}\right]=\left[\begin{array}{c}81.417\\ 87\\ 193.13\\ 69.2\\ 73.23\end{array}\right]$

经过归一化操作：

f⁽²⁾＝81.417+87+193.13+69.2+73.23＝503.973

s⁽²⁾＝[81.417 87 193.13 69.2 73.23]^T/503.973

    ＝[0.1616 0.1726 0.3832 0.1373 0.1453]^T

误差δ⁽²⁾为：

${\mathrm{\δ}}^{\left(2\right)}=\underset{n=1}{\overset{5}{\mathrm{\Σ}}}|s_n^{\left(2\right)}-s_n^{\left(1\right)}|$

$=|0.1616-0.1591|+|0.1726-0.176|+|0.3832-0.3802|+|0.1373-0.365|+|0.1453-0.1482|$

$=0.0126$

因为δ⁽²⁾＞设定的误差门限E＝0.001，需要进行第三次迭代：

$s^{\left(3\right)}=A\×s^{\left(2\right)}$

$=\left|\begin{array}{ccccc}89& 67& 92& 111& 36\\ 83& 123& 82& 95& 54\\ 212& 180& 211& 260& 81\\ 75& 58& 76& 94& 36\\ 64& 80& 72& 80& 72\end{array}\right|\×\left[\begin{array}{c}0.1616\\ 0.726\\ 0.3832\\ 0.1373\\ 0.453\end{array}\right]=\left[\begin{array}{c}81.6718\\ 86.956\\ 193.6494\\ 69.3908\\ 73.1871\end{array}\right]$

经过归一化操作：

f⁽³⁾＝81.6718+86.956+193.6494+69.3908+73.1871＝504.855

s⁽³⁾＝[81.6718 86.956 193.6496 68.3908 73.1871]^T/504.855

    ＝[0.1618 0.1722 0.3836 0.1374 0.145]^T

误差δ⁽³⁾为：

${\mathrm{\δ}}^{\left(3\right)}=\underset{n=1}{\overset{5}{\mathrm{\Σ}}}|s_n^{\left(3\right)}-s_n^{\left(2\right)}|$

$=|0.1618-0.1616|+|0.1722-0.1726|+|0.3836-0.3832|+|0.1374-0.1373|+|0.145-0.1453|$

$=0.0014$

因为δ⁽³⁾＞设定的误差门限E＝0.001，需要进行第四次迭代：

$s^{\left(4\right)}=A\×s^{\left(3\right)}$

$=\left|\begin{array}{ccccc}89& 67& 92& 111& 36\\ 83& 123& 82& 95& 54\\ 212& 180& 211& 260& 81\\ 75& 58& 76& 94& 36\\ 64& 80& 72& 80& 72\end{array}\right|\×\left[\begin{array}{c}0.1618\\ 0.722\\ 0.3826\\ 0.1374\\ 0.145\end{array}\right]=\left[\begin{array}{c}81.7021\\ 86.9513\\ 193.7116\\ 69.4133\\ 73.1833\end{array}\right]$

经过归一化操作：

f⁽⁴⁾＝81.7021+86.9513+193.7116+69.4133+73.1833＝504.9616

s⁽⁴⁾＝[81.7021 86.9513 193.7116 69.4133 73.1833]^T/504.9616

    ＝[0.1618 0.1722 0.3836 0.1375 0.1449]^T

误差δ⁽⁴⁾为：

${\mathrm{\δ}}^{\left(4\right)}=\underset{n=1}{\overset{5}{\mathrm{\Σ}}}|s_n^{\left(4\right)}-s_n^{\left(3\right)}|$

$=|0.1618-0.1618|+|0.1722-0.1722|+|0.3836-0.3836|+|0.1375-0.1374|+|0.1449-0.145|$

$=0.0002$

因为δ⁽⁴⁾＜设定的误差门限E＝0.001，满足误差要求，循环迭代停止。

最后得到sBs⁽⁴⁾＝[0.1618 0.1722 0.3836 0.1375 0.1449]^T

B、计算卖家的信用排序值，依照迭代算法，取初始排序值t为：

t⁽⁰⁾＝[0.25 0.25 0.25 0.25]^T

一次迭代后得到：

$t^{\left(1\right)}=B\×t^{\left(0\right)}$

$=\left|\begin{array}{cccc}70& 64& 68& 57\\ 168& 285& 162& 204\\ 110& 101& 106& 84\\ 85& 130& 80& 128\end{array}\right|\×\left[\begin{array}{c}0.25\\ 0.25\\ 0.25\\ 0.25\end{array}\right]=\left[\begin{array}{c}64.75\\ 204.75\\ 100.25\\ 105.75\end{array}\right]$

经过归一化操作：

f⁽¹⁾＝64.75+204.75+100.25+105.75＝475.5

t⁽¹⁾＝[64.75 204.75 100.25 105.75]^T/475.5

    ＝[0.1362 0.4306 0.2108 0.2224]^T

误差δ⁽¹⁾为：

${\mathrm{\δ}}^{\left(1\right)}=\underset{n=1}{\overset{4}{\mathrm{\Σ}}}|t_n^{\left(1\right)}-t_n^{\left(0\right)}|$

$=|0.1362-0.25|+|0.4306-0.25|+|0.2108-0.25|+|0.2224-0.25|$

$=0.3612$

因为δ⁽¹⁾＞设定的误差门限E＝0.001，需要进行第二次迭代运算。

......

以下的过程和A中计算计算买家的信用排序值迭代过程一致，故省略详细步骤。经过四次迭代后，满足了δ＜设定的误差门限E的要求。每次迭代的计算结果如下表2所示：

表2

经过上述操作之后最终的结果为：

s＝[0.1618 0.1722 0.3836 0.1375 0.1449]^T

t＝[0.1267 0.4509 0.1966 0.2258]^T

在本例中最后的以信用得分从高到低排序如下表3：

买家

三

二

一

五

四

排序名次	1	2	3	4	5
						Rank值	0.3836	0.1722	0.1618	0.1449	0.1375
卖家	二	四	三	一	-
						排序名次	1	2	3	4	-
Rank值	0.4509	0.2258	0.1966	0.1267	-

表3

本发明的方法充分、综合地考虑了所有的评分值来得到每个卖家和买家的合理Rank值。简单说来，如果一个卖家的Rank值高，则他给买家的评分值的权重就会高，因此买家的Rank值也会更合理；反之亦然，某个买家的Rank值很低，则他给卖家的评分的权值就很小，卖家们的Rank值也更合理。在这个体系中，所有的卖家、买家既是评价者、也是被评价者，投票的权重就是投票者自己的Rank值，也就是Rank值越高的人所投出票的“话语权”越大。只有很多Rank值很高的评分者给你的评分也较高的时候，你才可能得到很高的Rank值，充分体现了平等的思想。

有了可靠的对买家和卖家的信用等级排序，就可以对不同的用户的交易范围、额度、权限等做相应的规范，其应用非常广泛。这个排序值是交易平台，特别是网络交易平台中非常重要的数据。

本发明的方法不仅仅适用于买卖双方这一相互评分的模型，还可用于其它很多“一对一”互评的场景，比如：“教和学”相互评分中的等级排序，每个老师对学生给个评分；每个学生也给老师评分，相互的评分结果也可构造成矩阵U和V，用同样的算法，也能得到所有学生和老师的排序s和t。还有“上级和下级”互相考核指标、“管理者和被管理者”相互评分等等系统中。

另外，本发明的方法还可以用在特定的子集合中元素的排序：各个级别(幼、初、中、高、专业)教师和学生的排序；不同类型(地域、学科、偏好、性别等)卖家、买家的排序等等。

以上通过具体实施方式和实施例对本发明进行了详细的说明，但这些并非构成对本发明的限制。在不脱离本发明原理的情况下，本领域的技术人员还可做出许多变形和改进，这些也应视为本发明的保护范围。

Claims (8)

1.一种交易系统中买卖双方信用的等级排序方法，其特征在于，包括如下步骤：

步骤一、原始数据预处理；

设第j个卖家为第i个买家的信用评分为v_i，j，则将所有的卖家给买家的信用评分存储到二维存储矩阵V中；

设第i个买家为第j个卖家的信用评分为u_j，i，则将所有的买家给卖家的信用评分存储到二维存储矩阵U中；

步骤二、计算两个核心矩阵A和B，其中，A为一个N行N列的正方形存储矩阵，它由所述的存储矩阵V和U中的数值经过矩阵相乘运算得到；B为一个M行M列的正方形存储矩阵，它是由所述的存储矩阵U和V中的数值经过矩阵相乘运算得到；

步骤三、进行迭代运算，分别计算买家和卖家的信用排序值。

2.如权利要求1所述的方法，其特征在于，步骤三所述的计算买家的信用排序值采用如下方法：

步骤a、设定迭代起始值s；

步骤b、进行迭代运算，将A乘以s；

步骤c、进行归一化处理；

步骤d、计算迭代后的误差δ^(m)；

步骤e、判断误差δ^(m)是否小于设定的误差门限E，如果小于则停止迭代运算，输出N个买家的信用排序值；否则，返回步骤b，继续进行迭代运算。

3.如权利要求2所述的方法，其特征在于：步骤a所述的迭代起始值s，如果是第一次进行迭代计算，则取N长度、内容相同的初始向量存储在某一行存储单元s内；

如果已进行了第m次迭代运算，则将第m-1次迭代计算的结果保留在行存储器s中。

4.如权利要求2所述的方法，其特征在于，步骤c所述的归一化处理后，将第m次迭代后的s^(m)覆盖到上次迭代的同一个行存储单元s^(m-1)中，并作为下一次迭代的起始值。

5.如权利要求1所述的方法，其特征在于，步骤三所述的计算卖家的信用排序值采用如下方法：

步骤A、设定迭代起始值t；

步骤B、进行迭代运算，将B乘以t；

步骤C、进行归一化处理；

步骤D、计算迭代后的误差δ⁽ⁿ⁾；

步骤E、判断误差δ⁽ⁿ⁾是否小于设定的误差门限E，如果小于则停止迭代运算，输出M个买家的信用排序值；否则，返回步骤B，继续进行迭代运算。

6.如权利要求5所述的方法，其特征在于：步骤A所述的迭代起始值t，如果是第一次进行迭代计算，则取M长度、内容相同的初始向量存储在某一行存储单元t内；

如果已进行了第n次迭代运算，则将第n-1次迭代计算的结果保留在行存储器t中。

7.如权利要求5所述的方法，其特征在于，步骤C所述的归一化处理后，将第n次迭代后的t⁽ⁿ⁾覆盖到上次迭代的同一个行存储单元t^(n-1)中，并作为下一次迭代的起始值。

8.如权利要求1所述的方法，其特征在于，步骤一中所述的存储矩阵V和U中，如果某一买家i和卖家j没有交易，则双方没有互相打分，矩阵中的相应的v_i，ju_j，i都填0。

Images