Question

我正在尝试为“朋友的朋友”算法编写自己的代码。此算法作用于一组三维数据点，并返回数据集中“晕圈”的数量。每个光环是一个点的集合，其距离小于链接长度b，是程序的唯一参数。

算法描述： FOF算法有一个称为链接长度的自由参数。以小于或等于连接长度的距离分开的任何两个粒子称为“朋友”。然后，FOF组由粒子集定义，集合中的每个粒子通过朋友网络连接到集合中的每个其他粒子。

设置FOF组计数器j = 1。

对于每个粒子，n，尚未与任何组相关联：
将n分配给组j，为组j初始化一个新成员列表mlist，其中粒子n为第一个条目，
递归地，对于mlist中的每个新粒子p：
找到距离小于或等于链接长度的p的邻居，添加到已经分配给j组的mlist，
记录组j的mlist，设置j = j + 1。

这是我尝试编写算法的代码。我这样做的唯一语言就是Python。但是，我需要在Fortran中编写此代码或使其更快。我真的希望有人能帮助我。

首先，我生成一组应该模仿3晕的存在点：

import random
from random import *
import math
from math import *
import numpy
from numpy import *
import time

points = 1000

halos=[0,100.,150.]

x=[]
y=[]
z=[]
id=[]
for i in arange(0,points,1):
   x.append(halos[0]+random())
   y.append(halos[0]+random())
   z.append(halos[0]+random())
   id.append(i)

for i in arange(points,points*2,1):
   x.append(halos[1]+random())
   y.append(halos[1]+random())
   z.append(halos[1]+random())
   id.append(i)

for i in arange(points*2,points*3,1):
   x.append(halos[2]+random())
   y.append(halos[2]+random())
   z.append(halos[2]+random())
   id.append(i)

然后我编码了FOF算法：

  x=array(x)
  y=array(y)
  z=array(z)
  id=array(id)

  t0 = time.time()                         

  id_grp=[]
  groups=zeros((len(x),1)).tolist()
  particles=id
  b=1 # linking length
  while len(particles)>0:
  index = particles[0]
  # remove the particle from the particles list
  particles.remove(index)
  groups[index]=[index]
  print "#N ", index
  dx=x-x[index]
  dy=y-y[index]
  dz=z-z[index]
  dr=sqrt(dx**2.+dy**2.+dz**2.)
  id_to_look = where(dr<b)[0].tolist()
  id_to_look.remove(index)
  nlist = id_to_look
  # remove all the neighbors from the particles list
  for i in nlist:
        if (i in particles):
           particles.remove(i)
  print "--> neighbors", nlist
  groups[index]=groups[index]+nlist
  new_nlist = nlist
  while len(new_nlist)>0:
          index_n = new_nlist[0]
          new_nlist.remove(index_n)
          print "----> neigh", index_n
          dx=x-x[index_n]
          dy=y-y[index_n]
          dz=z-z[index_n]
          dr=sqrt(dx**2.+dy**2.+dz**2.)
          id_to_look = where(dr<b)[0].tolist()
          id_to_look = list(set(id_to_look) & set(particles))
          nlist = id_to_look
          if (len(nlist)==0):
             print "No new neighbors found"
          else:
             groups[index]=groups[index]+nlist
             new_nlist=new_nlist+nlist
             print "------> neigh-neigh", new_nlist
             for k in nlist:
               particles.remove(k)

最后，我们会在列表groups

中找到一个光环列表

这部分代码有点偏离主题，但我认为向你展示它会很好。我基本上删除所有没有粒子的组，根据粒子数量排序并显示一些属性。

  def select(test,list):
  selected = []
  for item in list:
    if test(item) == True:
      selected.append(item)
  return selected

  groups=select(lambda x: sum(x)>0.,groups)
  # sorting groups
  groups.sort(lambda x,y: cmp(len(x),len(y)))
  groups.reverse()

  print time.time() - t0, "seconds"

  mass=x
  for i in arange(0,len(groups),1):
    total_mass=sum([mass[j] for j in groups[i]])
    x_cm = sum([mass[j]*x[j] for j in groups[i]])/total_mass
    y_cm = sum([mass[j]*y[j] for j in groups[i]])/total_mass
    z_cm = sum([mass[j]*z[j] for j in groups[i]])/total_mass
    dummy_x_cm = [x[j]-x_cm for j in groups[i]]
    dummy_y_cm = [y[j]-y_cm for j in groups[i]]
    dummy_z_cm = [z[j]-z_cm for j in groups[i]]
    dummy_x_cm = array(dummy_x_cm)
    dummy_y_cm = array(dummy_y_cm)
    dummy_z_cm = array(dummy_z_cm)
    dr = max(sqrt(dummy_x_cm**2.+dummy_y_cm**2.+dummy_z_cm**2.))
    dummy_x_cm = max(dummy_x_cm)
    dummy_y_cm = max(dummy_y_cm)
    dummy_z_cm = max(dummy_z_cm)
    print i, len(groups[i]), x_cm, y_cm, z_cm,dummy_x_cm,dummy_y_cm,dummy_z_cm

Answer 1

我认为你开始学习Fortran是不明智的，希望得到的代码比你当前的实现更快。它最终可能是，但我认为你最好尽可能快地实现你的Python实现，然后再考虑用另一种语言实现，特别是外语。

我写Fortran，我个人觉得它的性能在整个Python中都很生气，但是那些了解这些内容的人提供了令人信服的论据，即如果精心设计，Python + SciPy + Numpy可以在许多计算内核中与Fortran匹配科学/工程专业。不要忘记，在计算机上的所有核心都运行得很热之前，您还没有优化Python。

所以：

1st - 在Python中获得有效的实现。

第二 - 尽可能快地实施。

IF（大写字母，因为它是一个很大的'if'）代码仍然不够快，并且将其翻译成编译语言的成本/收益是有利的然后考虑将其转换为哪种编译语言。如果你在Fortran被广泛使用的领域，那么通过各种方式学习Fortran，但它是一种小众语言，它可能有利于你的职业生涯更多地学习C ++或其中一个亲戚。

编辑（太长，无法放入评论框）

为什么在你的问题中误导我们？你声明你唯一熟悉的语言是Python，现在你说你知道Fortran。我猜你一定很不舒服。而且，根据您的评论，似乎您真正需要的帮助可能是让您的Python实现更快; Sideshow Bob提出了一些建议。考虑到这一点，然后并行化。

Answer 2

指向更有效算法的指针。如果我没有弄错的话，你会将一个点与其他每一点进行比较，看看是否有一点比链接长度更近。对于大量的点，有更快的方法找到近邻 - 空间索引和KD树从我的头顶，但无疑还有其他方法也适合你。

Answer 3

如果你有一个现代显卡，你可以使用PyOpenCL在Python代码中对数百个处理器（取决于你的卡）进行并行化。

您可以调查以查看算法FoF是否在此voidfinder F90 code

中实现

您可以将距离定义为平方距离，以避免使用sqrt（）并使用x * x而不是x ** 2 ...

用Python编写的朋友之友算法需要在Fortran 90/95中

3 个答案: