multi_ecoc.c

使用具有增量学习的监控式学习方法。包括几个不同的分类算法。

/* Copyright (C) 2001-2002  Mikael Ylikoski
 * See the accompanying file "README" for the full copyright notice */
/**
 * @file
 * Multi class classification using error correcting output codes.
 *
 * This file implements ECOC.
 *
 * @author  Mikael Ylikoski
 * @date    2001-2002
 */

#include <stdlib.h>
#include "multi.h"
#include "multi_ecoc.h"
#include "parray.h"
#include "vector.h"
#include "utility.h"


/**
 * Test code.
 */
static int hd_15_12[620] = {
    0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,
    1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1,
    0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1,
    1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1,
    1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,
    0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1,
    0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1,
    0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,
    1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1,
    0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};


/**
 *
 */
int
multi_ecoc_learn (void *data, vector *v, int class) {
    int i, j, *code;
    void *cd;
    multi_db *db;
    parray *codes;
    vector *u;

    db = (multi_db *)data;
    if (class >= db->size)
	return -1;

    if (db->funcs->option & OPTION_COPY_VECTOR)
	u = vector_copy (v);
    else
	u = v;

    codes = (parray *)db->method_data;
    for (i = 0; i < array_get_size (db->classes); i++) {
	cd = array_get_value (db->classes, i);
	code = (int *)array_get_value (codes, i);
	j = code[class];
	if (j == 1)
	    db->funcs->learn (db->data, cd, u, 1);
	else
	    db->funcs->learn (db->data, cd, u, -1);
    }

    return 0;
}


/**
 *
 */
int
multi_ecoc_unlearn (void *data, vector *v, int class) {
    multi_db *db;
    parray *codes;

    db = (multi_db *)data;
    codes = (parray *)db->method_data;

    return -1;
}

/*
static int
hamming_distance(.., ..) {
    int i;

    return i;
}
*/

/**
 *
 */
int
multi_ecoc_classify_top(void *data, vector *v) {
    int i, j, k, *hd, *code;
    double d;
    void *cd;
    multi_db *db;
    parray *codes;

    db = (multi_db *)data;
    codes = (parray *)db->method_data;
    hd = my_calloc (db->size, sizeof(int));

    /*
    for (i = 0; i < array_get_size(db->classes); i++) {
	cd = array_get_value(db->classes, i);
	d = db->funcs->classify(db->data, cd, v);
	k = d > 0;
	for (j = 0; j < db->size; j++) {
	    code = array_get_value(codes, j);
	    if (code[i] != k)
		hd[j]++;
	}
    }
    */
    for (i = 0; i < array_get_size (db->classes); i++) {
	cd = array_get_value (db->classes, i);
	d = db->funcs->classify (db->data, cd, v);
	k = d > 0;
	code = array_get_value (codes, i);
	for (j = 0; j < db->size; j++)
	    if (code[j] != k)
		hd[j]++;
    }

    j = 0;
    k = hd[0];
    for (i = 1; i < db->size; i++)
	if (hd[i] < k) {
	    j = i;
	    k = hd[i];
	}

    //printf("hd = %d\n", hd[j]);
    return j;
}


double *
multi_ecoc_classify_score (void *data, vector *v) {

    return NULL;
}


int
multi_ecoc_info (void *data) {
    multi_db *db;

    db = (multi_db *)data;
    return db->size;
}


static classifier_functions multi_ecoc_functions = {
    .learn = multi_ecoc_learn,
    .classify_top = multi_ecoc_classify_top,
    .info = multi_ecoc_info
};


/**
 * Create a new classifier database.
 *
 * @param funcs  classifiers functions
 * @param data   classifiers global data
 * @param size   number of classes
 * @return  The new classifier database.
 */
classifier *
multi_ecoc_new (multi_functions *funcs, void *data, int size) {
    int i, j, *ip;
    void *cc;
    multi_db *db;

    db = my_malloc (sizeof(multi_db));
    db->funcs = funcs;
    db->data = data;
    db->size = size;

    j = 12;
    db->classes = parray_new (j);
    for (i = 0; i < j; i++) {
	cc = db->funcs->new ();
	array_set_value (db->classes, i, cc);
    }
    parray_set_size (db->classes, j);
    db->method_data = parray_new (j);
    for (i = 0; i < j; i++) {
	ip = &hd_15_12[i * 15];
	array_set_value ((parray *)db->method_data, i, ip);
    }
    parray_set_size ((parray *)db->method_data, j);

    return classifier_new (db, &multi_ecoc_functions);
}