BlogJava-Skynet-随笔分类-算法/函数

跟我一起学 - 算法导论 - 线性时间排序

刘凯毅 — Tue, 08 Dec 2009 06:21:00 GMT

下面介绍的排序都为：非比较排序法

这里个人认为在某些特定的地方非比较排序的速度非常明显；
比如：对待排数据中有顺序分类，使用鸽巢总体分类，然后对不同类别的待排小数据集合采用插入，快排等排序方式

Counting sort ：计数排序
描述：迭代待排序数组出元素x，确定小于此元素[z]个数，然后把x放到它在的最终输出数组[z]上。
特性：与待排值有关；稳定的排序算法；待排序数据要求过于严格，无实际用处；
算法的步骤如下：
   1. 找出待排序的数组中最大和最小的元素
   2. 统计数组中每个值为i的元素出现的次数，存入数组C的第i项
   3. 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
   4. 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

Radix sort：基数排序
描述：将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零. 然后, 从最低位开始, 依次进行一次排序.这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列.
排序方式：LSD 由右向左排；MSD 由左向右排
特性：非比较排序；待排数据需要统一格式；
假设需排序数列的取值范围从1...k,我们于是建一个K+1元的数组 a[]，并赋初值为0，然后便开始排序工作：
算法的步骤如下：
   1. 按输入顺序读入数列，如果所读的元素为i(1<=i<=k),我们就将a[i]的值加一，这样直到读完所有的元素。
   2. 读出元素并排序：我们遍历整个数组，如果a[i]=j(j>=0),我们就输出j次i(表示元素i在原先数列中出现了j次),这样输出的序列就是已排序的。
   3. 由于一般排序算法涉及到元素之间的比较，如果化成比较树可以知道，这样的排序算法复杂度的下限是O(N*lnN),而计数排序没有比较元素，所以所需排序时间就少了，我们可以看到计数排序的复杂度为O(n*k)，其中k（k的定义同上）为合并排列所需的时间，是个常数。
   4. 此算法适合所需排列的元素取值范围不大的情况下，否则会造成空间的消耗，比如，一共100个元素，其取值范围从1-100000，显然这个时候用基数排序是不合适的。

Bucket sort：桶排序
描述：工作的原理是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。
桶排序以下列程序进行：
   1. 设置一个定量的阵列当作空桶子。
   2. 寻访序列，并且把项目一个一个放到对应的桶子去。
   3. 对每个不是空的桶子进行排序。
   4. 从不是空的桶子里把项目再放回原来的序列中。

Pigeonhole sort：鸽巢排序
描述：是一种时间复杂度为O(n)且在不可避免遍历每一个元素并且排序的情况下效率最好的一种排序算法. 但它只有在差值(或者可被映射在差值)很小的范围内的数值排序的情况下实用.
算法的步骤如下：与桶排同

刘凯毅 2009-12-08 14:21 发表评论

跟我一起学 - 算法导论 - 快速排序

刘凯毅 — Thu, 03 Dec 2009 09:11:00 GMT

# 快排和分治很像都是分而治之 ，但他们却是相反的方式排序：
分治是想拆分完成后，合并以有序的小段进行排序，而快排是直接由原始的“拆分”来排序。

#encoding=utf-8
#从大到小
def partition(A,p,r):
    tmp=A[p]
    while True :
        while p+1<r and A[p] > tmp : p+=1
        while r-1>p and A[r] <= tmp : r-=1
    if A[p]<=A[r]: A[p],A[r]=A[r],A[p]
    if r-1<=p : return p

def quickSort(A,p,r):
    if p<r:
        q=partition(A,p,r)
        quickSort(A,p,q)
        quickSort(A,q+1,r)

A=[9,61,7,14,-1,7,667,3,6,8]
print A
quickSort(A,0,len(A)-1)
print A
# 结果 [667, 61, 14, 9, 8, 7, 7, 6, 3, -1]

图解：
一次迭代过程描述（从小到大）：
1. 以 A[0] 为切分点用临时变量记录这里是 切分点 = [5]
2. 分别起 2枚指针 [切分起左,右]
3. 分别向中间靠拢，当左指针指向值大于切分点停止左，右指针指向值小于切分点停止右。
4. 判断是否是停止点上左值小于右值是：交换两指针值！

第一次迭代后 :
以初始分隔 [5] 就已经切分好了小于 5 的左，大于等于5 的右

刘凯毅 2009-12-03 17:11 发表评论

跟我一起学 - 算法导论 - 堆

刘凯毅 — Tue, 01 Dec 2009 04:05:00 GMT

转自【http://www.cnblogs.com/coderzh/archive/2008/09/22/1296195.html】
作者：CoderZh（CoderZh的技术博客 - 博客园）
出处：http://coderzh.cnblogs.com/
# 我这加了些个人理解的说明

#encoding:UTF-8
# [递归] - 单条路自下往上排序
def heap_adjust(data, s, m):
    if 2 * s > m:return

    # 声明预设父节点位置
    temp = s - 1

    # [左]子节点值大于父节点值  :  预设父节点位置为左子节点位置
    if data[2*s - 1] > data[temp]: temp = 2*s-1

    # [右]子节点值大于预设父节点 : 预设父节点位置为右子节点位置
    if 2 * s <= m - 1 and data[2*s] > data[temp]: temp = 2 * s

    # 交换值满足堆特性此为 [ 父节点小于子节点  ]
    if temp <> s - 1:
        data[s - 1], data[temp] = data[temp], data[s - 1]
        heap_adjust(data, temp + 1, m)

def heap_sort(data):
    m = len(data) / 2
    # 构建堆树
    # 测试数据 [3,2,1] 数组值为所以非底层叶节点
    for i in range(m , 0, -1):
        heap_adjust(data, i, len(data))


    # 从堆树中 [出栈] 排序输出
    # 测试数据 [5, 4, 3, 2]
    data[0], data[-1] = data[-1], data[0]
    for n in range(len(data) - 1, 1, -1):
        heap_adjust(data, 1, n)
        data[0], data[n - 1] = data[n-1], data[0]

data=[2,3,6,3,868,9,8,-1]
heap_sort(data)
print data
# [-1, 2, 3, 3, 6, 8, 9, 868]

转自【 http://www.cppblog.com/guogangj/ 】
堆存储

堆入栈复杂度为Ο(logn)

堆出栈 Ο(logn)

刘凯毅 2009-12-01 12:05 发表评论

跟我一起学 - 算法导论 - 递归式

刘凯毅 — Wed, 25 Nov 2009 15:09:00 GMT

看第二节 - 递归树方法：
突发奇想能否使用 txt 构造出递归过程
还是有上此提到的递归方法分治排序

# encoding: utf-8
arr=[]
def printTree():
    ac = []
    ii = 0
    for r in arr :
        c,ss,cc = r
        sc = [' ' for i in xrange(cc*(c-1))]
        for i in xrange(len(sc)) :
            if i % cc == 0 : sc[i]="│"
        #print "ci %s ii %s = %s "%(ci,ii,ii < ci)
        if ii>=c  :
            sc = "".join(sc)+"├─"+ss+'  '
        else :
            sc = "".join(sc)+"└─"+ss
        ii = c
        ac.append( sc )

    for r in ac[::-1] :
        print r


def MERGE(A,p,q,r):
    #print "%s:%s - %s:%s" % (p,q+1,q+1,r+1)
    if p==q : L = [A[p],10**10]
    else : L = A[p:q+1]+[10**10]

    if q+1==r : R = [A[r],10**10]
    else : R = A[q+1:r+1]+[10*10]

    i = j = 0
    for k in xrange(p,r+1):
        if L[i]<R[j] :
            A[k]=L[i]
            i+=1
        else:
            A[k]=R[j]
            j+=1
    # print "%s:%s = %s \n%s:%s = %s\n\n%s" % ( p,q, L , q+1,r,R, A)

def MERGE_SORT(A,p,r,c=1):
    if p<r:
        q = (p+r)/2
        MERGE_SORT(A,p,q,c+1)
        MERGE_SORT(A,q+1,r,c+1)
        arr.append( (c,"%s - %s" % ( A[p:q+1],A[q+1:r+1]) , 3 ) )
        # Debugging(A,p,q,r, sc )
        MERGE(A,p,q,r)

A=[5,2,7,4,1,3,2,6]
MERGE_SORT(A,0,len(A)-1)
print A
printTree()

输出（重下往上看输出排序过程，我就不多说了应该很好理解了！！）：

[1, 2, 2, 3, 4, 5, 6, 7]
├─[2, 4, 5, 7] - [1, 2, 3, 6]
│  ├─[1, 3] - [2, 6]
│  │  ├─[2] - [6]
│  │  └─[1] - [3]
│  ├─[2, 5] - [4, 7]
│  │  ├─[7] - [4]
│  │  └─[5] - [2]

刘凯毅 2009-11-25 23:09 发表评论

跟我一起学 - 算法导论 - 函数的增长

刘凯毅 — Mon, 23 Nov 2009 15:33:00 GMT

3.1 渐近号

渐近范围      f(n) = θ(g(n)) ~a=b
渐近上界      f(n) = Ο(g(n)) ~a<=b    0≤f(n)≤cg(n)
渐近下界      f(n) = Ω(g(n)) ~a>=b    0≤cg(n)≤f(n)
非渐近上界   f(n) = o(g(n))    ~alim[n<=∞](f(n)/g(n))=0
非渐近下界   f(n) = ω(g(n))   ~a>b     0≤cg(n)lim[n<=∞](f(n)/g(n))=0

渐近号使用（目前我能理解到的！）:
当渐近符号出现在某个公式中时，我们将其解释为一个不在乎其名称的署名函数。
例：2n^2+3n+1 = 2n^2+θ(n) ，这种用法有助于屏蔽无关紧要的细节，如低阶项。。

∑[1≤k≤n]O(i)

3.2 标准记号和常量函数
单调性：单调递增，单调递减
# 传说中的广播体操原来是上下取整啊！呵呵
下取整，上取整： x-1 < └X┘ <= x   <= ┌X┐ < x+1

取模运算 a mod n = a-└a/n┘n

多项式 p(n) = ∑[0≤i≤d] a.i n^i

指数 (a^m)^n = a^(m*n)   ; a^m*a^n = a^(m+n)

# 指数中的特殊符号 e
# e不论对x微分几次，结果都还是e！难怪数学系学生会用e比喻坚定不移的爱情！
# 数学中的爱情符号 e 哈哈！！
e = lim[n≤∞](1+1/n)^n

对数
lgn = log_2(n)
lnn=log_e(n)
lg^k(n)=(lgn)^k
lg lg n = lg(lgn)

阶乘 n!

函数迭代

斐波那切
F0 = 0
F1 = 1
..
Fi = Fi-1+Fi-2

刘凯毅 2009-11-23 23:33 发表评论

跟我一起学 - 算法导论 - 分治算法

刘凯毅 — Sun, 22 Nov 2009 15:26:00 GMT

算法导论,一章二小节 ,分治算法

def MERGE(A,p,q,r):
    print "%s:%s - %s:%s" % (p,q+1,q+1,r+1)
    if p==q : L = [A[p],10**10]
    else : L = A[p:q+1]+[10**10]

    if q+1==r : R = [A[r],10**10]
    else : R = A[q+1:r+1]+[10*10]

    i = j = 0
    for k in xrange(p,r+1):
        if L[i]<R[j] :
            A[k]=L[i]
            i+=1
        else:
            A[k]=R[j]
            j+=1
    # print "%s:%s = %s \n%s:%s = %s\n\n%s" % ( p,q, L , q+1,r,R, A)

def Debugging(A,p,q,r,c):
    print "%s\t%s:%s - %s:%s" % (c,p,q,q+1,r)

def MERGE_SORT(A,p,r,c=1):
    if p<r:
        q = (p+r)/2
        MERGE_SORT(A,p,q,c+1)
        MERGE_SORT(A,q+1,r,c+1)
        #Debugging(A,p,q,r,c)
        MERGE(A,p,q,r)

A=[5,2,7,4,1,3,2,6]
print A
MERGE_SORT(A,0,len(A)-1)
print A

结果输出》》
python 2f.py
[5, 2, 7, 4, 1, 3, 2, 6]
[1, 2, 2, 3, 4, 5, 6, 7]

分享些细节：算法并不难，但确实写了很久，调试让我很郁闷。
直到写了 def Debugging 目测：

python 2f.py
3       0:0 - 1:1
3       2:2 - 3:3
2       0:1 - 2:3
3       4:4 - 5:5
3       6:6 - 7:7
2       4:5 - 6:7
1       0:3 - 4:7

看每层对数组的数组下标取值：
在 python 中当
arr = [1,2,3,4] 我希望能取出 [2,3] 是 arr[1:3] 是最后一位不计算在内的
最典型的 arr[0,1] == [1]

刘凯毅 2009-11-22 23:26 发表评论

理解高斯函数，以及在推荐算法中的应用

刘凯毅 — Thu, 19 Nov 2009 03:14:00 GMT

这是一个很有用的公式比如：用户消费分值权重，产品关联分值权重等等

公式

在 http://www.wolframalpha.com 中表示 :
e = (1+1/n) ^n
a*e^(-(x-b)^2/c^2)
a 峰值最大值
b 峰值x轴偏移量
c 弧度跨度

= 1*e^(-(x-1)^2/1^2)

修改峰值 a = 2

这里就不一一展现 b 峰值x轴偏移量， c 弧度跨度了大家可以去 wolframalpha 自己去尝试

实例1 与时间有关的递减：

import math
def gaussian(x,peak=1.0,axis=1.0,span=1.0):
return peak*math.e**(-(x-axis)**2/(span)**2 )

跨度 c 参考:
c = 1 : 在2.5 附件急剧衰减
c = 2 : 4
c = 18 :30 # 这个数衰减统计一个月不错
c = 55 :90 # 衰减统计一个季度不错

#简单应用
消费1次得峰值4分浏览1次峰值2分
统计某用户季度得分
数据：在前10天浏览10次，消费1次，前11天浏览5次
d10 = gaussian(10,span=55.0)
d11 = gaussian(11,span=55.0)
print d10*10*2+d10*4*1+d11*5*2
#结果 33.0407089687

倒的高斯　－　实例2 ：
公式 =

目的　与次数有关的产品分值化

#用户对某产品分值化
# 比如某用户用过某产品 n次，我希望 n 无限大是一个渐进某个值而不是和 n 无限递增的
#下面的 fun 结果是 1.6 ～ 10 分值直接的区域, 也就是传说中的产品感兴趣 “10分制” 简易版
def gs(x,peak=9.0,axis=-2.0,span=11.0):
return "%.4f" % (-1*peak*math.e**(-(x-axis)**2/(span)**2 )+peak+1)

>>> gs(1)
'1.6451'
>>> gs(2)
'2.1148'
>>> gs(3)
'2.6800'
>>> gs(4)
'3.3161'
>>> gs(5)
'3.9970'
>>> gs(6)
'4.6969'
>>> gs(60)
'10.0000'

刘凯毅 2009-11-19 11:14 发表评论

跟我一起学 - 算法导论 - 插入排序

刘凯毅 — Wed, 18 Nov 2009 15:29:00 GMT

算法导论 - 算法入门 ,一小节（插入排序,复杂度）

#  插入排序                -         复杂度
def insertion_sort(arr):             # 1
    for j in xrange( 1,len(arr) ):   # n-1
        key = arr[j]                 # n-1
        i=j-1                        # n-1
        while i>=0 and arr[i]> key : # n(n-1)/2
            arr[i+1] = arr[i]        # n(n-1)/2
            i=i-1                    # n(n-1)/2
        arr[i+1] = key               # n-1
        print arr                    # n-1

验证结果 :
>>> arr=[5,2,4,6,1,3]
>>> insertion_sort(arr)
[2, 5, 4, 6, 1, 3]
[2, 4, 5, 6, 1, 3]
[2, 4, 5, 6, 1, 3]
[1, 2, 4, 5, 6, 3]
[1, 2, 3, 4, 5, 6]

验证复杂度：
z = 5(n-1)+1+3n(n-1)/2
我们测试数据为 n=6
当数据极端情况就是需要全部重新排列
就是 [6,5,4,3,2,1] 要排出 [1,2,3,4,5,6] 这样
>> z = 71

一种比较笨的验证方法供大家拍砖 :

def insertion_sort(arr):
    ii=0
    ii+=1
    for j in xrange( 1,len(arr) ):
        ii+=1

        key = arr[j]
        ii+=1

        i=j-1
        ii+=1

        while i>=0 and arr[i]> key :
            ii+=1

            arr[i+1] = arr[i]
            ii+=1

            i=i-1
            ii+=1

        arr[i+1] = key
        ii+=1

        print arr
        ii+=1

    print "----",str(ii)

>>> arr=[6,5,4,3,2,1]
>>> insertion_sort(arr)
[5, 6, 4, 3, 2, 1]
[4, 5, 6, 3, 2, 1]
[3, 4, 5, 6, 2, 1]
[2, 3, 4, 5, 6, 1]
[1, 2, 3, 4, 5, 6]
---- 71 #复杂度验证为 71

罗嗦下 n(n-1)/2
极端情况下
i=1 ; j 需要挪动 1次
i=2 ; j 挪动 1+2次
i=3 ; j 挪动 1+2+3次
....
i=n ; j 挪动 1+2....+n

我们又找到 (1+n)+(2+n-1)+(3+n-2).... = (1+n)n/2
我们这的 i 是从 2 次开始的也就是说 (n-1)n/2 了

def tn(ii):
    ti=0
    for i in xrange(ii) :
        for j in xrange(i) :
            ti+=1
    print ti

print tn(2)  #1 = 1
print tn(3)  #3 = 1+2
print tn(4)  #6 = 1+2+3
..

刘凯毅 2009-11-18 23:29 发表评论

算法复杂度分析图

刘凯毅 — Tue, 17 Nov 2009 15:12:00 GMT

发现自己写个小程序 - 文本存储二叉结构的hashMap。那个费劲！痛下决心仔细学习算法。
（如果大家有兴趣就跟我一起 - 《算法导论》，也望大家监督我能每天拿出一小时和大家分享算法,算法代码我会尽量使用 py 和解决一些分析日志的应用上靠（其实，上面费劲的 二叉hash 是为了分析日志中 - 希望能实现多个大文件不需要合并就能根据某列排序输出! 目前的解决办法 find .. -exec cat {} \; | perl |sort 的笨方法）

1. 算法在计算中的作用（笔记） :
   算法(algorithm):就是定义良好的计算过程，它取一个或一组作为输出，并产生一个或一组自作为输出。

一些函数运行级别 # http://www.wolframalpha.com/ 函数都可在网站里运行
这里 n=一亿条数据 :
log_2(n)     30
n^0.5        31622
n            10^9
n*log_2(n)   2.9^10
n^2          10^18
n^3          10^27
2^n          无穷
n!           10^362880

需要知道的复杂度 - 在某一个临界点后合并会别插入要快的
插入排序复杂度 n^2    http://www.wolframalpha.com/input/?i=n^2
合并排序复杂度 n*log_2(n) http://www.wolframalpha.com/input/?i=n*log_2%28n%29+

网上的查找到的一些名称：参考 http://www.51testing.com/?uid-130868-action-viewspace-itemid-66729
1.1稳定排序非稳定排序 -
稳定排序是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，。反之，就是非稳定的排序。
1.2内排序外排序
在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。
1.3算法的时间复杂度空间复杂度
所谓算法的时间复杂度，是指执行算法所需要的计算工作量。一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。

几种常见的算法复杂度：
2.1冒泡排序（Bubble Sort）    O(n^2)
2.2选择排序（Selection Sort） O(n^2 )
2.3插入排序（Insertion Sort） O(n^2)
2.4堆排序    O( nlog(n) )
2.5归并排序 O( nlog_2(n) )
2.6快速排序最好 O( nlog_2(n) ) 最坏 O(n^2)

wiki 参考：http://zh.wikipedia.org/wiki/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95
穩定的

冒泡排序（bubble sort） — O(n²)
雞尾酒排序 (Cocktail sort, 雙向的冒泡排序) — O(n²)
插入排序（insertion sort）— O(n²)
桶排序（bucket sort）— O(n); 需要 O(k) 額外空間
計數排序 (counting sort) — O(n+k); 需要 O(n+k) 額外空間
合併排序（merge sort）— O(n log n); 需要 O(n) 額外空間
原地合併排序 — O(n²)
二叉排序樹排序（Binary tree sort） — O(n log n)期望時間; O(n²)最壞時間; 需要 O(n) 額外空間
鴿巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 額外空間
基數排序（radix sort）— O(n·k); 需要 O(n) 額外空間
Gnome sort — O(n²)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 額外空間

[編輯] 不穩定

選擇排序（selection sort）— O(n²)
希爾排序（shell sort）— O(n log n) 如果使用最佳的現在版本
Comb sort — O(n log n)
堆排序（heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序（quicksort）— O(n log n) 期望時間, O(n²) 最壞情況; 對於大的、亂數串列一般相信是最快的已知排序
Introsort — O(n log n)
Patience sorting — O(n log n + k) 最壞情況時間，需要額外的 O(n + k) 空間，也需要找到最長的遞增子序列（longest increasing subsequence）

[編輯] 不實用的排序演算法

Bogo排序 — O(n × n!) 期望時間，無窮的最壞情況。
Stupid sort — O(n³); 遞迴版本需要 O(n²) 額外記憶體
Bead sort — O(n) or O(√n), 但需要特別的硬體
Pancake sorting — O(n), 但需要特別的硬體

刘凯毅 2009-11-17 23:12 发表评论

算法公式 - 图形化

刘凯毅 — Thu, 05 Nov 2009 05:09:00 GMT

在定制数学公式的时候可能希望有个直观的展现

http://www.wolframalpha.com/

我们前一段时间用到的 { 推荐分值 90 天递减公式，如果这东西早发现公式就不会错了！}

目前我们递减的公式

y=-x/90+1

在比如我们优化下 90天改成

(y*10)^2=-x+90

2009-11-05

刘凯毅 2009-11-05 13:09 发表评论

apriori-实现

刘凯毅 — Tue, 01 Sep 2009 09:43:00 GMT

谢谢同事孙超讲解
这就把他的思想画个图

刘凯毅 2009-09-01 17:43 发表评论

apriori 算法（py）

刘凯毅 — Mon, 31 Aug 2009 06:25:00 GMT

代码:

# -*- coding: UTF8 -*-

import sys
# 最小支持度
sup_min = int(sys.argv[1])

ss = ","

# 交易数据库
D=[
'A,B,C,D',
'B,C,E',
'A,B,C,E',
'B,D,E',
'A,B,C,D'
]

print "交易数据库展现"
for arr in D : print arr
print

'''
rows=int(sys.argv[1])
D=[]
for tid in open('BuyMusic.20090722.mob.prodIds').readlines()[:rows] :
    D.append(tid.split("\n")[0].split("\t")[1])

print "读取文件结束 BuyMusic.20090722.mob.prodIds !"
'''
#全局频繁项收集
sup_data_map = {}
#全局  最大频繁项收集
is_zsup={}

# 遍历过程临时局部  频繁项收集
mapL = {}

# 第一次频繁项收集
def find_frequent_1_itemset(I):
    if I=='null' or I=='' : return
    if mapL.has_key(I): mapL[I]+=1
    else: mapL[I]=1

map(find_frequent_1_itemset,[ I  for TID in D for I  in TID.split(ss) ])

# 刷选掉小于最小支持度的频繁项
def remove_not_sup_min(map,supmin=sup_min):
    for k  in [k for k,v in map.items() if v<supmin] :
        del map[k]
remove_not_sup_min(mapL)

print "第一次筛选频繁项结束!"
print mapL

# 装载全局频繁项最大频繁项
for k,v in mapL.items() :
    sup_data_map[k]=v
    is_zsup[k]=v

# 判定是否 'BD' 属于  'BCD' 中
isInTid = lambda I,TID : len(I.split(ss)) == len([i for i in I if i in TID.split(ss)])

# 组合  [A,B] + [A,C] = [A,B.C]
def comb(arr1,arr2):
    tmap={}
    for v in arr1+arr2 : tmap[v]=""
    return tmap.keys()

# apriori 迭代核心
def runL(mapL,dep):
    mapL2 = {}
    C={}
    keys = mapL.keys()
    iik=""
    jjk=""
    # 根据上次  频繁项，生成本次 '可能频繁项' 集合
    for ii in range(len(keys)) :
        for jj in range(ii+1,len(keys)) :
            keystr=comb([ch for ch in keys[ii].split(ss)],[ch for ch in keys[jj].split(ss)])
            if not len(keystr) == dep : continue
            keystr.sort()
            tk=ss.join(keystr)
            if not tk in C : C[tk]=(keys[ii],keys[jj])

    #  '可能频繁项' 对比交易数据库  计数
    for tk,z in C.items():
        for TID in D:
            if isInTid(tk,TID) :
                if mapL2.has_key(tk): mapL2[tk]+=1
                else: mapL2[tk]=1

    # 刷选掉小于最小支持度的频繁项
    remove_not_sup_min(mapL2)
    for k,v in  is_zsup.items() :
        for k1,v1 in mapL2.items() :
            if isInTid(k,k1) :
                del is_zsup[k]
                break
    # 全局频繁项 ,最大频繁项  收集
    for k,v in mapL2.items() :
        sup_data_map[k]=v
        is_zsup[k]=v
    print "第"+str(dep)+"次筛选频繁项结束!"
    return mapL2

# 真正运行
ii=1
while mapL :
    ii=ii+1
    mapL = runL(mapL,ii)
    print mapL

# 全局  频繁项中去除最大频繁项
for k,v in is_zsup.items() :
    if sup_data_map.has_key(k) : del sup_data_map[k]

print "频繁项"
print sup_data_map
print
print "最大频繁项"
print is_zsup
print

print "可信度展现"
for k,v in  sup_data_map.items() :
    for k1,v1 in is_zsup.items() :
        if isInTid(k,k1) :
            print k,"->",k1,"\t%.1f" %((float(is_zsup[k1])/float(sup_data_map[k]))*100)+"%"

结果:
-bash-3.00$ python ap.py 2
交易数据库展现
A,B,C,D
B,C,E
A,B,C,E
B,D,E
A,B,C,D

第一次筛选频繁项结束!
{'A': 3, 'C': 4, 'B': 5, 'E': 3, 'D': 3}
第2次筛选频繁项结束!
{'C,D': 2, 'C,E': 2, 'A,D': 2, 'A,B': 3, 'A,C': 3, 'B,E': 3, 'B,D': 3, 'B,C': 4}
第3次筛选频繁项结束!
{'A,B,D': 2, 'A,B,C': 3, 'B,C,D': 2, 'B,C,E': 2, 'A,C,D': 2}
第4次筛选频繁项结束!
{'A,B,C,D': 2}
第5次筛选频繁项结束!
{}
频繁项
{'A': 3, 'C': 4, 'B': 5, 'E': 3, 'D': 3, 'C,D': 2, 'C,E': 2, 'A,D': 2, 'A,B': 3, 'A,C': 3, 'A,B,D': 2, 'B,C,D': 2, 'A,C,D': 2, 'B,E': 3, 'B,D': 3, 'B,C': 4, 'A,B,C': 3}

最大频繁项
{'B,C,E': 2, 'A,B,C,D': 2}

可信度展现
A -> A,B,C,D    66.7%
C -> B,C,E    50.0%
C -> A,B,C,D    50.0%
B -> B,C,E    40.0%
B -> A,B,C,D    40.0%
E -> B,C,E    66.7%
D -> A,B,C,D    66.7%
C,D -> A,B,C,D    100.0%
C,E -> B,C,E    100.0%
A,D -> A,B,C,D    100.0%
A,B -> A,B,C,D    66.7%
A,C -> A,B,C,D    66.7%
A,B,D -> A,B,C,D    100.0%
B,C,D -> A,B,C,D    100.0%
A,C,D -> A,B,C,D    100.0%
B,E -> B,C,E    66.7%
B,D -> A,B,C,D    66.7%
B,C -> B,C,E    50.0%
B,C -> A,B,C,D    50.0%
A,B,C -> A,B,C,D    66.7%

刘凯毅 2009-08-31 14:25 发表评论

k-means （python）算法

刘凯毅 — Fri, 07 Aug 2009 08:20:00 GMT

转:http://www.daniweb.com/forums/thread31449.html
什么都不说了，直接看代码吧。
注解应该写的比较详细

# liukaiyi
# 注 k-means ，维度类型 - 数值形式 ( 199 或 23.13 )
import sys, math, random

# -- 类化 '数据'
# 在 n-维度空间
class Point:
    def __init__(self, coords, reference=None):
        self.coords = coords
        self.n = len(coords)
        self.reference = reference
    def __repr__(self):
        return str(self.coords)

# -- 类化 '聚集点 / 聚类平均距离点 '
# -- 在 n-维度空间
# -- k-means 核心类
# -- 每次聚集各点围绕她进行聚集
# -- 并提供方法求-聚集后的计算中心点，同时记入此次中心点(聚集各点平均距离)，为下一次聚集提供中心点.
class Cluster:
    def __init__(self, points):
        if len(points) == 0: raise Exception("ILLEGAL: EMPTY CLUSTER")
        self.points = points
        self.n = points[0].n
    for p in points:
            if p.n != self.n: raise Exception("ILLEGAL: MULTISPACE CLUSTER")
        # 求聚集各点后平均点
    self.centroid = self.calculateCentroid()
    def __repr__(self):
        return str(self.points)

    # 更新中心点，并返回原中心点与现中心点(聚集各点平均距离)距离
    def update(self, points):
        old_centroid = self.centroid
        self.points = points
        self.centroid = self.calculateCentroid()
        return getDistance(old_centroid, self.centroid)

    # 计算平均点（聚集/收集各点（离本类的中心点）最近数据,后生成新的中心点）
    def calculateCentroid(self):
        centroid_coords = []
        #  维度迭代
    for i in range(self.n):
            centroid_coords.append(0.0)
            # 收集各点迭代
        for p in self.points:
                centroid_coords[i] = centroid_coords[i]+p.coords[i]
            centroid_coords[i] = centroid_coords[i]/len(self.points)
        return Point(centroid_coords)

# -- 返回根据 k-means 聚集形成的数据集
def kmeans(points, k, cutoff):
    # Randomly sample k Points from the points list, build Clusters around them
    initial = random.sample(points, k)
    clusters = []
    for p in initial: clusters.append(Cluster([p]))
    # 迭代 k-means 直到每次迭代各收集点别的最多不超过 0.5
    while True:
        #  k 个收集数组
        lists = []
        for c in clusters: lists.append([])
    # 迭代每个数据点，并计算与每个中心点距离
    # 并把数据点添加入相应最短的中心点收集数组中
    # 在迭代中 smallest_distance 为每个点与各中心点最短距离参数，请注意看
        for p in points:
            smallest_distance = getDistance(p, clusters[0].centroid)
            index = 0
            for i in range(len(clusters[1:])):
                distance = getDistance(p, clusters[i+1].centroid)
                if distance < smallest_distance:
                    smallest_distance = distance
                    index = i+1
            # 添加到离最短中心距离的数组中
        lists[index].append(p)

        # 聚集完，计算新中心点
    # 并 cluster.centroid 属性记入下新中心点（下一次聚集的中心点）
    # 并计算与上一次中心点距离，如果差值在 cutoff 0.5 以下 ,跳出迭代（结束，返回最后一次聚集集合）
    biggest_shift = 0.0
        for i in range(len(clusters)):
            shift = clusters[i].update(lists[i])
            biggest_shift = max(biggest_shift, shift)
        if biggest_shift < cutoff: break
    return clusters

# -- 得到欧几里德距离两点之间
def getDistance(a, b):
    # Forbid measurements between Points in different spaces
    if a.n != b.n: raise Exception("ILLEGAL: NON-COMPARABLE POINTS")
    # Euclidean distance between a and b is sqrt(sum((a[i]-b[i])^2) for all i)
    ret = 0.0
    for i in range(a.n):
        ret = ret+pow((a.coords[i]-b.coords[i]), 2)
    return math.sqrt(ret)

# -- 在 n-维度空间中创建随机点
# -- 随机生成测试数据
def makeRandomPoint(n, lower, upper):
    coords = []
    for i in range(n): coords.append(random.uniform(lower, upper))
    return Point(coords)

# main
def main(args):
    # 参数说明
    # num_points,    n,    k,      cutoff,         lower,        upper
    # 随机数据数量 , 维度, 聚集数, 跳出迭代最小距离 ,   维度数最大值,维度数最小值
    num_points, n, k, cutoff, lower, upper = 10, 2, 3, 0.5, -200, 200

    # 在 n-维度空间里 , 创建 num_points 随机点
    # 测试数据生成
    points = []
    for i in range(num_points): points.append(makeRandomPoint(n, lower, upper))

    # 使用 k-means 算法，来聚集数据点 (算法入口点)
    clusters = kmeans(points, k, cutoff)

    print "\nPOINTS:"
    for p in points: print "P:", p
    print "\nCLUSTERS:"
    for c in clusters: print "C:", c
if __name__ == "__main__": main(sys.argv)

刘凯毅 2009-08-07 16:20 发表评论