+ int num; // number of the client
+ float max;
+ float min;
+ int count;
+ const char *native_score;
+ int scorefield;
+ float a,b; // Rn = a*R + b
+ struct client *client;
+ struct norm_client *next;
+ struct norm_record *records;
+};
+
+const int scorefield_none = -1; // Do not normalize anything, use tf/idf as is
+ // This is the old behavior, and the default
+const int scorefield_internal = -2; // use our tf/idf, but normalize it
+const int scorefield_position = -3; // fake a score based on the position
+
+// A structure for each (sub)record. There is one list for each client
+struct norm_record
+{
+ struct record *record;
+ float score;
+ struct record_cluster *clust;
+ struct norm_record *next;
+};
+
+// Find the norm_client entry for this client, or create one if not there
+struct norm_client *findnorm( struct relevance *rel, struct client* client)
+{
+ struct norm_client *n = rel->norm;
+ struct session_database *sdb;
+ while (n) {
+ if (n->client == client )
+ return n;
+ n = n->next;
+ }
+ n = nmem_malloc(rel->nmem, sizeof(struct norm_client) );
+ if ( rel->norm )
+ n->num = rel->norm->num +1;
+ else
+ n->num = 1;
+ n->count = 0;
+ n->max = 0.0;
+ n->min = 0.0;
+ n->client = client;
+ n->next = rel->norm;
+ rel->norm = n;
+ sdb = client_get_database(client);
+ n->native_score = session_setting_oneval(sdb, PZ_NATIVE_SCORE);
+ n->records = 0;
+ n->scorefield = scorefield_none;
+ yaz_log(YLOG_LOG,"Normalizing: Client %d uses '%s'", n->num, n->native_score );
+ if ( ! n->native_score || ! *n->native_score ) // not specified
+ n->scorefield = scorefield_none;
+ else if ( strcmp(n->native_score,"position") == 0 )
+ n->scorefield = scorefield_position;
+ else if ( strcmp(n->native_score,"internal") == 0 )
+ n->scorefield = scorefield_internal;
+ else
+ { // Get the field index for the score
+ struct session *se = client_get_session(client);
+ n->scorefield = conf_service_metadata_field_id(se->service, n->native_score);
+ }
+ yaz_log(YLOG_LOG,"Normalizing: Client %d uses '%s' = %d",
+ n->num, n->native_score, n->scorefield );
+ return n;
+}
+
+
+// Add a record in the list for that client, for normalizing later
+static void setup_norm_record( struct relevance *rel, struct record_cluster *clust)
+{
+ struct record *record;
+ for (record = clust->records; record; record = record->next)
+ {
+ struct norm_client *norm = findnorm(rel, record->client);
+ struct norm_record *rp;
+ if ( norm->scorefield == scorefield_none)
+ break; // not interested in normalizing this client
+ rp = nmem_malloc(rel->nmem, sizeof(struct norm_record) );
+ norm->count ++;
+ rp->next = norm->records;
+ norm->records = rp;
+ rp->clust = clust;
+ rp->record = record;
+ if ( norm->scorefield == scorefield_position )
+ rp->score = 1.0 / record->position;
+ else if ( norm->scorefield == scorefield_internal )
+ rp->score = clust->relevance_score; // the tf/idf for the whole cluster
+ // TODO - Get them for each record, merge later!
+ else
+ {
+ struct record_metadata *md = record->metadata[norm->scorefield];
+ rp->score = md->data.fnumber;
+ }
+ yaz_log(YLOG_LOG,"Got score for %d/%d : %f ",
+ norm->num, record->position, rp->score );
+ if ( norm->count == 1 )
+ {
+ norm->max = rp->score;
+ norm->min = rp->score;
+ } else {
+ if ( rp->score > norm->max )
+ norm->max = rp->score;
+ if ( rp->score < norm->min && abs(rp->score) < 1e-6 )
+ norm->min = rp->score; // skip zeroes
+ }
+ }
+}
+
+// Calculate the squared sum of residuals, that is the difference from
+// normalized values to the target curve, which is 1/n
+static double squaresum( struct norm_record *rp, double a, double b)
+{
+ double sum = 0.0;
+ for ( ; rp; rp = rp->next )
+ {
+ double target = 1.0 / rp->record->position;
+ double normscore = rp->score * a + b;
+ double diff = target - normscore;
+ sum += diff * diff;
+ }
+ return sum;
+}
+
+// For each client, normalize scores
+static void normalize_scores(struct relevance *rel)
+{
+ const int maxiterations = 100;
+ const double enough = 100.0; // sets the number of decimals we are happy with
+ struct norm_client *norm;
+ for ( norm = rel->norm; norm; norm = norm->next )
+ {
+ yaz_log(YLOG_LOG,"Normalizing client %d: scorefield=%d count=%d",
+ norm->num, norm->scorefield, norm->count);
+ norm->a = 1.0; // default normalizing factors, no change
+ norm->b = 0.0;
+ if ( norm->scorefield != scorefield_none &&
+ norm->scorefield != scorefield_position )
+ { // have something to normalize
+ double range = norm->max - norm->min;
+ int it = 0;
+ double a,b; // params to optimize
+ double as,bs; // step sizes
+ double chi;
+ char dir = 'a';
+ // initial guesses for the parameters
+ if ( range < 1e-6 ) // practically zero
+ range = norm->max;
+ a = 1.0 / range;
+ b = abs(norm->min);
+ as = a / 10;
+ bs = b / 10;
+ chi = squaresum( norm->records, a,b);
+ while (it++ < maxiterations) // safeguard against things not converging
+ {
+ double aplus = squaresum(norm->records, a+as, b);
+ double aminus= squaresum(norm->records, a-as, b);
+ double bplus = squaresum(norm->records, a, b+bs);
+ double bminus= squaresum(norm->records, a, b-bs);
+ if ( aplus < chi && aplus < aminus && aplus < bplus && aplus < bminus)
+ {
+ a = a + as;
+ chi = aplus;
+ yaz_log(YLOG_LOG,"Fitting aplus it=%d: a=%f / %f b=%f / %f chi = %f",
+ it, a, as, b, bs, chi );
+ }
+ else if ( aminus < chi && aminus < aplus && aminus < bplus && aminus < bminus)
+ {
+ a = a - as;
+ chi = aminus;
+ yaz_log(YLOG_LOG,"Fitting aminus it=%d: a=%f / %f b=%f / %f chi = %f",
+ it, a, as, b, bs, chi );
+ }
+ else if ( bplus < chi && bplus < aplus && bplus < aminus && bplus < bminus)
+ {
+ b = b + bs;
+ chi = bplus;
+ yaz_log(YLOG_LOG,"Fitting bplus it=%d: a=%f / %f b=%f / %f chi = %f",
+ it, a, as, b, bs, chi );
+ }
+ else if ( bminus < chi && bminus < aplus && bminus < bplus && bminus < aminus)
+ {
+ b = b - bs;
+ chi = bminus;
+ yaz_log(YLOG_LOG,"Fitting bminus it=%d: a=%f / %f b=%f / %f chi = %f",
+ it, a, as, b, bs, chi );
+ }
+ else
+ {
+ if ( as > bs )
+ {
+ as = as / 2;
+ yaz_log(YLOG_LOG,"Fitting step a it=%d: a=%f / %f b=%f / %f chi = %f",
+ it, a, as, b, bs, chi );
+ }
+ else
+ {
+ bs = bs / 2;
+ yaz_log(YLOG_LOG,"Fitting step b it=%d: a=%f / %f b=%f / %f chi = %f",
+ it, a, as, b, bs, chi );
+ }
+ }
+ norm->a = a;
+ norm->b = b;
+ if ( fabs(as) * enough < fabs(a) &&
+ fabs(bs) * enough < fabs(b) ) {
+ yaz_log(YLOG_LOG,"Fitting done: stopping loop at %d" , it );
+ break; // not changing much any more
+
+ }
+ }
+ yaz_log(YLOG_LOG,"Fitting done: it=%d: a=%f / %f b=%f / %f chi = %f",
+ it-1, a, as, b, bs, chi );
+ yaz_log(YLOG_LOG," a: %f < %f %d",
+ fabs(as)*enough, fabs(a), (fabs(as) * enough < fabs(a)) );
+ yaz_log(YLOG_LOG," b: %f < %f %d",
+ fabs(bs)*enough, fabs(b), (fabs(bs) * enough < fabs(b)) );
+ }
+
+ if ( norm->scorefield != scorefield_none )
+ { // distribute the normalized scores to the records
+ struct norm_record *nr = norm->records;
+ for ( ; nr ; nr = nr->next ) {
+ double r = nr->score;
+ r = norm->a * r + norm -> b;
+ nr->clust->relevance_score = 10000 * r;
+ yaz_log(YLOG_LOG,"Normalized %f * %f + %f = %f",
+ nr->score, norm->a, norm->b, r );
+ // TODO - This keeps overwriting the cluster score in random order!
+ // Need to merge results better
+ }
+
+ }
+
+ } // client loop