Question

首先帮助解释这个难题的背景：

我有一个数据库，通过比较用户提交的全球平均值来估算用户的可靠性。值范围介于0和1之间。那么，在哪里：

此特定用户的可靠性= r
此特定用户提交的值的平均值= a
Global，“同意”average = g

可靠性：

r = 1 - ABS(g - a)

这是计算每个用户的可靠性的方式。现在，全球“同意”平均g使用加权平均值计算，其中权重为r，值为a。如果总共有3个用户：

  g = ((r1 * a1) + (r2 * a2) + (r3 * a3)) / (r1 + r2 + r3)

问题是，一旦用户具有高可靠性，他们就拥有完全的垄断权，没有新的价值观可以改变这一点。举个例子：

g was initially 0.5
user1 r was initially 0.5
user2 r was initially 0.5
user3 r was initially 0.5

现在，他们将逐一提交值，并观察会发生什么：

user1 a is submitted, 1.0
user1 reliability goes slightly down because it differs from g (0.5)
user2 a is submitted, 1.0
user1 and user2 reliability go up to 100%, g is now 1.0.
user3 a is submitted, 0.0
user3 reliability goes down to 0%. g is still 1.0.

由于user3的可靠性非常低，因此加权对g完全没有任何影响。 User3的可靠性下降，因为提交的值与全球平均值完全不同。如何使user3的提交对最终值产生某种影响？也许我需要添加一些常量，以便可靠性永远不会完全为零（但接近）？

现在，对于SQL代码。我添加了一个演示问题的SQL小提琴： http://sqlfiddle.com/#!3/d3fd1/21 我已经抽象了代码以保持它的简短，但它仍然很长。

表创建，存储过程和触发器：

-- Stores user info
CREATE TABLE dbo.Users(
    [UserID] [int] NOT NULL,
    [Reliability] [float] NOT NULL
  )

-- Contains global averages from all users who submitted data
CREATE TABLE dbo.GlobalSubmission(
    GlobalSubmissionID  [int] NOT NULL,
    Name [varchar](50) NULL,
    GlobalAverage [float] NOT NULL,
)

CREATE TABLE dbo.UserSubmission(
    SubValue float NOT NULL,
    GlobalSubmissionID int NOT NULL,
    UserID int NOT NULL,
)


GO

--Calculate the "ideal value", used for GlobalSubmission.
CREATE FUNCTION dbo.IdealValueCalc(@globalSubmissionID INT)
RETURNS int
AS
BEGIN

DECLARE @tmpReliability TABLE (SubValue float, Reliability float)


INSERT INTO @tmpReliability
    SELECT AVG(us.SubValue) as SubValue, usr.Reliability Reliability FROM UserSubmission us
    JOIN Users usr 
    ON us.UserID = usr.UserID
    WHERE GlobalSubmissionID = @GlobalSubmissionID
    GROUP BY us.UserID, usr.Reliability

--Perform weighted mean calculations.
Return (SELECT SUM(SubValue * Reliability) / SUM(Reliability) FROM @tmpReliability)
END
go


--Calculate the reliability of one user.
CREATE FUNCTION dbo.GetReliabilityForUser
(@userID int)
Returns Float
AS BEGIN
Return (SELECT 1 - AVG(ABS(db.userAvg - db.GlobalAverage))
    FROM (
      SELECT pmd.UserID,
            gs.GlobalAverage, 
            AVG(pmd.SubValue) as userAvg
      FROM UserSubmission pmd
      -- Joins average value for each user with "ideal" value from GlobalSubmission
      JOIN GlobalSubmission gs 
        ON gs.GlobalSubmissionID = pmd.GlobalSubmissionID
        WHERE pmd.UserID = 1
      GROUP BY pmd.UserID, gs.GlobalSubmissionID, gs.GlobalAverage
     ) db
     GROUP BY db.UserID)
End
go



CREATE TRIGGER trg_SubmissionComputation
ON UserSubmission 
AFTER INSERT, UPDATE
AS BEGIN
    --Calculate this uer's reliability
    DECLARE @userID int = (SELECT TOP(1) UserID FROM inserted)
    DECLARE @userReliability float = dbo.GetReliabilityForUser(@userID)

    UPDATE Users
    SET Reliability=@userReliability
    WHERE UserID = @userID

    --Recalculate globalSubmission values:
    DECLARE @globalSubmissionID int = (SELECT TOP(1) GlobalSubmissionID FROM inserted)
    DECLARE @globalAverage float = dbo.IdealValueCalc(@globalSubmissionID)
        --The global average for this set of submissions has been recalculated. Now inserting:

    UPDATE GlobalSubmission
    SET GlobalAverage = @globalAverage 
    WHERE GlobalSubmissionID = @globalSubmissionID
END
GO

测试它：

--Creating 3 new users
INSERT INTO Users
(UserID, Reliability)
values 
(1, 0.5),
(2, 0.5),
(3, 0.5)
GO

--Creating a new GlobalSubmission
INSERT INTO GlobalSubmission
(GlobalSubmissionID, NAME, GlobalAverage)
values (1, 'BOILER2B' , 0.5)
GO

