DefaultGapsScores.java
4.54 KB
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
package LIA_topic_seg;
import java.util.*;
/**
* Cette classe permet le calcul de probabililtés de rupture à chaque intervalle entre deux phrases, ou unités textuelles.
* Les calculs implémentés sont la similarité cosine et les profondeurs de dissimilarité.
*
*
*/
public class DefaultGapsScores implements GapsScores{
LexicalChainList chains;
float[] gaps_scores = null;
int sentence_count = 0;
static int SIM_WINDOW = 3;
public DefaultGapsScores (LexicalChainList lcl, int sc){
//création du tableau des probas de rupture pour chaque phrase/séquence
chains = lcl;
sentence_count = sc;
// System.out.print("nombre de phrases traitése : " + sc);
compute_cos();
// for (int i= 0 ; i<sc; i++){
// gaps_scores[i]=0;
// }
}
public DefaultGapsScores (LexicalChainList lcl, DefaultInputData in){
//création du tableau des probas de rupture pour chaque phrase/séquence
chains = lcl;
sentence_count = in.sentenceCount();
compute_cos();
}
/**
* transforme l'attribut gaps_scores en des scores de similarités => on recherchera les plus petits
*
*/
public void compute_cos(){
// transforme gaps_scores en des scores de similarités => on recherchera les + petits
gaps_scores = new float[sentence_count-1];
for (int senti = 0 ; senti< sentence_count-1 ; senti++){
float sup = 0;
float inf1 = 0;
float inf2 = 0;
for (int lem=0 ; lem< chains.lemmaCount() ; lem++){
float wa = 0;
float wb = 0;
for (int sentj = senti ; sentj>senti-SIM_WINDOW && sentj>=0; sentj--){
if (chains.weight(lem,sentj) > wa){
wa = chains.weight(lem,sentj);
}
}
for (int sentk = senti+1 ; sentk<=senti+SIM_WINDOW && sentk<sentence_count ; sentk++){
if (chains.weight(lem,sentk) > wb){
wb = chains.weight(lem,sentk);
}
}
sup += wa * wb;
inf1 += wa * wa;
inf2 += wb * wb;
}
if (inf1 * inf2 != 0){
gaps_scores[senti]= sup / (float)Math.sqrt(inf1 * inf2);
}
else {
gaps_scores[senti]= 0;
}
}
}
/**
* Cette fonction opère un lissage sur l'attribut gaps_scores, pour chaque valeur elle la remplace
* par la moyenne avec les valeurs précédente et suivante.
* @param w : fenêtre de lissage : elle est égale à 1 quoi qu'il arrive
*/
public void compute_smoothing(int w){
//w est la fenêtre de lissage
float[] smooth_cos = new float[gaps_scores.length] ;
smooth_cos[0]= (gaps_scores[1]+2*gaps_scores[0])/3;
for (int i=1 ; i<gaps_scores.length-1 ; i++){
smooth_cos[i]= (gaps_scores[i-1]+gaps_scores[i+1]+2*gaps_scores[i])/4 ;
}
smooth_cos[gaps_scores.length-1]=(gaps_scores[gaps_scores.length-2]+gaps_scores[gaps_scores.length-1])/2;
//System.out.print("dernier calculé" + smooth_cos[gaps_scores.length-1]);
gaps_scores = smooth_cos.clone();
}
/**
* Cette fonction, après calcul des similarités, permet de sélectionner les frontières candidates
* en recherchant les minimas locaux et en leur attribuant des valeurs liées à la profondeur
* de dissimilarité.
* Les résultats sont directement reportés dans l'attribut gaps_scores
* @return : le nombre de candidats pour lesquels une valeur a été calculée.
*/
public float compute_depth_scores(){ // retourne le nombre de depth calculées
//transforme gaps_scores en des scores de profondeur => on recherchera les + grands
int count = 0;
float[] depth_scores = new float [gaps_scores.length];
depth_scores[0]=0;
depth_scores[gaps_scores.length-1]=0;
for (int i=1 ; i<gaps_scores.length-1 ; i++){
if (gaps_scores[i-1]>gaps_scores[i] && gaps_scores[i+1]>gaps_scores[i]){
// on ne calcule les scores que des candidats, c'est à dire les minimas locaux
float lmax = 0;
float rmax = 0;
int j = i-1;
while (gaps_scores[j]>lmax){
lmax = gaps_scores[j];
}
j = i+1;
while (gaps_scores[j]>rmax){
rmax = gaps_scores[j];
}
depth_scores[i]= (rmax + lmax - 2 * gaps_scores[i])/2;
count ++;
}
else{
depth_scores[i]=0;
}
}
gaps_scores = depth_scores.clone();
return count;
}
// private void compute_C99(){
//
//
// }
public float[] values(){
return gaps_scores;
}
public float bound_value(int bound){
return gaps_scores[bound];
}
public String to_string(){
java.io.StringWriter w = new java.io.StringWriter();
w.write(super.toString()+"\n");
for (int i=0 ; i<gaps_scores.length ; i++){
w.write("GAP " + i + " - " + (i+1) + " : " + gaps_scores[i] +"\n");
}
return w.toString();
}
}