数据研究之综合评分(三) 多指标下的对比-寻找相似的城市

最新推荐文章于 2023-02-26 14:17:39 发布
最新推荐文章于 2023-02-26 14:17:39 发布
阅读量1k 收藏 1
点赞数 1
文章标签： 大数据 算法 数据结构 分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a13871125303/article/details/81224786
版权

背景:

城市的数据指标多种多样,人口数量,GDP,土地面积等等

我们有的时候想要找相似的城市,例如 人口体量大体相同  土地面积大体相同 连GDP也大体相同

sql方式:计算在数据库当中进行

在同一年内找相似城市

SELECT
	area_code
FROM
	(
		SELECT
			count(*) count,
			area_code
		FROM
			(
				SELECT
					b.area_code area_code,
					b.quota_code quota_code
				FROM
					(
						SELECT
							quota_code,
							score_value
						FROM
							score_dat
						WHERE
							area_code = '420100'#城市码
						AND static_year = 2016 #具体的年份
						AND quota_code IN ('Z110101','Z170408','Z140606') #各种指标码
					) a,
					(
						SELECT
							quota_code,
							area_code,
							score_value
						FROM
							score_dat
						WHERE
							static_year = 2016 #具体的年份
						AND quota_code IN ('Z110101','Z170408','Z140606') #各种指标码
					) b
				WHERE
					a.quota_code = b.quota_code
				AND a.score_value <= b.score_value * (1 + 
(CASE WHEN b.quota_code='Z110101' THEN 0.2 WHEN b.quota_code = 'Z170408' THEN 0.2 WHEN b.quota_code = 'Z140606' THEN 0.2 END))#不同指标码可以设置不同的偏移量
				AND a.score_value >= b.score_value * (1 - 
(CASE WHEN b.quota_code='Z110101' THEN 0.2 WHEN b.quota_code = 'Z170408' THEN 0.2 WHEN b.quota_code = 'Z140606' THEN 0.2 END))#不同指标码可以设置不同的偏移量
			) c
		GROUP BY
			area_code
	) d
WHERE
	count >= 3#指标码的个数

结果:

420100,510100

时间:0.06s

数据量20万条数据

把自己也给查询出来了,如果不想显示自己,在sql中添加个!=就可以了

在不同年代中找相似的城市

SELECT
	area_code,static_year
FROM
	(
		SELECT
			count(*) count,
			area_code,
			static_year
		FROM
			(
				SELECT
					b.area_code area_code,
					b.quota_code quota_code,
					b.static_year static_year
				FROM
					(
						SELECT
							quota_code,
							score_value
						FROM
							score_data
						WHERE
							area_code = '420100'#城市码
						AND static_year = 2016 #具体的年份
						AND quota_code IN ('Z110101','Z170408','Z140606') #各种指标码
					) a,
					(
						SELECT
							quota_code,
							area_code,
							score_value,
              static_year
						FROM
							score_data
						WHERE
						 quota_code IN ('Z110101','Z170408','Z140606') #各种指标码
					) b
				WHERE
					a.quota_code = b.quota_code
				AND a.score_value <= b.score_value * (1 + 
(CASE WHEN b.quota_code='Z110101' THEN 0.2 WHEN b.quota_code = 'Z170408' THEN 0.2 WHEN b.quota_code = 'Z140606' THEN 0.2 END))#不同指标码可以设置不同的偏移量
				AND a.score_value >= b.score_value * (1 - 
(CASE WHEN b.quota_code='Z110101' THEN 0.2 WHEN b.quota_code = 'Z170408' THEN 0.2 WHEN b.quota_code = 'Z140606' THEN 0.2 END))#不同指标码可以设置不同的偏移量
			) c
		GROUP BY
			area_code,static_year
	) d
WHERE
	count >= 3#指标码的个数

420100    2016
420100    2017
510100    2016
510100    2017

时间:0.065s

数据量20万条数据

把自己也给查询出来了,如果不想显示自己,在sql中添加个!=就可以了

代码方式:在程序当中计算

在程序计算的前提是,需要加载整张数据表的数据到内存当中

数据库的数据的数据结构

//保存数据库的数据的数据结构
public class FBStructure {
	private Map<String, Map<Integer, List<ScoreGrade>>> indexYearScore;
	private Map<String, Map<Integer, List<ScoreGrade>>> cityYearScore;
	public Map<String, Map<Integer, List<ScoreGrade>>> getIndexYearScore() {
		return indexYearScore;
	}
	public void setIndexYearScore(Map<String, Map<Integer, List<ScoreGrade>>> indexYearScore) {
		this.indexYearScore = indexYearScore;
	}
	public Map<String, Map<Integer, List<ScoreGrade>>> getCityYearScore() {
		return cityYearScore;
	}
	public void setCityYearScore(Map<String, Map<Integer, List<ScoreGrade>>> cityYearScore) {
		this.cityYearScore = cityYearScore;
	}
	
}

用于前台展示的数据结构

//用于前台展示的数据结构
List<Map<String,Object>> frontBackList;
	List<String> notExist;
	public List<Map<String, Object>> getFrontBackList() {
		return frontBackList;
	}
	public void setFrontBackList(List<Map<String, Object>> frontBackList) {
		this.frontBackList = frontBackList;
	}
	public List<String> getNotExist() {
		return notExist;
	}
	public void setNotExist(List<String> notExist) {
		this.notExist = notExist;
	}

核心代码:

/**
	 * 从DB中获取需要的数据结构
	 * @return
	 */
	private synchronized FBStructure getStructureByDB(){
		long expireTime = SystemConfig.EXPIRE_TIME;
		if(expiryMap==null) {
			expiryMap = ExpiryCache.getExpiryMap();
		}
                //从内存当中查询数据
		FBStructure fBStructure = (FBStructure)expiryMap.get("fBStructure");
		List<ScoreGrade> selectAllScoreGrade = null;
		if(fBStructure==null) {
			fBStructure = new FBStructure();
                        //一个用于管理引用的方法 expireTime过期时间
			expiryMap.put("fBStructure", fBStructure,expireTime);
                        //从redis中加载数据
			String scoreJson = redisClientUtils.get("score_city", 0);
			if(scoreJson==null) {
                                //从数据库当中查询数据
				selectAllScoreGrade = conStaticDao.selectAllScoreGrade();
				scoreJson = JacksonUtil.writeValueAsString(selectAllScoreGrade);
				redisClientUtils.set("score_city", scoreJson, 0);
			}else {
				List<Map<String,Object>> scoreMapList = JacksonUtil.readValue(scoreJson, List.class);
				selectAllScoreGrade = new LinkedList<ScoreGrade>();
				ScoreGrade scoreGrade = null;
				for (Map<String, Object> map : scoreMapList) {
					scoreGrade = new ScoreGrade();
					selectAllScoreGrade.add(scoreGrade);
					scoreGrade.setAreaCode( map.get("areaCode").toString());
					scoreGrade.setAreaName(map.get("areaName").toString());
					scoreGrade.setIndexId(map.get("indexId").toString());
					scoreGrade.setScoreValue(Float.parseFloat(map.get("scoreValue").toString()));
					scoreGrade.setStaticYear(Integer.parseInt(map.get("staticYear").toString()));
				}
			}
			//indexId:staticYear:scoreGrade
			Map<String,Map<Integer,List<ScoreGrade>>> indexYearScore = new HashMap<String,Map<Integer,List<ScoreGrade>>>();
			Map<String,Map<Integer,List<ScoreGrade>>> cityYearScore = new HashMap<String,Map<Integer,List<ScoreGrade>>>();
			Map<Integer,List<ScoreGrade>> tIdYearScore = null;
			Map<Integer,List<ScoreGrade>> rCodeYearScore = null;
			List<ScoreGrade> tIdScoreList = null;
			List<ScoreGrade> tCodeScoreList = null;
			String tIndexId = null;
			Integer tStaticYear = null;
			String tAreaCode = null;
			for (ScoreGrade scoreGrade : selectAllScoreGrade) {
				tIndexId = scoreGrade.getIndexId();
				tStaticYear = scoreGrade.getStaticYear();
				tAreaCode = scoreGrade.getAreaCode();
				tIdYearScore = indexYearScore.get(tIndexId);
				if(tIdYearScore==null) {
					tIdYearScore = new HashMap<Integer,List<ScoreGrade>>();
					indexYearScore.put(tIndexId, tIdYearScore);
				}
				tIdScoreList = tIdYearScore.get(tStaticYear);
				if(tIdScoreList==null) {
					tIdScoreList = new LinkedList<ScoreGrade>();
					tIdYearScore.put(tStaticYear, tIdScoreList);
				}
				tIdScoreList.add(scoreGrade);
				rCodeYearScore = cityYearScore.get(tAreaCode);
				if(rCodeYearScore==null) {
					rCodeYearScore = new HashMap<Integer,List<ScoreGrade>>();
					cityYearScore.put(tAreaCode, rCodeYearScore);
				}
				tCodeScoreList = rCodeYearScore.get(tStaticYear);
				if(tCodeScoreList==null) {
					tCodeScoreList = new LinkedList<ScoreGrade>();
					rCodeYearScore.put(tStaticYear, tCodeScoreList);
				}
				tCodeScoreList.add(scoreGrade);
			}
			fBStructure.setCityYearScore(cityYearScore);
			fBStructure.setIndexYearScore(indexYearScore);
		}
		expiryMap.setExpire("fBStructure", expireTime);
		return fBStructure;
	}
/**
 * 查询相似城市indexIds 指标项数组 offsets偏移量数组 staticYear目标年份 
 * areaCode城市码 sortIndex用于排序的指标字段 frontBack:true返回排序指标前20名的数据
*frontBack:false返回排序指标后20名的数据  isSync:true查询staticYear年份的城市
*isSync:false查询不同年份的城市
*/ 
	public FBResult selectFrontAndBackCity(String[] indexIds,Integer[] offsets,
			Integer staticYear,String areaCode,String sortIndex,Boolean frontBack,Boolean isSync){
		FBResult result = new FBResult();
		FBStructure fBStructure = this.getStructureByDB();
		Map<String, Map<Integer, List<ScoreGrade>>> indexYearScore = fBStructure.getIndexYearScore();
		Map<String, Map<Integer, List<ScoreGrade>>> cityYearScore = fBStructure.getCityYearScore();
		if(sortIndex == null) {
			//默认排序
			sortIndex = SystemConfig.SORT_INDEX_ID;
		}
		if(isSync==null) {
			//默认同步
			isSync = true;
		}
		//默认正面城市
		if(frontBack==null) {
			frontBack = true;
		}
		int flag =0;
		for (String indexId : indexIds) {
			if(sortIndex.equals(indexId)){
				flag = 1;
				break;
			}
		}
		if(flag==0) {
			sortIndex = indexIds[0];
		}
		int index = 0;
		Float value = null;
		Float offset = null;
		//indexId:scoreValue
		Map<String,Float> benchmarkingCityMap =new HashMap<String,Float>();
		//获取指定年份城市指标
		Map<Integer, List<ScoreGrade>> codeYearScore = cityYearScore.get(areaCode);
		List<ScoreGrade> codeScoreList = codeYearScore.get(staticYear);
		for (ScoreGrade scoreGrade : codeScoreList) {
			benchmarkingCityMap.put(scoreGrade.getIndexId(), scoreGrade.getScoreValue());
		}
		Map<Integer, List<ScoreGrade>> yearScore = null;
		Map<String,Map<Integer,Map<String,Object>>> codeYearCountValue = new HashMap<String,Map<Integer,Map<String,Object>>>();
		Collection<List<ScoreGrade>> scoreListCollection = null;
		List<ScoreGrade> scoreList = null;
		String quotaName =null;
		List<String> notExist = new LinkedList<String>();
		Map<String, String> quotaMap = this.getQuotaMap();
		for (String indexId : indexIds) {
			value = benchmarkingCityMap.get(indexId);
			if(value==null) {
				quotaName = quotaMap.get(indexId);
				notExist.add(quotaName);
			}
		}
		if(!notExist.isEmpty()) {
			result.setNotExist(notExist);
			return result;
		}
		for (String indexId : indexIds) {
			index++;
			value = benchmarkingCityMap.get(indexId);
			offset = Math.abs((offsets[index-1]/(float)100));
			yearScore = indexYearScore.get(indexId);
			if(isSync) {
				scoreList = yearScore.get(staticYear);
				inCodeYearCountValue(areaCode, sortIndex, value, offset, scoreList, codeYearCountValue, indexId);
			}else {
				scoreListCollection = yearScore.values();
				for (List<ScoreGrade> list : scoreListCollection) {
					inCodeYearCountValue(areaCode, sortIndex, value, offset, list, codeYearCountValue, indexId);
				}
			}
		}
		int length = indexIds.length;
		Map<String, Map<Integer, Map<String, Object>>> codeYearSortCityValue = filterAndSort(length,
				codeYearCountValue);
		List<Map<String,Object>> sortList = new LinkedList<Map<String,Object>>();
		intoBestYearArea(codeYearSortCityValue, sortList);
		List<Map<String, Object>> frontBackList = frontBackSort(frontBack, sortList);
		result.setFrontBackList(frontBackList);
		return result;
	}
	/**
	 * 取最早或最迟的年份
	 * @param codeYearSortCityValue
	 * @param sortList
	 */
	private void intoBestYearArea(Map<String, Map<Integer, Map<String, Object>>> codeYearSortCityValue,
			List<Map<String, Object>> sortList) {
		Collection<Map<Integer, Map<String, Object>>> yearSortCityValueList = codeYearSortCityValue.values();
		Collection<Map<String, Object>> sortCityValues = null;
		Iterator<Map<String, Object>> iterator = null;
		Map<String, Object> cityValue = null;
		for (Map<Integer, Map<String, Object>> yearSortCityValue : yearSortCityValueList) {
			sortCityValues = yearSortCityValue.values();
			iterator = sortCityValues.iterator();
			if(iterator.hasNext()) {
				cityValue = iterator.next();
				sortList.add(cityValue);
			}
		}
	}
	/**
	 * 筛选并排序返回
	 * @param length
	 * @param codeYearCountValue
	 * @return
	 */
	private Map<String, Map<Integer, Map<String, Object>>> filterAndSort(Integer length,
			Map<String, Map<Integer, Map<String, Object>>> codeYearCountValue) {
		Integer count = null;;
		Map<String,Map<Integer,Map<String,Object>>> codeYearSortCityValue = new HashMap<String,Map<Integer,Map<String,Object>>>();
		Map<Integer,Map<String,Object>> yearSortCityValue = null;
		Map<String,Object> cityValue = null;
		Map<Integer,Map<String,Object>> yearCountValue = null;
		Set<Integer> years = null;
		Map<String, Object> countValue = null;
		Set<Entry<String, Map<Integer, Map<String, Object>>>> entrySet = codeYearCountValue.entrySet();
		String nowAreaCode = null;
		for (Entry<String, Map<Integer, Map<String, Object>>> entry : entrySet) {
			nowAreaCode = entry.getKey();
			yearCountValue = entry.getValue();
			years = yearCountValue.keySet();
			for (Integer yearKey : years) {
				countValue = yearCountValue.get(yearKey);
				count = (Integer) countValue.get("count");
				//筛选
				if(count==length) {
					yearSortCityValue = codeYearSortCityValue.get(nowAreaCode);
					if(yearSortCityValue==null) {
						//排序
						yearSortCityValue = new TreeMap<Integer,Map<String,Object>>();
						codeYearSortCityValue.put(nowAreaCode, yearSortCityValue);
					}
					cityValue = yearSortCityValue.get(yearKey);
					if(cityValue==null) {
						cityValue = new HashMap<String,Object>();
						yearSortCityValue.put(yearKey, cityValue);
						cityValue.put("areaCode", nowAreaCode);
						cityValue.put("value", countValue.get("value"));
						cityValue.put("areaName", countValue.get("areaName"));
						cityValue.put("staticYear", yearKey);
					}
				}
			}
		}
		return codeYearSortCityValue;
	}
	/**
	 * 指定正反取20条以内数据,并排序
	 * @param frontBack
	 * @param sortList
	 * @return
	 */
	private List<Map<String, Object>> frontBackSort(final Boolean frontBack, List<Map<String, Object>> sortList) {
		Collections.sort(sortList, new Comparator<Map<String,Object>>() {
			@Override
			public int compare(Map<String, Object> o1, Map<String, Object> o2) {
				Float o1F = (Float) o1.get("value");
				Float o2F = (Float) o2.get("value");
				if(frontBack) {
					return o2F.compareTo(o1F);
				}else {
					return o1F.compareTo(o2F);
				}
			}
		});
		int size = sortList.size();
		if(size>40) {
			size = 40;
		}
		int end;
		if(frontBack&&size%2!=0) {
			end = size/2+1;
		}else {
			end = size/2;
		}
		List<Map<String, Object>> frontBackList = sortList.subList(0, end);
		return frontBackList;
	}
	/**
	 * 封装数据结构
	 * @param areaCode
	 * @param sortIndex
	 * @param value
	 * @param offset
	 * @param scoreList
	 * @param codeYearCountValue
	 * @param indexId
	 */
	private void inCodeYearCountValue(String areaCode, String sortIndex, Float value, Float offset,
			List<ScoreGrade> scoreList, Map<String,Map<Integer,Map<String,Object>>> codeYearCountValue, String indexId) {
		Map<Integer,Map<String, Object>> yearCountValue = null;
		Map<String, Object> countValue;
		Integer count;
		Float nowValue = null;
		String nowAreaCode = null;
		String nowAreaName = null;
		Integer nowYear = null;
		for (ScoreGrade scoreGrade : scoreList) {
			nowValue = scoreGrade.getScoreValue();
			nowAreaCode = scoreGrade.getAreaCode();
			nowAreaName = scoreGrade.getAreaName();
			nowYear = scoreGrade.getStaticYear();
			//排除对标城市
			if(scoreGrade.equals(areaCode)) {
				continue;
			}
			if(nowValue>=value*(1-offset)&&nowValue<=value*(1+offset)) {
				yearCountValue = codeYearCountValue.get(nowAreaCode);
				if(yearCountValue==null) {
					yearCountValue = new HashMap<Integer,Map<String, Object>>();
					codeYearCountValue.put(nowAreaCode, yearCountValue);
				}
				countValue = yearCountValue.get(nowYear);
				if(countValue==null) {
					countValue = new HashMap<String,Object>();
					yearCountValue.put(nowYear, countValue);
					countValue.put("count", 0);
					countValue.put("areaName", nowAreaName);
				}
				count = (Integer) countValue.get("count");
				countValue.put("count", count+1);
				if(sortIndex.equals(indexId)) {
					countValue.put("value", nowValue);
				}
			}
		}
	}

后言:

数据库计算方式:

  优点:不需要加载数据到内存

  缺点:1.数据表过大时,查询会慢到令人无法忍受(可以通过水平分表解决)

           2.数据库压力大,并发能力有限

程序计算方式:

  优点:速度快,并发承载能力强

  缺点:占用内存资源

(20w的表,数据量也才占用几十M的内存(主要看一条数据占多少内存),数据表太大,内存无法放下可以通过分布式计算解决)

两种方式各有优劣,具体使用哪种方式还要看实际情况而定

 

紫月风清
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
电影评分数据集-用于电影推荐系统
02-12
电影评分数据集-用于电影推荐系统。有两个数据集。 数据集1：包括movies.csv和ratings...包含了6000多位用户对近3900个电影的共100万（1,000,209）条评分数据，评分均为1～5的整数，其中每个电影的评分数据至少有20条。
数据挖掘思维和实战17 实践 2：如何使用 word2vec 和 k-mean 聚类寻找相似的城市
fegus的博客
10-08 567
在这一节实践课程中，我着重介绍了整个模型训练环节的代码，其中主要写了两段代码，分别训练了 Word2Vec 模型和 K-means 模型。除了数据部分，这些代码几乎可以复制即运行。到这一课时，关于聚类问题的内容就告一段落了，在数据缺少标注的时候，聚类算法是十分常用的，它可以帮助我们了解数据情况。当然，聚类方法也存在一些局限，还需要在日常的工作中多加练习，不断积累自己的经验。
数据挖掘模型介绍之一：相似度模型
一些杂七杂八的想法
02-17 1万+
1. 相似度模型的应用场景 简单的说，相似度模型的应用场景就是，需要找到和某个实体相似的其他实体。 比如： （1）商铺选址：某公司要在新城市开新的店铺，需要选址，可以使用相似度模型，找到和现有市场中表现好的商铺地址相似的地点； （2）广告宣传：其实和商铺选址类似，要选择一个好的宣传地点，可以使用相似度模型，找到和现有最好的宣传地点最相似的地点； （3）个性化推荐：这是现在互联网领域，尤其
hofstede六个维度指数指标_多维度对比分析的雷达图
weixin_39574246的博客
11-28 2399
今天看了一下自己的百家号指数，突破700分了，如下图，突发奇想，这种类型的图是不是自己也能制作？当然可以了，这个叫做雷达图，我们通常会看到气象雷达，它是以从同一点开始的轴上表示的三个或更多变量的二维图表的形式显示多变量数据的图形方法，也称之为蜘蛛图、网络图等。通常用来反应几个指标的变化情况，如财务指标收益性、生产性、流动性、安全性和成长性的评价，游戏里面经常会遇到雷达图，如王者荣耀中对战绩、生存、...
基于Pandas和Matplotlib实现的模型网络指标对比图工具
m0_63642362的博客
02-26 1261
自己造轮子是一件很折腾，但也很有意思的事情。可以培养自己除了开发之外，关于产品和用户角度的一些思维。关于这个工具，后续也会引入和支持更多的绘图方式来辅助算法选型和科研需要。最后，也在PFCC的推荐下，给PaddleYOLO和PaddleDetection提交了相应的PR，目前已被合入，后面又做了微调。林旭 某小厂算法架构师AICA六期班学员飞桨PFCC成员飞桨PPDEGithub主页:https://github.com/isLinXu。
Kaggle-电信客户流失分析及应对措施
Graow的博客
06-28 3866
Kaggle-电信客户流失分析及应对措施-随机森林分析原因分析目标分析背景数据集内容分析流程分析结果制定策略对流失用户进行召回总结 分析原因 在产品使用过程中,一些用户会因为各式各样的原因而不再使用我们的产品, 这些用户难道就任由他们流失了吗？ 分析目标 正面,通过对流失客户的分析,我们产品质量和生命周期得到优化 反面,分析所有相关的客户数据，并开发针对性的客户保留服务 分析背景 项目数据来源于Kaggle-电信客户流失 数据集内容 1. 上个月内离开的客户–该列称为“客户流失” 2. 每个客户已签署的服务
数据集-电影评分数据-movieles-可用于做毕设实验.zip
最新发布
03-14
资源名称：js数据集-电影评分数据-movieles-可用于做毕设实验.zip 内容概要：是一款数据集，电影评分数据，已经做好了分类和数据说明。特别简单易用。 关键信息：可以用于数据分析，大数据，推荐系统的学习和实验，...
多指标综合评分法优选β-环糊精辅助提取制首乌工艺
02-21
多指标综合评分法优选β-环糊精辅助提取制首乌工艺，崔明磊，任晓亮，目的：研究β-环糊精辅助提取制首乌活性成分的工艺。方法：采用层次分析法（AHP），以二苯乙烯苷、大黄素、大黄素甲醚提取转移率为
评分卡-数据集
03-16
评分卡在IT行业中，特别是在数据分析、风险管理和信用评估领域，是一种重要的工具。它通过将复杂的模型预测结果转化为直观的分数，使得决策者可以快速理解和应用这些预测。本数据集名为"评分卡-数据集"，其中包含一...
DSR动态评分-数据解读.doc
12-01
DSR 动态评分-数据解读 DSR 动态评分是淘宝平台上的一个评价系统，旨在评估卖家的信誉度和店铺的服务质量。该系统将店铺的好评率、信誉点、产品好评率和 DSR 评分四个方面的因素进行综合评估，以确定卖家的服务质量...
仿51job类似城市选择弹窗效果
08-24
仿51job类似城市选择弹窗效果，支持多级选项
数据特征分析方法总结
Whitney66的博客
04-04 2万+
数据特征分析方法总结 21世纪是大数据的时代，因为这些大数据中蕴含着时代发展的信息。如何科学地分析数据特征是数据分析师必须掌握的基础技能之一。因此，我今天主要希望通过理论推导并实现一些常用的数据特征分析方法来加强对数据特征处理的能力。 分布分析 分布分析:研究数据的分布特征和分布类型，分为定量数据和定性数据，并通过这两种类型来区分基本统计量。 常用指标为：极差、频率分布情况、分组组距及组数 # 读取数据 data = pd.read_csv('data/深圳罗湖二手房信息.csv', engine='pyt
数据研究之综合评分(一) 权重-评分-指标
a13871125303的博客
01-07 2万+
背景: 大数据火热的背景下,数据的深层次挖掘成了一个热门的话题,单一类型的数据.只需要看不同年份数值,即可以明白其含义,然而很多时候研究方向是多维度,多类型的数据,这个时候,无法在一张图表上更好的展示.这个时候就引入了评分机制,人为的为数据打分,然而不同类型的数据是无法互相影响的,这个时候我们就引入了权重这个概念. 评分: 什么是评分? 以城市的GDP为例,2015年广东的GDP有7.2万...
多指标综合评价方法汇总
热门推荐
饭饭认认米的博客
10-27 10万+
写在前面上学的时候，有一门综合评价的课程，那时候没觉得以后会用到它，现在才发现是那么实用，实际应用中如果采用单指标进行评价给人的感觉总是有偏驳的，除非是那种极其可靠且明确其重要性的指标。近期基本上把老课本里的方法翻了个老底，以前觉得这门课程似乎挺难的，现在看来只是以前没有深入的好好看，方法简单且实用。 综合评价的方法一般是主客观结合的，方法的选择需基于实际指标数据情况选定，最为关键的是指标的选取，
图像质量评价，图片放大和缩小
Gone_HuiLin的博客
11-18 1143
#include #include #include #include using namespace cv; using namespace std; // PSNR 峰值信噪比计算 返回数值为30-50dB 值越大越好 double PSNR(const Mat& I1, const Mat& I2) {     cv::Mat s1;     // 计算图像差|I
信息检索笔记-完整搜索系统的评分计算
继续微笑lsj
10-04 4154
前面我们给出了文档评分中词项权重计算的理论，并由此导出向量空间模型和基本余弦相似度评分算法。当然不少策略不会精确返回与查询相匹配的K篇文档，一些策略也可以推广到余弦相似度计算之外的其他场合中去。 快速评分算法以及排序     前面介绍通过计算查询与文档的余弦相似度来给文档评分：          在上面这个公式中，我们对V(q)，进行了一个归一化处理。例如查询q=[je
数据指标种类
zjlamp的博客
10-11 1万+
1、定性指标与定量指标 （1）定性指标通常是非结构化的、经验性的、揭示性的、难以归类的。 定性数据吸纳主观因素。 （2）定量指标涉及很多数值和统计数据，提供可靠的量化结果，但缺乏直观的观察。 定量数据排斥主观因素。   2、虚荣指标与可付诸实施的指标 （1）虚荣指标看上去很美，让你感觉良好，却不能为你的公司带来丝毫的改变。如“总注册用户数”、“总活跃用户数” 如果你有一个数据，却不...
数据分析——统计学多指标统计方法
huangyiting1990的博客
01-30 3212
一、多变量分析方法的选择 https://pan.baidu.com/s/1ogCfSwcNvxlJXPhPzeHlGQ 提取码: qs3d； 分析的目的：区分有监督分析和无监督分析 1、有因变量，则建立有监督模型； 1）因变量为连续变量（建立的模型称为回归预测模型），自变量为连续变量时，可选择回归分析、方差分析；自变量为分类变量或分类+连续变量，可选择带虚拟变量的回归分析、联合分析、方差分析； 2）因变量为分类变量（建立的模型称为分类预测模型），当自变量为连续变量（或连续+分类变量）时，可选用判别分析、L
lucene评分-相似度算法的优化
DancingCalf的专栏
04-25 1112
lucene评分里使用的默认相似度算法是BM25，官方文档对BM25的参数(k1,b)调节有专门的介绍。 但是在短文本的场景下，就算是调节k1(一般调到0.3)，也不能避免经常出现错误的评分排序。 研读lucene源码,在 BM25Similarity 这个类里，计算tfNorm的时候，公式是 (freq * (k1 + 1)) / (freq + k1 * (1 - b + b * field...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值