scratch/CosineSimUtility.java at master · debanjanghosh/scratch · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
package com.rutgers.util;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public  class CosineSimUtility
{

	private static HashMap<Double, Double> unigramIdfMap;


	public static void setUnigramMap( HashMap<Double, Double > idfMap )
	{
		unigramIdfMap = idfMap ;
	}

	public static double getIdf(double context)
	{
		Double value = unigramIdfMap.get(context);
		if ( null == value )
		{
			System.out.println("unigram do not contain this context - check ");
			return 0.0 ;
		}
		return value ;
	}

	public static double getIdfVector(List<Double> vector)
	{
		double sum = 0.0;
		//|A| = a_i*a_i + ... + a_n*a_n
		for ( double v : vector)
		{
			sum = sum + getIdf(v) * getIdf(v) ;
		}

		return sum ;
	}

	public static double innerProductWithTfIdf(List<Double> tVector,List<Double> cVector)
	{
		double sum = 0.0;
		for ( double context : cVector)
		{
			if ( tVector.contains(context))
			{
				sum = sum + getIdf(context) * getIdf(context) ;
			}
		}

		//normalize it
		double tSizeNorm = getIdfVector(tVector) ;
		double cSizeNorm = getIdfVector(cVector) ;


		if ( tSizeNorm == 0.0 || cSizeNorm == 0.0)
		{
			return 0.0 ;
		}

	//	return sum ;


		return sum/(Math.sqrt(tSizeNorm) * Math.sqrt(cSizeNorm));
	}

	public static double innerProductWithRankPosition(String target,
			Map<Double, Double> targetRankVector,List<Double> cVector)
	{
		double sum = 0.0;
		for ( double context : cVector)
		{
			if ( targetRankVector.keySet().contains(context))
			{
				Double rank = targetRankVector.get(context) ;
				if( null == rank)
				{
					System.out.println("context not available") ;
					rank = 0.0 ;
				}

				sum = sum + rank.doubleValue()  * rank.doubleValue()  ;
			}
		}

		//normalize it
		double tSizeNorm = 0;//getRankVector(tVector,positionRankMap) ;
		double cSizeNorm = 0;//getRankVector(cVector,positionRankMap) ;


		if ( tSizeNorm == 0.0 || cSizeNorm == 0.0)
		{
			return 0.0 ;
		}

	//	return sum ;


		return sum/(Math.sqrt(tSizeNorm) * Math.sqrt(cSizeNorm));
	}

	public double getRankVector(List<Double> vector, Map<Double,Double> positionRankMap)
	{
		double sum = 0.0;
		//|A| = a_i*a_i + ... + a_n*a_n
		for ( double v : vector)
		{
			Double value = positionRankMap.get(v);
			if ( null == value )
			{
				value = 0.0 ;
			}
			sum = sum + value.doubleValue() * value.doubleValue() ;
		}

		return sum ;
	}


	public static double innerProduct(List<Double> tVector,List<Double> cVector)
	{
		double sum = 0.0;
		for ( double context : cVector)
		{
			if ( tVector.contains(context))
			{
				sum = sum + 1.0 ;
			}
		}

		//normalize it
		double tSize =tVector.size() ;
		double cSize =cVector.size() ;

		if ( tSize == 0.0 || cSize == 0.0)
		{
			return 0.0 ;
		}

	//	return sum ;


		return sum/(Math.sqrt(tSize) * Math.sqrt(cSize));
	}

}