Question

如何在分布式计算中计算大型向量（系列）的算术平均值，我在多个节点上对数据进行分区。我不想使用map reduce范例。是否存在任何分布式算法来有效地计算平均值，除了在每个节点上的各个和的平凡计算，然后将结果带到主节点并且除以向量的大小（系列）。

Answer 1

分布式平均共识是另一种选择。

map-reduce与master的简单方法的问题在于，如果你拥有大量数据，实质上是为了使所有内容彼此依赖，可能需要很长时间来计算数据，哪个时候信息非常过时，因此是错误的，除非你锁定整个数据集 - 对于大量的分布式数据集是不切实际的。使用分布式平均一致性（相同的方法适用于替代算法的均值），您可以获得更新，更好地猜测均值的当前值而不会锁定数据，并且实时。这是一篇关于它的论文的链接，但它的数学很重要： http://web.stanford.edu/~boyd/papers/pdf/lms_consensus.pdf 你可以谷歌上写很多论文。

一般概念是这样的：在每个节点上说你有一个套接字监听器。您评估本地总和和平均值，然后将其发布到其他节点。每个节点都侦听其他节点，并在有意义的时间刻度上接收它们的总和和平均值。然后你可以通过（sumForAllNodes（storedAverage [node] * storedCount [node]）/（sumForAllNodes（storedCount [node]））评估总平均值的好猜测。如果你有一个真正大的数据集，你可以只听新的它们存储在节点中的值，并修改本地计数和平均值，然后发布它们。

如果这花费太长时间，您可以对每个节点中的数据的随机子集进行平均。

这里有一些c＃代码可以给你一个想法（使用fleck在比Windows-10-only microsoft websockets实现更多版本的Windows上运行）。在两个节点上运行它，一个用

<appSettings>
    <add key="thisNodeName" value="UK" />
</appSettings>

在app.config中

，并使用＆＃34; EU-North＆＃34;在另一个。这是一些示例代码。这两个实例使用websockets交换装置。您只需要添加数据库的后端枚举。

using Fleck;

namespace WebSocketServer
{
    class Program
    {
        static List<IWebSocketConnection> _allSockets;
        static Dictionary<string,decimal> _allMeans;
        static Dictionary<string,decimal> _allCounts;
        private static decimal _localMean;
        private static decimal _localCount;
        private static decimal _localAggregate_count;
        private static decimal _localAggregate_average;

        static void Main(string[] args)
        {
            _allSockets = new List<IWebSocketConnection>();
            _allMeans = new Dictionary<string, decimal>();
            _allCounts = new Dictionary<string, decimal>();

            var serverAddresses = new Dictionary<string,string>();
            //serverAddresses.Add("USA-WestCoast", "ws://127.0.0.1:58951");
            //serverAddresses.Add("USA-EastCoast", "ws://127.0.0.1:58952");
            serverAddresses.Add("UK", "ws://127.0.0.1:58953");
            serverAddresses.Add("EU-North", "ws://127.0.0.1:58954");
            //serverAddresses.Add("EU-South", "ws://127.0.0.1:58955");
            foreach (var serverAddress in serverAddresses)
            {
                _allMeans.Add(serverAddress.Key, 0m);
                _allCounts.Add(serverAddress.Key, 0m);
            }

            var thisNodeName = ConfigurationSettings.AppSettings["thisNodeName"];   //for example "UK"
            var serverSocketAddress = serverAddresses.First(x=>x.Key==thisNodeName);
            serverAddresses.Remove(thisNodeName);

            var websocketServer = new Fleck.WebSocketServer(serverSocketAddress.Value);

            websocketServer.Start(socket =>
            {
                socket.OnOpen = () =>
                {
                    Console.WriteLine("Open!");
                    _allSockets.Add(socket);
                };
                socket.OnClose = () =>
                {
                    Console.WriteLine("Close!");
                    _allSockets.Remove(socket);
                };
                socket.OnMessage = message =>
                {
                    Console.WriteLine(message + " received");

                    var parameters = message.Split('~');
                    var remoteHost = parameters[0];
                    var remoteMean = decimal.Parse(parameters[1]);
                    var remoteCount = decimal.Parse(parameters[2]);
                    _allMeans[remoteHost] = remoteMean;
                    _allCounts[remoteHost] = remoteCount;


                };
            });
            while (true)
            {
                //evaluate my local average and count
                Random rand = new Random(DateTime.Now.Millisecond);
                _localMean = 234.00m + (rand.Next(0, 100) - 50)/10.0m;
                _localCount = 222m + rand.Next(0, 100);

                //evaluate my local aggregate average using means and counts sent from all other nodes
                //could publish aggregate averages to other nodes, if you wanted to monitor disagreement between nodes
                var total_mean_times_count = 0m;
                var total_count = 0m;
                foreach (var server in serverAddresses)
                {
                    total_mean_times_count += _allCounts[server.Key]*_allMeans[server.Key];
                    total_count += _allCounts[server.Key];
                }
                //add on local mean and count which were removed from the server list earlier, so won't be processed
                total_mean_times_count += (_localMean * _localCount);
                total_count = total_count + _localCount;

                _localAggregate_average = (total_mean_times_count/total_count);
                _localAggregate_count = total_count;

                Console.WriteLine("local aggregate average = {0}", _localAggregate_average);

                System.Threading.Thread.Sleep(10000);
                foreach (var serverAddress in serverAddresses)
                {
                    using (var wscli = new ClientWebSocket())
                    {
                        var tokSrc = new CancellationTokenSource();
                        using (var task = wscli.ConnectAsync(new Uri(serverAddress.Value), tokSrc.Token))
                        {
                            task.Wait();
                        }

                        using (var task = wscli.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(thisNodeName+"~"+_localMean + "~"+_localCount)),
                            WebSocketMessageType.Text,
                            false,
                            tokSrc.Token
                            ))
                        {
                            task.Wait();
                        }
                    }

                }
            }
        }



    }
}

不要忘记在给定时间通过同步添加静态锁定或单独活动。（为简单起见未示出）

Answer 2

您可以使用两种简单的方法。

正如您所正确指出的那样，一个是计算每个节点上的总和，然后将总和除以总数据量：

avg = (sum1+sum2+sum3)/(cnt1+cnt2+cnt3)

另一种可能性是计算每个节点的平均值，然后使用加权平均值：

avg = (avg1*cnt1 + avg2*cnt2 + avg3*cnt3) / (cnt1+cnt2+cnt3)
    = avg1*cnt1/(cnt1+cnt2+cnt3) + avg2*cnt2/(cnt1+cnt2+cnt3) + avg3*cnt3/(cnt1+cnt2+cnt3)

我没有看到这些微不足道的方法有任何问题，我想知道你为什么要使用不同的方法。

如何计算分布式数据的均值？

2 个答案: