【学习排序】 Learning to Rank中Pointwise关于PRank算法源码实现

package com.example.pointwise;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

/**
 * Pointwise基于点学习排序(Learning to Rank)的Prank算法
 * @author Eastmount YXZ
 * 参考资料
 * 该算法从136维数据集改成46维数据集,中间可能有注释不一致现象
 * （原始论文） http://papers.nips.cc/paper/2023-pranking-with-ranking.pdf
 * （新浪） http://blog.sina.com.cn/s/blog_4c98b960010008xn.html
 * （CSDN）http://blog.csdn.net/pennyliang/article/details/17333373
 */
public class Prank {
	
	public int RANK_NUM = 10000; //记录总样本数 (总行数)
	public int RANK_CATA = 46;   //排序的特征维数 (数据集136维 后改为46维)
	public int RANK_ITER = 1;    //排序的迭代次数 (原文迭代1次)
	public int RANK_LABEL= 3;    //排序划分的阈值 (微软数据集划分5类 0-4) 3维全相关,部分相关,不相关
	
	//采用该方法实现动态数组添加数据
	List<Float> weight = null;   //特征值的权重向量 (46个 136个)
	//训练集数据 每行共48个数据  (46个特征值 二维数组-feature[行号][46] + 真实Label值0-2 + qid值)
	List<List<Float>> x = null;       
	Float [] b = null;           //阈值数 K+1个(RANK_LABEL+1)
	public int sumLabel = 0;     //文件总行数 (标记数)
	
	/**  
	 * 函数功能 读取文件
	 * 参数 String filePath 文件路径
	 */
	public void ReadTxtFile(String filePath) throws IOException {
		String encoding="GBK";
		File file = new File(filePath);  //文件
		BufferedReader bufferedReader = null;
		try {
			//判断文件是否存在
			if(file.isFile() && file.exists()) { 
				//输入流
				InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding); 
			    bufferedReader = new BufferedReader(read);
				String lineTxt = null;
				sumLabel =0;  //记录总样本数
				x = new ArrayList<List<Float>> ();
				
				//按行读取数据并分解数据
				while((lineTxt = bufferedReader.readLine()) != null) {
					String str = null;
					int lengthLine = lineTxt.length();
					List<Float> subList=new ArrayList<Float>();
					x.add(subList);
					//获取数据 字符串空格分隔
                	String arrays[] = lineTxt.split(" ");
                	for(int i=2; i<arrays.length; i++) {
                		if(i>=48) { //#号后跳出 后面注释不进行读取
	    					continue;
	    				}
                		 //获取特征:特征值 如1:0.0004
                		String subArrays[] = arrays[i].split(":");
                		int number = Integer.parseInt(subArrays[0]); //判断特征 
	    				float value = Float.parseFloat(subArrays[1]); 
	    				subList.add(value);	
                	}
                	//获取每行样本的Label值 i=0 （五个等级0-4）
                	subList.add(Float.parseFloat(arrays[0]));
                	//获取qid值 i=1
                	String subArrays[] = arrays[1].split(":");
                	subList.add(Float.parseFloat(subArrays[1]));
                	//总行数+1
                	sumLabel++;  
				} //End 按行读取
				read.close();
			} else {
        		System.out.println("找不到指定的文件\n");
        	}
		} catch (Exception e) {
            System.out.println("读取文件内容出错");
            e.printStackTrace();
        } finally {
        	bufferedReader.close();
        }
	}
	
	/**
	 * 函数 写文件
	 * 参数 String filePath 文件路径
	 * 注意 该函数还是136维数据，但算法该成46维 故不使用该函数 
	 */
	public void WriteTxtFile(String filePath) {
		try {
			System.out.println("文件输出");
			String encoding = "GBK";
			FileWriter fileWriter = new FileWriter(filePath);
			//按行写文件
			for(int i=0; i<sumLabel; i++) {
				fileWriter.write("样本行数"+i+"\r\n");
				fileWriter.flush();   
				String value;
				//写数据特征值 136
				for(int j=0;j<136;j++) {
					value = String.valueOf(x.get(i).get(j)); //输出第i行 第j个特征值 
 					fileWriter.write(value+" ");
				}
				//label等级 qid
				fileWriter.write("\r\n");
				value = String.valueOf(x.get(i).get(136)); //label
				fileWriter.write(value+" ");
				value = String.valueOf(x.get(i).get(137));
				fileWriter.write(value+" ");
				fileWriter.write("\r\n");
			}
			fileWriter.close();
		} catch(Exception e) {
			e.printStackTrace();
		}
	} 
	
	/**
	 * 学习排序
	 * 主要功能计算136维权重w和划分五个等级的阈值b
	 */
	public void LearningToRank() {
		int realRank;                         //真实Label等级
		int predictRank;                      //预测Label等级
		Float[] y= new Float[RANK_LABEL+1];   //new label
		Float tao [] = new Float[RANK_LABEL+1];
		
		//初始化权重 全为0
		weight = new ArrayList<Float>();
		for(int i=0; i< RANK_CATA; i++){ //特征向量的维数
			weight.add((float) 0.0);
		}
		//初始化阈值 b[0]=b[1]=[2]=0 b[3]=正无穷大
		b=new Float[RANK_LABEL+1];
		for(int i=0; i<RANK_LABEL; i++){ //b[0] b[1] b[2]
			b[i] = (float) 0.0;
		}
		b[RANK_LABEL] = Float.POSITIVE_INFINITY; //b[3]
		
		/*
		 * 开始计算权重 
		 * 注意:迭代主要参照CSDN博客,它没有退出.同时没有损失计算,其结果差别不大
		 * 同时原论文中Loop 1...T是总行数 并没有讲述迭代
		 */
		for(int iter = 0; iter < RANK_ITER; iter++){  //总的迭代次数 RANK_ITER=1
			for(int i=0; i< RANK_NUM; i++){   //总样本数 可以设置读取txt中部分
				//测试顺序
				predictRank = 1;
				//权重*特征向量-阈值
				float sumWX = (float) 0.0;
				for(int z=0; z<46; z++) {
					sumWX += weight.get(z)*x.get(i).get(z);    
				}	
				//预测排名
				for(int r=1;r<=RANK_LABEL;r++) { //阈值数 RANK_LABEL=3
					if(sumWX-b[r]<0) {
						predictRank = r;
						break;
					}
				}
				//获取真实等级 即数据集中第一个Label数字
				realRank = Math.round(x.get(i).get(46)); //四舍五入并转整数
				if(realRank!=predictRank) {
					for(int r=1; r < RANK_LABEL; r++){//若136维数据 5个值时
						if(realRank <= r) {	  // y形如 1 1 -1 -1 -1
							y[r] = (float)-1;
						}
						else {
							y[r] = (float)1;
						}
					}
					float tao_sum = (float) 0.0;    //tau和
					for(int r=1; r < RANK_LABEL; r++) {   //三个等级
						//权重*特征向量-阈值
						if((sumWX - b[r]) * y[r] <= 0) {
							tao[r] = y[r];
						} else {
							tao[r] = (float) 0.0;
						}
						tao_sum += tao[r];	
					}
					//更新数据
					for(int z=0; z<RANK_CATA; z++) {  //136维权重
						float newWeight = weight.get(z) +tao_sum*x.get(i).get(z);
						weight.set(z, newWeight);
					}		
					for(int r=1;r < RANK_LABEL;++r) {  //5个阈值
	                        b[r] = b[r] - tao[r];	
	                }
				} //End if
				else {
					continue;
				}
			} //End 样本总数
		} //End 迭代次数
	}
	
	/**
	 * 函数 预测排序结果
	 * 主要 通过LearningToRank()函数计算的得分计算分数,再根据阈值划分等级
	 */
	public void PredictNewLabel() {
		float rightCount = 0;
		float score = (float) 0.0;
		for(int i=0; i < RANK_NUM; i++){
			int predict_r = 1;
			//权重*特征向量-阈值 (W*X-B)
			float sumWX = (float) 0.0; 
			for(int z=0; z<46; z++) {
				sumWX = sumWX + weight.get(z) * x.get(i).get(z);
			}
			for(int r=1; r<= RANK_LABEL; r++){  //5
				if(sumWX < b[r]){
					score = sumWX;
					predict_r = r;
					break;
				}
			}
			//计算正确概率
			if(predict_r == Math.round(x.get(i).get(46))) //46维数据 46-label 47-qid 0-45特征值
			{
				rightCount++;
			}
			System.out.println("predict="+predict_r+" score="+score+" real="+x.get(i).get(46));
		}
		//输出结果
		System.out.println("正确率:"+rightCount/(float)RANK_NUM);
		System.out.println("输出阈值");
		for(int i= 1;i<4;i++){
			System.out.println(b[i]+" ");
		}
	}
	
	
	/**
	 *	主函数 
	 */
	public static void main(String[] args) {
		
		String fileInput = "train.txt";
		String fileOutput = "output.txt";
		String fileRank = "rank.txt";
		//实例化
		Prank prank = new Prank();
		try {
			//第一步 读取文件并解析数据
			prank.ReadTxtFile(fileInput);
			//第二步 输出解析的基础数据
			//prank.WriteTxtFile(fileOutput);
			//第三步 学习排序训练模型
			prank.LearningToRank();
			//第四步 测试打分排序
			prank.PredictNewLabel();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * End
	 */
}