--First, we will submit values of 1 for two users:
INSERT INTO UserSubmission values (1.0, 1, 1); -- Value: 1.0, User 1, Submission 1
GO
INSERT INTO UserSubmission values (1.0, 1, 2); -- Value: 1.0, User 2, Submission 1
GO
INSERT INTO UserSubmission values (1.0, 1, 1); -- Value: 1.0, User 1, Submission 1
GO
INSERT INTO UserSubmission values (1.0, 1, 2); -- Value: 1.0, User 2, Submission 1
GO


--Now, we will submit values of 0 for the third user:
INSERT INTO UserSubmission values (0.0, 1, 3); -- Value: 0.0, User 3, Submission 1
GO
INSERT INTO UserSubmission values (0.0, 1, 3); -- Value: 0.0, User 3, Submission 1
GO

SELECT * FROM Users -- This results in 0% reliability for the last user.

--If we create new users and add them, the reliability won't budge:
INSERT INTO Users
(UserID, Reliability)
values 
(4, 0.5),
(5, 0.5),
(6, 0.5),
(7, 0.5),
(8, 0.5)
GO


INSERT INTO UserSubmission values (0, 1, 4); -- Value: 0, User 4, Submission 1
GO
INSERT INTO UserSubmission values (0, 1, 5); -- Value: 0, User 5, Submission 1
GO
INSERT INTO UserSubmission values (0, 1, 6); -- Value: 0, User 6, Submission 1
GO
INSERT INTO UserSubmission values (0, 1, 7); -- Value: 0, User 7, Submission 1
GO
INSERT INTO UserSubmission values (0, 1, 8); -- Value: 0, User 8, Submission 1
GO
INSERT INTO UserSubmission values (0, 1, 4); -- Value: 0, User 4, Submission 1
GO
INSERT INTO UserSubmission values (0, 1, 5); -- Value: 0, User 5, Submission 1
GO
INSERT INTO UserSubmission values (0, 1, 6); -- Value: 0, User 6, Submission 1
GO
INSERT INTO UserSubmission values (0, 1, 7); -- Value: 0, User 7, Submission 1
GO
INSERT INTO UserSubmission values (0, 1, 8); -- Value: 0, User 8, Submission 1
GO


SELECT * FROM Users -- Even though we've added loads of new users suggesting 0 as value, the final value
-- is remaining 1.0, because when a new value (0) is submitted, it varies too much from the global average
--(1), causing the reliability of that user to go down, and that user ends up making no influence on the
-- global average!

Answer 1

这是一个替代估计，仍然有点临时但不会产生权重0。

1）对于每个用户产生指数衰减的平方误差估计。以可调任意估计K开始。然后，每当用户产生值a并且组均值为g时，产生平方误差E =（a-g）*（a-g）并将之前的平方误差估计值改变为after = before * x + E *（1 - x）其中x是0和1之间的另一个可调谐常数，它调整旧估计衰减的速度。这个估计值永远不会降到零，但是由于下一步，它可能会阻止它降低到某个可调值以下。

2）要获得新的全局估计，请像以前一样使用加权平均值，但使权重为该用户当前平方误差估计值的倒数。

如果所有用户都是无偏的，则指数衰减估计可能最终为每个用户的平均误差的合理估计，然后权重将是估计的线性组合，其最小化全局估计的预期平方误差。检查：如果不同的用户我提交了来自同一来源的Ni估计值的平均值，那么每个用户估计的均方误差将是1 / Ni，因此乘以其倒数会将它们的平均值转换为每个用户的估计值的原始总和。用户和加权估算最终只能汇总估算值。

Answer 2

第一个建议，摆脱绝对差异。他们使数学比应该更难。使用方差来保持简单。

跟踪每个用户提交值的总和和数量。

g =（sum1 * r1 + sum2 * r2 + sum3 * r3）/（count1 * r1 + count2 * r2 + count3 * r3）

将总和初始化为0.5，计数为1，r为1.0。

每当您收到评级时，请使用以下各项更新该用户的总和和计数，总体g和可靠性：

r = 1-（g - sum / count）^ 2.

基本上，您正在跟踪一些“先前”的评级。如果将count初始化为大数，则算法可以抵抗错误提交的值，但需要更多时间来收敛。如果减少初始计数（极端情况为0），则完全相反。

Answer 3

在计算新的全局均值之前，不要更新用户的可靠性。

g was initially "don't care"
user1 r was initially 0.5
user2 r was initially 0.5
user3 r was initially 0.5

然后

user1 a is submitted, 1.0
g = (0.5)*(1.0)/(0.5) = 1.0
user1 reliability = 1 - ABS (1 -1) = 1
user2 a is submitted, 1.0
g = ((1.0)*(1.0) + (0.5)*(1.0))/(1 + 0.5) = 1.0
user1 reliability = 1 - ABS (1 -1) = 1
user2 reliability = 1 - ABS (1 -1) = 1
user3 a is submitted, 0.0
g = ((1.0)*(1.0) + (1.0)*(1.0) + (0.5)*(0))/(1 + 1 + 0.5) = 0.8
user1 reliability = 1 - ABS (0.8 -1) = 0.8
user2 reliability = 1 - ABS (0.8 -1) = 0.8
user3 reliability = 1 - ABS (0.8 - 0.0) = 0.2

加权平均死锁：值取决于值

3 个答案: