FM算法组合估计

  1 #include <stdio.h>
  2 #include <math.h>
  3 #include <stdlib.h>
  4 #include <time.h>
  5
  6 #define NUM (int)pow(2.0,25)+1
  7
  8 int length=0;//计算长度
  9 int data[350000];//存放数据流
 10
 11 struct node
 12 {
 13     int data;
 14     struct node* next;
 15 };
 16 struct node* creat()//创建链表
 17 {
 18     int x;
 19     struct node *tail,*p,*head;
 20     head=(struct node *)malloc(sizeof(struct node));
 21     head->next=NULL;
 22     tail=head;
 23     //FILE *fp=fopen("./stream_for_fm.txt","r");
 24     FILE *fp=fopen("./stream_sample_fm.txt","r");//样本
 25     if(fp==NULL)
 26     {
 27         printf("file open failed!\n");
 28         exit(0);
 29     }
 30     while(!feof(fp))
 31     {
 32         fscanf(fp,"%d",&x);
 33         p=(struct node *)malloc(sizeof(struct node));
 34         p->data=x;
 35         tail->next=p;
 36         p->next=NULL;
 37         tail=p;
 38         data[length++]=x;
 39     }
 40     printf("链表创建成功!\n");
 41     return head;
 42 }
 43 /*排序链表*/
 44 struct node *sort(struct node *head)
 45 {
 46     struct node *p,*q;
 47     for(p=head->next;p!=NULL;p=p->next)
 48     {
 49         for(q=p->next;q!=NULL;q=q->next)
 50         {
 51             if(p->data > q->data)
 52             {
 53                 int tmp=p->data;
 54                 p->data=q->data;
 55                 q->data=tmp;
 56             }
 57         }
 58     }
 59     printf("链表排序完成!\n");
 60     return head;
 61 }
 62
 63 /*计算有多少不同元素*/
 64 int different_node_count(struct node *head)
 65 {
 66     struct node *p,*q,*tmp;
 67     int count_equal=0,count_total=0;
 68     tmp=NULL;
 69
 70     for(p=head->next;p!=NULL;p=p->next)
 71     {
 72         for(q=p->next;q!=NULL;q=q->next)
 73         {
 74             if(p->data == q->data)
 75             {
 76                 count_equal++;//相同元素加
 77                 tmp=q;//记录最后一个相同的元素位置
 78             }
 79             else
 80             {
 81                 break;
 82             }
 83         }
 84         if(tmp!=NULL)
 85         {
 86             p=tmp;
 87             tmp=NULL;
 88         }
 89         //count_total++;//统计全部节点的个数
 90     }
 91     printf("不同节点的个数%d\n节点总数:%d\n",length-count_equal,length);
 92     return length-count_equal;
 93 }
 94 //计算尾数
 95 int get_tailnum(long long a)
 96 {
 97     int i=0,count =0;
 98     while(a!=0)
 99     {
100         if(0 == a%2)
101         {
102             count++;
103         }
104         else
105         {
106             break;
107         }
108         a=a/2;
109         i++;
110     }
111     return count;
112 }
113
114 int main()
115 {
116     struct node *head;
117     int only_value;
118     int M=4,L=4;
119     int i,j,k,x;
120     int circle=20;
121     long long h,a,b;
122     int R[20][20];//尾数
123     int max_tailnum=0,tmp;//最大尾长
124     double ave_tail[20]={0};//最大尾数的平均数
125     int mid_tail;//平均尾数的中位数
126     int estimate[30];//存入估计值
127     double error;//误差
128     long long sum=0;
129
130     head=creat();
131     head=sort(head);
132     only_value=different_node_count(head);
133     srand(time(0));
134     for(x=0;x<circle;x++)
135     {
136         for(i=0;i<M;i++)//分组M
137         {
138             for(j=0;j<L;j++)//每组L个hash
139             {
140                 a=rand()%NUM;
141                 b=rand()%NUM;
142                 max_tailnum=0;
143                 for(k=0;k<length;k++)
144                 {
145                     tmp=get_tailnum(a*data[k]+b);
146                     if(max_tailnum<tmp)
147                     {
148                         max_tailnum=tmp;
149                     }
150                 }
151                 R[i][j]=max_tailnum;
152             }
153             for(j=0;j<L;j++)
154             {
155                 ave_tail[i]+=R[i][j];
156             }
157             ave_tail[i]/=L;//每组的平均值
158         }
159
160         if(M%2==0)
161         {
162             mid_tail=(ave_tail[M/2]+ave_tail[M/2+1])/2;
163         }
164         else
165         {
166             mid_tail=ave_tail[M/2];
167         }
168
169         estimate[x]=(int)pow(2.0,mid_tail);
170
171         //ave_tail尾长的平均值清零
172         for(int i=0 ;i < 20 ;i ++)
173         {
174             ave_tail[i]=0;
175         }
176     }
177     int temp=0;
178     printf("估计元素个数");
179     for(i=0;i<circle;i++)
180     {
181         temp+=estimate[i];
182         //printf("%8d",estimate[i]);
183         sum+=(estimate[i]-only_value)*(estimate[i]-only_value);
184     }
185     printf("%lf",temp/(double)circle);
186     putchar(‘\n‘);
187     error=sqrt(sum/(double)only_value);
188     printf("误差(方差):%lf\n",error);
189     system("pause");
190     return 0;
191 }
时间: 2024-10-06 02:59:09

FM算法组合估计的相关文章

FM算法解析及Python实现

1. 什么是FM? FM即Factor Machine,因子分解机. 2. 为什么需要FM? 1.特征组合是许多机器学习建模过程中遇到的问题,如果对特征直接建模,很有可能会忽略掉特征与特征之间的关联信息,因此,可以通过构建新的交叉特征这一特征组合方式提高模型的效果. 2.高维的稀疏矩阵是实际工程中常见的问题,并直接会导致计算量过大,特征权值更新缓慢.试想一个10000*100的表,每一列都有8种元素,经过one-hot独热编码之后,会产生一个10000*800的表.因此表中每行元素只有100个值

[算法]组合类问题

1,组合相关公式 C(n,m)=n*(n-1)*(n-2)...*(n-m-1)/m!=n!/(m!*(n-m)!) C(n,m)=C(n,n-m) C(n+1,m)=C(n,m)+C(n,m-1) C(n,1)+C(n,2)+…+C(n,n)=2^n; 2,相关算法 Question 1: 输入一个字符串,打印出该字符串中字符的所有组合. 算法1:同样可以按照文章http://www.cnblogs.com/orchid/p/4025172.html中提到的思路,有长度为strlen(s)个盒

Ensemble_learning 集成学习算法 stacking 算法

原文:https://herbertmj.wikispaces.com/stacking%E7%AE%97%E6%B3%95 stacked 产生方法是一种截然不同的组合多个模型的方法,它讲的是组合学习器的概念,但是使用的相对于bagging和boosting较少,它不像bagging和boosting,而是组合不同的模型,具体的过程如下:1.划分训练数据集为两个不相交的集合.2. 在第一个集合上训练多个学习器.3. 在第二个集合上测试这几个学习器4. 把第三步得到的预测结果作为输入,把正确的回

机器学习十大算法(二)

文章来源:https://www.dezyre.com/article/top-10-machine-learning-algorithms/202 本人自行翻译,如有错误,还请指出.后续会继续补充实例及代码实现. 3.机器学习算法概述 3.1 朴素贝叶斯分类器算法 手动分类网页,文档,电子邮件或任何其他冗长的文本注释将是困难且实际上不可能的. 这是朴素贝叶斯分类器机器学习算法来解决. 分类器是从可用类别之一分配总体的元素值的函数. 例如,垃圾邮件过滤是朴素贝叶斯分类器算法的流行应用程序. 此处

光线投射算法与光线跟踪算法

原文:http://blog.csdn.net/changbaolong/article/details/8461704 光线跟踪计算机算法的一般描述 为了生成在三维计算机图形环境中的可见图像,光线跟踪是一个比光线投射或者扫描线渲染更加逼真的实现方法.这种方法通过逆向跟踪与假象的照相机镜头相交的光路进行工作,由于大量的类似光线横穿场景,所以从照相机角度看到的场景可见信息以及软件特定的光照条件,就可以构建起来.当光线与场景中的物体或者媒介相交的时候计算光线的反射.折射以及吸收. 光线跟踪的场景经常

EM算法原理以及高斯混合模型实践

EM算法有很多的应用: 最广泛的就是GMM混合高斯模型.聚类.HMM等等. The EM Algorithm 高斯混合模型(Mixtures of Gaussians)和EM算法 EM算法 求最大似然函数估计值的一般步骤: (1)写出似然函数: (2)对似然函数取对数,并整理: (3)求导数,令导数为0,得到似然方程: (4)解似然方程,得到的参数即为所求. 期望最大化算法(EM算法): 优点: 1. 简单稳定: 2. 通过E步骤和M步骤使得期望最大化,是自收敛的分类算法,既不需要事先设定类别也

从软件工程的角度写机器学习3——主要监督学习算法的工程性分析

主要机器学习算法的工程适用性分析 前段时间AlphaGo跟李世石的大战及相关的深度学习的新闻刷了一遍又一遍的朋友圈.不过这件事情,也只是在机器学习的深度上进一步拓展,而机器学习的广度(也即工程化实践)上,仍然没有什么突破性的理论或实践,用的领域继续用,不用的领域依然不用. 工程性分析的作用 工程上的琐事 机器学习的使命是使计算机强大的运算能力和存储能力转化为推演能力,能转化是一方面,转化的效率则是另一方面.科研性质的AlphaGo,拥有近乎无限的计算资源,不用太考虑这方面的问题,但在我们实际的工

python入门-分类和回归各种初级算法

引自:http://www.cnblogs.com/taichu/p/5251332.html ########################### #说明: # 撰写本文的原因是,笔者在研究博文"http://python.jobbole.com/83563/"中发现 # 原内容有少量笔误,并且对入门学友缺少一些信息.于是笔者做了增补,主要有: # 1.查询并简述了涉及的大部分算法: # 2.添加了连接或资源供进一步查询: # 3.增加了一些lib库的基本操作及说明: # 4.增加

算法复杂度估算经验

算法复杂度: 复杂度计算出来后有什么用? 估计程序能否在规定时间内处理题目指定规模的数据 ACM有时间限制1s “规模”的举例 1.给N个数排序  规模:N 2.判断字符串P是否是字符串T的子串  规模:串的长度|P|和|T| 3.判断一个整数是否属于整数集合S  规模:|S| 要判断多少次(查询次数) 4.图中某两个点的最短路径/求连通图的最小生成树 规模:顶点数 边数 5.给一个整数集合S,问是否存在S的一个非空子集T,满足T中所有元素的和为零  规模:|S| 算法运算次算: 当代计算机1s