相似度（参数调节代码）

最新推荐文章于 2023-03-01 21:37:29 发布
最新推荐文章于 2023-03-01 21:37:29 发布
阅读量867 收藏 1
点赞数
分类专栏： 随感
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiefubao/article/details/52882914
版权 
// test1.cpp : Defines the entry point for the console application.
//

#include <vector>
#include <cstring>
#include <fstream>
#include <string>
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <ctime>
#include <iomanip>
#include <cmath>
#include <queue>

using namespace std;

struct serie
{
	vector<double> vec;
	string label;
	double len;
};
double speed = 1.6;
double INF = 1e10;
serie series[10000];
double dpA[2000][2000];
double dpB[2000][2000];
int num = 637;
double coe=0.2;
int WIN = 0;
double down_ratio;
map<int, string> names;
vector<int> lens(38, 0);
vector<int> num1(38, 0);
vector<int> num2(38, 0);
vector<int> classes(38,0);
vector<double> dev_mean(38, 0);

string to_string(int value)
{
	char help[10];
	sprintf(help,"%d",value);
	return string(help);
}
double DPA(int i, int j, int win)
{
	if ((i == 0 && j == win + 1) || (j == 0 && i == win + 1))
	{
		return dpA[i][j];;
	}
	if (abs(i - j) <= win)
		return dpA[i][j];
	return INF;
}
double DPB(int i, int j, int win)   
{
	if ((i == 0 && j == win + 1) || (j == 0 && i == win + 1))
	{
		return dpB[i][j];;
	}
	if (abs(i - j) <= win)
		return dpB[i][j];
	return INF;
}
double getdis(int one, int two, int i, int j)
{
	vector<double>& vec1 = series[one].vec;
	vector<double>& vec2 = series[two].vec;
	int n = vec1.size();
	double ans = (vec1[i * 2] - vec2[j * 2])*(vec1[i * 2] - vec2[j * 2]) + (vec1[i * 2 + 1] - vec2[j * 2 + 1])*(vec1[i * 2 + 1] - vec2[j * 2 + 1]);
	return sqrt(ans);
}
double getdistance00(int one, int two)
{
	int n = series[two].vec.size() + 1;
	dpA[0][0] = 0;
	dpB[0][0] = 0;
	dpA[1][0] = 0;
	dpB[0][1] = 0;
	n /= 2;
	for (int i = 2; i <= min(n - 1, WIN + 1); i++)
	{
		dpA[i][0] = dpA[i - 1][0] + getdis(one, one, i - 1, i - 1 - 1);// fabs(series[one].vec[i - 1] - series[one].vec[i - 1 - 1]);
		dpB[0][i] = dpB[0][i - 1] + getdis(two, two, i - 1, i - 1 - 1);// fabs(series[two].vec[i - 1] - series[two].vec[i - 1 - 1]);getdis(two, two, i - 1, j - 1-1)
	}
	int win = WIN;
	for (int i = 1; i < n; i++)
		for (int j = max(1, i - win); j < min(n, i + win + 1); j++)
		{
			if (i != 1)
				dpA[i][j] = min(DPA(i - 1, j, win) + getdis(one, one, i - 1, i - 1 - 1), DPB(i - 1, j, win) + coe*getdis(one, two, i - 1, j - 1));
			else
				dpA[i][j] = DPB(i - 1, j, win) + coe*getdis(one, two, i - 1, j - 1);

			if (j != 1)
				dpB[i][j] = min(DPA(i, j - 1, win) + coe*getdis(one, two, i - 1, j - 1), DPB(i, j - 1, win) + getdis(two, two, i - 1, j - 1 - 1));
			else
				dpB[i][j] = DPA(i, j - 1, win) + coe*getdis(one, two, i - 1, j - 1);

		}
	return min(dpA[n - 1][n - 1], dpB[n - 1][n - 1]);
}
double getdistance0t(int one, int two)
{
	int n = series[two].vec.size() + 1;
	dpA[0][0] = 0;
	dpB[0][0] = 0;
	dpA[1][0] = 0;
	dpB[0][1] = 0;
	for (int i = 2; i <= min(n-1,WIN + 1); i++)
	{
		dpA[i][0] = dpA[i - 1][0] + fabs(series[one].vec[i - 1] - series[one].vec[i - 1 - 1]);
		dpB[0][i] = dpB[0][i - 1] + 0*fabs(series[two].vec[i - 1] - series[two].vec[i - 1 - 1]);
	}
	int win = WIN;
	for (int i = 1; i < n; i++)
		for (int j = max(1, i - win); j < min(n, i + win + 1); j++)
		{
			if (i != 1)
				dpA[i][j] = min(DPA(i - 1, j, win) + fabs(series[one].vec[i - 1] - series[one].vec[i - 1 - 1]), DPB(i - 1, j, win) + coe*fabs(series[one].vec[i - 1] - series[two].vec[j - 1]));
			else
				dpA[i][j] = DPB(i - 1, j, win) + coe*fabs(series[one].vec[i - 1] - series[two].vec[j - 1]);

			if (j != 1)
				dpB[i][j] = min(DPA(i, j - 1, win) + coe*fabs(series[one].vec[i - 1] - series[two].vec[j - 1]), DPB(i, j - 1, win) + 0*fabs(series[two].vec[j - 1] - series[two].vec[j - 1 - 1]));
			else
				dpB[i][j] = DPA(i, j - 1, win) + coe*fabs(series[one].vec[i - 1] - series[two].vec[j - 1]);

		}
	return min(dpA[n - 1][n - 1], dpB[n - 1][n - 1]) ;
}
double getdistance0(int one, int two)
{
	int n = series[two].vec.size() + 1;
	dpA[0][0] = 0;
	dpB[0][0] = 0;
	dpA[1][0] = 0;
	dpB[0][1] = 0;
	for (int i = 2; i <= min(n - 1, WIN + 1); i++)
	{
		dpA[i][0] = dpA[i - 1][0] + fabs(series[one].vec[i - 1] - series[one].vec[i - 1 - 1]);
		dpB[0][i] = dpB[0][i - 1] + fabs(series[two].vec[i - 1] - series[two].vec[i - 1 - 1]);
	}
	int win = WIN;
	for (int i = 1; i < n; i++)
		for (int j = max(1, i - win); j < min(n, i + win + 1); j++)
		{
			if (i != 1)
				dpA[i][j] = min(DPA(i - 1, j, win) + fabs(series[one].vec[i - 1] - series[one].vec[i - 1 - 1]), DPB(i - 1, j, win) + coe*fabs(series[one].vec[i - 1] - series[two].vec[j - 1]));
			else
				dpA[i][j] = DPB(i - 1, j, win) + coe*fabs(series[one].vec[i - 1] - series[two].vec[j - 1]);

			if (j != 1)
				dpB[i][j] = min(DPA(i, j - 1, win) + coe*fabs(series[one].vec[i - 1] - series[two].vec[j - 1]), DPB(i, j - 1, win) + fabs(series[two].vec[j - 1] - series[two].vec[j - 1 - 1]));
			else
				dpB[i][j] = DPA(i, j - 1, win) + coe*fabs(series[one].vec[i - 1] - series[two].vec[j - 1]);

		}
	return min(dpA[n - 1][n - 1], dpB[n - 1][n - 1]);
}
double dp[2000][2000];
double getdistance1(int one, int two)
{
	int n = series[two].vec.size();
	dp[0][0] = fabs(series[one].vec[0] - series[two].vec[0]);
	int win = WIN;
	for (int i = 1; i < min(i+win,n); i++)
	{
		dp[i][0] = dp[i-1][0]+fabs(series[one].vec[i]-series[two].vec[0]);
		dp[0][i] = dp[0][i-1]+fabs(series[one].vec[0] - series[two].vec[i]);
	}
	for (int i = 1; i < n; i++)
		for (int j = max(1,i-win); j < min(i+win+1,n); j++)
		{
			if (j==i-win)
				dp[i][j] = fabs(series[one].vec[i] - series[two].vec[j]) +  min(dp[i - 1][j], dp[i - 1][j - 1]);
			else if (j==i+win)
				dp[i][j] = fabs(series[one].vec[i] - series[two].vec[j]) + min(dp[i][j - 1], dp[i - 1][j - 1]);
			else
				dp[i][j] = fabs(series[one].vec[i] - series[two].vec[j]) +min(dp[i - 1][j], min(dp[i][j - 1], dp[i - 1][j - 1]));
		}
	return dp[n - 1][n - 1];
	return 0;
}

double getdistance2(int one, int two)
{
	int n = series[two].vec.size();
	double ans = 0;
	for (int i = 0; i < series[one].vec.size(); i++)
	{
		ans += fabs(series[one].vec[i] - series[two].vec[i]);
	}
	return ans;
}
double getdistance3(int one, int two)
{
	int n = series[one].vec.size();
	double ans = 0;
	for (int i = 0; i < n - 1; i++)
	{
		ans += abs(series[one].vec[i] - series[two].vec[i]);
		ans += abs(series[two].vec[i] - series[one].vec[i + 1]);
		ans += abs(series[one].vec[i] - series[two].vec[i + 1]);
	}
	ans += abs(series[one].vec[n - 1] - series[two].vec[n - 1]);
	return ans;
}
double getdistance4(int one, int two)
{
	int n = series[two].vec.size();
	double ans = 0;
	dp[0][0] = abs(series[one].vec[0] - series[two].vec[0]);
	for (int i = 1; i < n; i++)
	{
		dp[i][0] = dp[i - 1][0] + abs(series[one].vec[i - 1] - series[one].vec[i]);
		dp[0][i] = dp[0][i - 1] + abs(series[two].vec[i - 1] - series[two].vec[i]);
	}
	int win = WIN;
	for (int i = 1; i < n; i++)
		//for (int j = 1; j < n; j++)
			for (int j = max(1, i - win); j < min(i + win + 1, n); j++)
		{
			dp[i][j] = INF;
			if (j - i + 1 <= win)
			dp[i][j] = min(dp[i][j],dp[i - 1][j] + abs(series[one].vec[i - 1] - series[one].vec[i]));
			if (i - j + 1 <= win)
			dp[i][j] = min(dp[i][j], dp[i][j - 1] + abs(series[two].vec[j - 1] - series[two].vec[j]));
			if (j - i + 1 <= win)
			dp[i][j] = min(dp[i][j], dp[i - 1][j ] + abs(series[one].vec[i] - series[two].vec[j])*coe);
			if (i - j + 1 <= win)
			dp[i][j] = min(dp[i][j], dp[i ][j - 1] + abs(series[one].vec[i] - series[two].vec[j])*coe);
			
		}
	return dp[n - 1][n - 1];
}
double getdistance5(int one, int two)
{
	int n = series[one].vec.size();
	double ans = 0;
	ans += abs(series[one].vec[0] - series[two].vec[0]);
	ans += abs(series[one].vec[n - 1] - series[two].vec[n - 1]);
	for (int i = 1; i < n - 1; i++)
	{
		ans += min(abs(series[one].vec[i] - series[two].vec[i - 1]), min(abs(series[one].vec[i] - series[two].vec[i]), abs(series[one].vec[i] - series[two].vec[i + 1])));
	}

	ans += abs(series[one].vec[n - 1] - series[two].vec[n - 1]);
	return ans;
}

void readInfo()
{
	ifstream file("/home/xiefubao/myproject/experiment/vldb_dataset/numhelp.txt");
	if (!file.is_open())
	{
		cout << "num.txt not open!" << endl;
		exit(0);
	}
	for (int i = 0; i < 38; i++)
	{
		string now;
		int no;
		file >> no;
		file >> now;
		file >> lens[i];
		file >> num1[i];
		file >> num2[i];
		file >> classes[i];
		file >> dev_mean[i];
		names[i] = now;
	}
}
void down_sample(int counter)
{
	int newnum = num*(1 - down_ratio);
	int getout = num - newnum;
	for (int i = 0; i < counter; i++)
	{
		vector<double> down;
		vector<int> help(num, 0);
		vector<bool> rem(num, 1);
		for (int j = 0; j < num; j++)
		{
			help[j] = j;
		}
		for (int j = 0; j < getout; j++)
		{
			int position = rand() % (num - j);
			rem[help[position]] = 0;
			swap(help[position], help[num-j-1]);
		}
		vector<double> now(newnum, 0);
		int add = 0;
		for (int j = 0; j < num; j++)
		{
			if (rem[j])
				now[add++] = series[i].vec[j];
		}
		swap(series[i].vec, now);
	}
	num = newnum;
}
void readFile(int filenum , bool train)
{
	num = lens[filenum - 1];
	string filepath = "/home/xiefubao/myproject/experiment/vldb_dataset/" + to_string(filenum) + "/" + names[filenum - 1] + (train ? "_TRAIN" : "_TEST") + ".txt";
	cout << filepath << endl;
	string now;
	ifstream in(filepath.c_str());
	if (!in.is_open())
	{
		cout << "not open" << endl;
		exit(1);
	}
	int number = train ? num2[filenum - 1] : num1[filenum - 1];
	for(int u = 0;u < number;u++)
	{
		in >> now;
		series[u].label = now;
		double len = 0;
		series[u].vec.clear();
		for (int i = 0; i < num; i++)
		{
			double point;
			in >> point;
			point = point;
			series[u].vec.push_back(point);
			if (i != 0)
				len += fabs(point - series[u].vec[i - 1]);
		}
		series[u].len = len;
	}
	cout<<"done 1"<<endl;
	//down_sample(number);
}
/*bool operator<(pair<double,string> n1,pair<double,string> n2) {
        return n1.first < n2.first;
}*/
int getvalue(int filenum,int wlen,double c,int counter,double(*distance) (int, int))
{
	int ans = 0;
	WIN = wlen;
	coe = c;
	for (int i = 0; i < counter; i++)
		{
			//cout << counter << " " << ans <<endl;
			priority_queue<pair<double,string> > pri;
			int prinum = 3;
			for(int j = 0;j < counter; j++)
			{
				if (i == j) continue;
				if (((i+3737)*(j+4343)) %(max(1,counter/classes[filenum]/5)) != 0) continue;
				double dis = distance(i,j);

				if(pri.size() < prinum)
					pri.push(make_pair(dis,series[j].label));
				else if(pri.top().first > dis)
				{
					pri.pop();
					pri.push(make_pair(dis,series[j].label));
				}
			}
			for(int u = 1;u <= prinum && !pri.empty();u++)
			{
				if(pri.top().second == series[i].label)
				{
					ans += u*u;
				}
				pri.pop();
			}
		}
		cout << "ans " << ans <<endl;
	return ans;
}
int   find_win_size(int filenum,double c,int counter,double(*distance) (int, int))
{
	int max_value = -1;
	int len = -1;
	for(int wlen = lens[filenum] / 2; wlen >= 2 ; wlen /= speed)
	{
		cout<<wlen<<endl;
		int value = getvalue(filenum,wlen,c,counter,distance);
		if(value >= max_value)
		{
			max_value = value;
			len = wlen;
		}
	}
	return len;
}
double find_ceo(int filenum,int counter, double(*distance) (int, int))
{
	int max_value = -1;
	double ans = -1;
	for(double rat = 1; rat > 0.001 ; rat /= 1.8)
	{
		int value = getvalue(filenum,WIN,rat,counter,distance);
		if(value >= max_value)
		{
			max_value = value;
			ans = rat;
		}
	}
	return ans;
}
int main()
{
	//cout << "xie" <<  << 123 << "123" << endl; getchar();
	readInfo(); 
	ofstream result;
	result.open("/home/xiefubao/myproject/experiment/vldb_dataset/compare.txt",ios::app);
	//file location
	//int filenum = 31;
	bool train = false;
	for (int filenum = 38; filenum <= 38; filenum++)
	{
		/*down_ratio = 0.2;
		readFile(filenum, false);
		cout << "start find winsize" << endl;
		WIN = find_win_size(filenum - 1,dev_mean[filenum-1]/2,num2[filenum -1],getdistance0);
		cout << "start find coe" << endl;
		coe = find_ceo(filenum - 1,num2[filenum -1],getdistance0);
		cout << "have done" << endl;
		cout << "WIN && coe : " << WIN << " " << coe <<endl;
        */
		clock_t start, finish;
		start = clock();

        WIN = 5;
        coe = dev_mean[filenum - 1];
		vector<int> hitnum(5, 0);
		int counter = num1[filenum - 1];

		cout << "reading" << endl;
		
		readFile(filenum, train);
		cout << "have read" << endl;
		cout << "xiefubao " << WIN << coe <<endl;
		//double(*distance[5]) (int, int) = { getdistance00, getdistance0, getdistance1, getdistance2, getdistance3 };
		double(*distance[5]) (int, int) = { getdistance0,getdistance1, getdistance2 };
		vector<int> computeDis;
		computeDis.push_back(0);
		computeDis.push_back(1);
		computeDis.push_back(2);
		//computeDis.push_back(3);
		//computeDis.push_back(4);
		for (int i = 0; i < counter; i++)
		{
			
			vector<double> mist(5, INF);
			vector<int> bestnum(5, -1);
			//cout << i << endl;  
			for (int j = 0; j < counter; j++)
			{
				if (i == j) continue;
				if (rand() %(max(1,counter/classes[filenum-1]/5)) != 0) continue;
				vector<double> dist(5, 0);
				for (int k = 0; k < computeDis.size(); k++)
				{
					dist[computeDis[k]] = distance[computeDis[k]](i, j);
				}
				for (int k = 0; k < computeDis.size(); k++)
					if (dist[computeDis[k]] < mist[computeDis[k]])
					{
						mist[computeDis[k]] = dist[computeDis[k]];
						bestnum[computeDis[k]] = j;
					}
			}
			if (i == counter - 1)
			{
				result << setw(2) << setfill(' ')  << filenum << " ";
			}
			for (int k = 0; k < computeDis.size(); k++)
			{
				if (series[i].label == series[bestnum[computeDis[k]]].label)
				{
					hitnum[computeDis[k]]++;
				}
				if (i % 100 == 0 || i == counter - 1)
					cout << "distance" << computeDis[k] << " hitsnum:" << hitnum[computeDis[k]] << " / " << i + 1 << " " << counter << endl;
				if (i == counter - 1)
				{
					result << setw(5) << setfill(' ')<< hitnum[computeDis[k]] << " ";
				}
			} 
			if (i % 100 == 0 || i == counter - 1)
				cout << endl;
			if (i == counter - 1)
			{
				result << setw(5) << setfill(' ') << counter <<" ";
				result << setw(4) << setfill(' ')<< WIN << "    " << setw(7) << setfill(' ') << coe << endl;
			}
		}
		finish = clock();
		//cout << "timeofcost: "<< finish - start << endl;
		cout << "series length: " << num << endl << endl;
		
	}
	return 0;
}

计算轨迹相似度代码
xiefubao的专栏
10-18 9106
// test1.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include #include #include #include #include #include #include #include #include #include #include
【机器学习】相似度度量方法总结
qq_41340996的博客
05-18 2395
相似性度量 描述样本之间相似度的方法有很多种，一般来说常用的有相关系数和欧式距离。 在做分类时，常常需要估算不同样本之间的相似性度量（Similarity Measurement），这时通常采用的方法就是计算样本间的“距离”（distance）。采用什么样的方法计算距离是很讲究的，甚至关系到分类的正确与否。 欧式距离 曼哈顿距离 切比雪夫距离 闵可夫斯基距离 标准化欧氏距离 马氏距离 夹角余弦 汉明距离 杰卡德距离&杰卡德相似系数 相关系数&相关距离 信息熵 1.欧式距离 平方、求和、开
代码相似度检测
12-13
简单的代码相似度检测，使用Java编写。 算法步骤： S1：剔除程序中所有注释、空行、空格 S2：剔除程序中所有变量、函数名 S3：剩下的部分（实际上主要是有 C++关键词构成的字符串）作为代码特征串 S4：两个特征串之间，使用字符串适量距离（Levenshtein Distance）计算相似度。
相似性和相异性的度量
Norah2
03-01 2044
介绍了相似性度量以及相异性度量的相关概念。其中包含简单匹配系数、Jaccard系数、余弦相似度、Tanimoto系数、皮尔森相关系数等。
python两条轨迹相似度算法_python代码驱动下的 LCSS算法(计算人员轨迹相似度)
weixin_31508009的博客
02-20 4077
1.实验背景最近毕业设计中，希望通过wifi数据计算人员轨迹的相似度。人员轨迹数据按照时间顺序，以地点id的序列来表示。示例：a = [180, 180, 141, 146, 141, 200, 235, 235, 173, 141, 141, 172, 180]b = [165, 235, 180, 141, 240, 171, 173, 172]LCSS算法则可以计算出两个序列之间的最长公共子...
一种基于用户兴趣联合相似度的协同过滤算法
06-10
首先融合覆盖评分信息的用户间的协同相似度、偏好相似度和轨迹相似度等3种相似度,通过参数调节不同度量的权重及相似度阈值形成联合相似度以获取用户有效的邻居数目;其次在联合相似度计算过程中引入反映时间权重的...
【短文本相似度】传统方法BM25解决短文本相似度问题.pdf
09-18
2. BM25算法是基于概率模型的，通过引入新的调节参数对TF-IDF算法进行优化，提高短文本相似度计算的准确性。 3. 在BM25算法中，通过考虑文档长度和查询词频，有效地解决了不同长度文档之间的公平比较问题。 4. 算法...
java 文本语义相似度计算,NLP 语义相似度计算 整理总结
weixin_42343124的博客
03-12 2009
更新中更新时间：2019-12-0318:29:52写在前面：本人是喜欢这个方向的学生一枚，写文的目的意在记录自己所学，梳理自己的思路，同时share给在这个方向上一起努力的同学。写得不够专业的地方望批评指正，欢迎感兴趣的同学一起交流进步。(参考文献在第四部分，侵删)一、背景在很多NLP任务中，都涉及到语义相似度的计算，例如：在搜索场景下(对话系统、问答系统、推理等)，query和Doc的语义相...
使用具有可调节平铺透明度的棋盘检查两个 2D 图像的相似性Matlab代码.rar
01-09
代码中的参数包括平铺透明度的调节参数、图像处理的阈值等。通过这些参数，用户可以对图像的相似度检测进行微调，以适应不同的应用场景。 对于适用对象来说，本代码非常适合计算机、电子信息工程、数学等相关专业的...
python jieba 文本相似度_文本相似度分析（基于jieba和gensim）
weixin_39648430的博客
12-17 2630
##基础概念本文在进行文本相似度分析过程分为以下几个部分进行，文本分词语料库制作算法训练结果预测分析过程主要用两个包来实现jieba，gensimjieba:主要实现分词过程gensim：进行语料库制作和算法训练##结巴(jieba)分词在自然语言处理领域中，分词和提取关键词都是对文本处理时通常要进行的步骤。用Python语言对英文文本进行预处理时可选择NLTK库，中文文本预处理可选择jieba库...
代码行差异统计工具，勇于比较两个代码包的新增，修改，删除的代码量，并能按语言类型归类
11-04
通过例子介绍使用方法如下： 1.差异统计 统计某一个版本的代码包相对于一个原始的基线代码包，变动的代码量 以及变动的代码量中各语言非空非注释行(NBNC)的结果 diffcount 缺省执行的就是差异统计，直接跟上两个代码包的目录即可 在diffcount目录下执行： diffcount test\sp1 test\sp2 实际使用中，可能会有文件名和目录名大小写不一致的情况，如果希望忽略 文件名大小写的差异，需要使用 --ignore-case 参数，否则两个一样的文件 一个会算作删除，一个会算作新增 G:\diffcount>diffcount test\sp1 test\sp2 Diffcount [test\sp1] and [test\sp2] result: LANG ADD MOD DEL A&M BLK CMT NBNC RATE ----------------------------------------------------------------------- C 44 7 26 51 8 11 35 1.00 Pascal 0 0 25 0 0 0 0 0.23 Java 7 4 11 11 0 3 9 0.41 Config 31 4 0 35 1 0 34 0.12 XML 126 0 0 126 2 0 124 0.12 ----------------------------------------------------------------------- Convert all NBNC lines to standard C Total: 57.65 (standard C lines) ADD MOD DEL A&M BLK CMT NBNC RATE 的 含义分别为： 新增、修改、删除、新增+修改、空行、注释、非空非注释行、标准C折算率 2.代码统计： 如果需要，可以把diffcount当作普通的代码行统计工具，统计一个代码包 代码统计使用 -c (或者--count-only)参数, 在diffcount目录下执行 diffcount -c test\count 执行结果如下： G:\diffcount>diffcount -c test\count Counting package [test\count] result: LANG TOTAL BLK CMT NBNC RATE ----------------------------------------------------------------------- C 203 46 61 101 1.00 C++ 57 7 25 25 0.42 Pascal 117 24 17 79 0.23 Java 71 7 24 40 0.41 ASM 129 34 12 85 2.50 C# 18 1 1 17 0.20 Basic 447 140 20 295 0.21 Perl 97 4 26 74 0.16 TCL/TK 91 12 26 54 0.50 Config 116 13 0 103 0.12 XML 126 2 0 124 0.12 ----------------------------------------------------------------------- Convert
推荐系统的应用案例剖析
凌风探梅的专栏
04-13 1284
推荐系统的应用案例剖析 发表于2016-01-04 17:34|1007次阅读| 来源阿里巴巴资深工程师|0 条评论| 作者贾双成 系统谷歌数学原理应用案例 摘要：本章将继续讲述推荐系统的应用案例。为了说明推荐系统的详细实施方案，本章首先详细介绍了一个音乐系统推荐的实施案例，之后为了让读者清晰大型推荐系统的原理，简要介绍一个淘宝周边兴趣点推荐的技术方案。 在《程序员》杂
几种相似度计算代码
_HAIL_的博客
05-14 4478
from math import sqrt """ 余弦相似度 """ def sim_distance_cos(p1,p2): c = set(p1.keys())&set(p2.keys()) if not c: return 0 ss = sum([p1.get(sk)*p2.get(sk) for sk in c]) sq1 = sq...
L1distance和L2distance区别
yanghao201607030101的博客
09-17 7660
L1distance和L2distance区别： L1distance即曼哈顿，即城市距离，各维度距离之和 L2distance即欧式距离，两点间直线距离 参考cs231n课程的一幅图，图上方形和圆形上的点都有相同距离。
数据相似性的度量方法总结
caoyongsheng的博客
04-05 1874
数据相似性的度量方法总结 https://blog.csdn.net/guoziqing506/article/details/51779536 混合类型属性相似度度量 上面说的这几种情况都是数据库中的数据相对类型比较统一，但是很多时候，实际工作中遇到的情况却并非如此。我们遇到的一组数据可能拥有多种类型的属性，也就是混合类型属性。 碰到这种情况，一种一般的处理办法是按照如下公式： 我来解...
轨迹相似性度量
热门推荐
人是一棵会思考的韭菜
07-05 2万+
    轨迹相似性对于移动对象分析来说是一个重要的指标，如何度量轨迹相似性，则是中心问题。轨迹相似性通常用一个距离函数来计算，现行比较常用的轨迹相似性度量指标有多种，而且分别有各自的优势，如何选择不同的轨迹相似性度量是进行轨迹聚类的关键。    在介绍轨迹相似性之前，先考虑如何定义点与轨迹之间的相似性[1]。假设有查询点q与轨迹A,q与A之间的相似性通常定义如下： p'为轨迹A上按照d(.)计算距...
LIP解决轨迹相似度问题（java解决，附代码）
qq_44996414的博客
01-25 1752
1、先看看LCSS的描述 给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。 一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。 两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。 1.1、解析 ...
AirTest 基本使用及框架浅剖析——五分钟上手制作游戏辅助
1_bit 的博客
04-25 1万+
简介 Airtest Project 是为编写自动化脚本，达到提升测试效率的一整套解决方案。它可以轻松的扩展到多平台、多引擎上；如基础的 Android和IOS手机应用、App；Windows上的应用等。 学习使用 Airtest Project 很容易，由于 Airtest Project 是基于Python的，只需要会一点基础的 Python 基础知识即可。Airtest Project 需要...
相似度算法
AnneQiQi的博客
01-19 3130
今天梳理的是底层的应用算法，计算相似度的。这种算法在nlp领域比较常见，其他的地方怎么用就仁者见仁啦～ 相似度算法 算法名称 简单描述 LCS 最长公共子序列 Hamming Distance 汉明距离 Cosine Similarity 余弦相似度算法 1、欧式距离（Euclidean Distance） 欧式距离全称是欧几里距离，是最易于理解的一种距离计算方式，源自欧式空间中两点间的距离公式。 平面空间内...
Rerank相似度
最新发布
03-29
### Rerank 相似度计算方法概述 Rerank 是一种用于重新排列检索到的文档列表的技术，通常基于更复杂的模型来优化排名顺序。其核心目标是通过多种信号（如向量相似度、关键词匹配等）综合评估查询与文档之间的相关性。 #### 综合得分公式解析 综合得分可以通过加权的方式结合多个相似度指标得出。具体而言： \[ \text{综合得分} = (\text{向量相似度权重} \times \text{文档和 query 向量相似度得分}) + (\text{关键词相似度权重} \times \text{文档和 query 关键词相似度得分}) \] 其中： - **向量相似度**：利用嵌入表示（embeddings），衡量两个向量间的余弦距离或其他相似度函数[^1]。 - **关键词相似度**：通过对齐文本中的关键字频率或位置信息，量化两者的语义关联程度。 以下是两种主要相似度计算的具体实现方式及其代码示例。 --- ### 向量相似度计算 向量相似度通常是通过预训练的语言模型生成文本嵌入后得到的结果。常见的做法如下： 1. 使用 Sentence-BERT 或其他句编码器获取 `query` 和 `document` 的嵌入表示； 2. 应用余弦相似度作为两者间的关系强度测量工具。 ```python from sentence_transformers import SentenceTransformer, util def calculate_vector_similarity(query_embedding, document_embeddings): """ 计算 query 与多篇文档之间基于向量的相似度分数。 参数: query_embedding (np.ndarray): 查询的嵌入向量. document_embeddings (list[np.ndarray]): 多篇文档对应的嵌入向量列表. 返回: list[float]: 每篇文档相对于查询的相似度分数. """ scores = [] for doc_emb in document_embeddings: score = util.cos_sim(query_embedding, doc_emb).item() scores.append(score) return scores ``` 此部分实现了如何从已有的嵌入数据出发快速求解余弦相似度。 --- ### 关键词相似度计算 对于关键词相似度，则可以采用 BM25 或 TF-IDF 这样的传统 IR 技术完成初步筛选后再进一步精调。下面展示了一个简单的例子说明过程： ```python import math from sklearn.feature_extraction.text import TfidfVectorizer class KeywordSimilarityCalculator: def __init__(self, documents): self.vectorizer = TfidfVectorizer() self.tfidf_matrix = self.vectorizer.fit_transform(documents) def compute_similarity(self, query): """ 基于 TF-IDF 转换后的矩阵计算 Query 对每篇文章的关键字匹配分值 参数: query (str): 用户输入的问题或者请求字符串 返回: np.array: 表明各文章针对当前提问的重要性评分数组形式呈现出来 """ query_tfidf = self.vectorizer.transform([query]) cosine_similarities = util.cosine_similarity(query_tfidf, self.tfidf_matrix)[0] return cosine_similarities.tolist() # Example Usage calculator = KeywordSimilarityCalculator(["doc1 content", "another article text"]) print(calculator.compute_similarity("example search term")) ``` 上述脚本定义了一种机制用来估算给定条件下不同资源文件里所含主题元素彼此接近的程度。 --- ### 权重调整策略 为了平衡两类特征的作用效果，在实际应用过程中往往还需要引入超参数调节各自贡献比例大小关系。例如设置默认情况下二者重要性的相对高低为7:3即意味着更加侧重考量前者因素的影响力度；当然也可以依据实验结果动态修改这些数值直至达到最佳性能表现为止。 最终完整的 reranking 函数可能看起来像这样: ```python def rerank_documents(query, documents, vector_model, keyword_calculator, weight_vec=0.7, weight_key=0.3): """ 根据 query 和 documents 列表执行 re-ranking 并返回排序后的索引 参数: query (str): 输入查询串 documents (list[str]): 待处理的文章集合 vector_model (...): 句子嵌入模型实例化对象 keyword_calculator (...) : 已初始化好的关键词计算器类实体 weight_vec (float): 向量相似度占比，默认值设为 0.7 weight_key (float): 关键词相似度占比，默认值设定成 0.3 返回: tuple[list[int], list[float]]: 排序后的文档索引以及对应总分 """ # 获取 Embedding 版本下的比较成果 embeddings = [vector_model.encode(d) for d in documents] vec_scores = calculate_vector_similarity(vector_model.encode(query), embeddings) # 执行 Keywords 方面的操作流程 key_scores = keyword_calculator.compute_similarity(query) combined_scores = [(i, wv*vec_score + wk*key_score) for i,(wv,wk),(vec_score,key_score) in zip(range(len(documents)),[(weight_vec,weight_key)]*len(documents), zip(vec_scores,key_scores))] sorted_indices_and_scores = sorted(combined_scores, key=lambda x:x[1], reverse=True) ranked_indices = [idx for idx,_ in sorted_indices_and_scores] final_scores = [score for _,score in sorted_indices_and_scores] return ranked_indices ,final_scores ``` 该版本不仅考虑到了原始检索阶段获得的信息同时也加入了额外层次上的判断从而提高了整体质量水平. ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值