pifiled.c

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

/* Copyright (C) 2002  Mikael Ylikoski
 * See the accompanying file "README" for the full copyright notice */
/**
 * @file
 * Proxy ifile daemon.
 * Behaves like a Select daemon but uses ifile as a back-end.
 *
 * @author  Mikael Ylikoski
 * @date    2002
 */

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include "dictionary.h"
#include "protocol_s.h"
#include "utility.h"


//static char *adr_str;		/**< Socket address string */
static protocol_s_data *pdata;	/**< Protocol data */
static dict *folders;		/**< Folder -> class table */
//static char *classes;		/**< Class -> folder table */
static int ifile_noc;
//static part *doc_parts;

static char *ifile_command = "ifile";

static char obuf[10000];
static char ibuf[10000];
static int ilen;
static int olen;


static void
rank_from_score (int *rank, double *score, int len) {
    int i, j, pos;
    double val;

    val = 0;
    for (j = 0; j < len; j++) {
	pos = -1;
	for (i = 0; i < len; i++)
	    if (score[i] != 0 && (pos == -1 || val < score[i])) {
		val = score[i];
		pos = i;
	    }
	if (pos == -1)
	    break;
	rank[j] = pos;
	score[pos] = 0;
    }
    rank[j] = -1;
}


static int
run_command (char *command, char *arg1, char *arg2, int get_output) {
    pid_t pid;
    int i, j;
    int inf[2];
    int outf[2];

    i = pipe (inf);
    if (i)
	return -1;
    i = pipe (outf);
    if (i)
	return -1;

    pid = fork ();
    if (pid == 0) {
	i = dup2 (inf[0], STDIN_FILENO);
	if (i != STDIN_FILENO)
	    exit (1);
	i = dup2 (outf[1], STDOUT_FILENO);
	if (i != STDOUT_FILENO)
	    exit (1);

	close (inf[0]);
	close (inf[1]);
	close (outf[0]);
	close (outf[1]);

	//execlp (command, "ifile", "-v", "0", "-k", "-w", arg1, arg2, NULL);
	execlp (command, "ifile", "-a", "qwerty", arg1, arg2, NULL);

	fprintf (stderr, "Error: Cannot exec ifile process!\n");
	exit (1);
    } else if (pid == -1) {
	fprintf (stderr, "Error: Cannot fork ifile process!\n");
	return -1;
    }

    close (inf[0]);
    close (outf[1]);

    if (ilen > 0) {
	for (j = 0; j < ilen; j += i) {	// FIXME this loop shouldn't be needed
	    i = write (inf[1], &ibuf[j], ilen - j);
	    if (i == -1)
		break;
	}
	if (j < ilen)
	    ;
    }
    close (inf[1]);

    if (get_output) {
	for (j = 0; j < 10000; j += i) {
	    i = read (outf[0], obuf, 10000 - j);
	    if (i < 1)
		break;
	}
	if (j < 0)
	    ;
	olen = j;
	obuf[olen] = '\0';
    }
    close (outf[0]);

    waitpid (pid, NULL, 0);

    return 0;
}


static int
setup_folders (void) {
    char buf[50], *ch;
    double d;
    int i, j, k;

    ibuf[0] = ' ';
    ilen = 1;
    run_command (ifile_command, "-q", NULL, 1);

    ch = obuf;
    for (k = 0; 1; k++) {
	ch = strchr (ch, '\n');
	if (!ch)
	    break;
	ch++;
    }
    k--;

    ifile_noc = k;

    folders = dict_new ();

    ch = obuf;
    for (i = 0; i < k; i++) {
	j = sscanf (ch, "%s %lf\n", buf, &d);
	if (j != 2) {
	    return -1;
	}
	dict_insert_word (folders, buf);
	ch = strchr (ch, '\n');
	if (!ch)
	    break;
	ch++;
    }

    return 0;
}


// also sets ifile_noc
static double *
ifile_classify_score (void) {
    char buf[50], *ch;
    double *dl, d;
    int i, j, k;

    run_command (ifile_command, "-q", NULL, 1);

    ch = obuf;
    for (k = 0; 1; k++) {
	ch = strchr (ch, '\n');
	if (!ch)
	    break;
	ch++;
    }
    k--;

    ifile_noc = k;
    dl = my_malloc (sizeof(double) * k);
    ch = obuf;

    for (i = 0; i < k; i++) {
	j = sscanf (ch, "%s %lf\n", buf, &d);
	if (j != 2) {
	    free (dl);
	    printf ("ERROR\n");
	    return NULL;
	}
	//j = dict_insert_word (folders, buf);
	j = atoi (buf);
	dl[j] = d;

	//printf ("%s %d %lf\n", buf, j, d);

	ch = strchr (ch, '\n');
	if (!ch)
	    break;
	ch++;
    }

    return dl;
}


static int *
ifile_classify_rank (void) {
    double *dl;
    int *il;

    dl = ifile_classify_score ();
    il = my_malloc (sizeof(int) * (ifile_noc + 1));
    rank_from_score (il, dl, ifile_noc);
    free (dl);

    return il;
}


static int
ifile_classify_top (void) {
    int *il;
    int i;

    il = ifile_classify_rank ();
    if (ifile_noc > 0)
	i = il[0];
    else
	i = -1;
    free (il);

    return -1;
}


static int
ifile_learn (char *class) {
    run_command (ifile_command, "-i", class, 0);
    return -1;
}


static int
setup_document (part *parts) {
    //doc_parts = ...;

    ilen = 0;

    /*
	if (!strcmp (parts->type, PART_TEXT)) {
	    document_set_text (doc, parts->string);
	    parts->string[parts->len] = '\0';
	} else if (!strcmp (parts->type, PART_RFC822)) {
	    fprintf (stderr, "Warning: Rfc822 parts not implemented!\n");
	} else if (!strcmp (parts->type, PART_FROM)) {
	    document_set_from (doc, parts->string);
	    parts->string[parts->len] = '\0';
	} else if (!strcmp (parts->type, PART_SUBJECT)) {
	    document_set_subject (doc, parts->string);
	    parts->string[parts->len] = '\0';
	} else if (!strcmp (parts->type, PART_HEADER)) {
	    fprintf (stderr, "Warning: Header parts not implemented!\n");
	} else if (!strcmp (parts->type, PART_LANGUAGE)) {
	    document_set_language (doc, parts->string);
	    parts->string[parts->len] = '\0';
	} else {
	    fprintf (stderr, "Warning: Unknown part type: %s\n", parts->type);
	}
    */
    memcpy (ibuf, parts->string, parts->len);
    ilen += parts->len;
    free (parts->type);
    free (parts);

    return 0;
}


static int
do_classify_doc (char *cl, char *typ) {
    int i, *il;
    double *dl;

    /* Find classifier */
    if (cl) {
	if (cl[0] == '"') {
	    if (!strncmp (cl, "\"ifile\"", 7))
		i = 0;
	    else
		i = -1;
	} else
	    i = atoi (cl);
    } else
	i = 0;
    if (i != 0) {
	//protocol_s_error (pdata);
	return -1;
    }

    if (!typ || !strcmp (typ, "s")) {
	dl = ifile_classify_score ();
	if (dl) {
	    protocol_s_classify_score (pdata, dl, ifile_noc);
	    free (dl);
	    return 0;
	}
	protocol_s_classify_score (pdata, NULL, 0);
    } else if (!strcmp (typ, "r")) {
	il = ifile_classify_rank ();
	if (il) {
	    for (i = 0; il[i] != -1; i++)
		;
	    protocol_s_classify_rank (pdata, il, i);
	    free (il);
	    return 0;
	}
	protocol_s_classify_rank (pdata, NULL, 0);
    } else if (!strcmp (typ, "t")) {
	i = ifile_classify_top ();
	protocol_s_classify_top (pdata, i);
    } else {
	fprintf (stderr, "Error: Unknown classification type: %s\n", typ);
	return -1;
    }

    return 0;
}


static int
do_learn (char *class) {
    int i;

    if (class[0] == '"') {
	i = strlen (class);
	class[i - 1] = '\0';
	dict_insert_word (folders, &class[1]);
    }

    ifile_learn (class);

    return 0;
}


/**
 * Write a folder number and name for the client.
 */
static void
write_folder (gpointer key, gpointer value, gpointer null) {
    protocol_s_write_integer (pdata, *(int *)value);
    protocol_s_write_string (pdata, "=");
    protocol_s_write_string (pdata, (char *)key);
    protocol_s_write_string (pdata, ";");
}


static int
do_get (const char *key) {
    if (!strcmp (key, "folders")) {
	// FIXME call ifile
	protocol_s_write_string (pdata, "l:");
	protocol_s_write_integer (pdata, dict_get_size (folders));
	protocol_s_write_string (pdata, ":");
	dict_for_each (folders, write_folder);
    } else if (!strcmp (key, "classifiers")) {
	protocol_s_write_string (pdata, "l:1:0=ifile;");
    } else if (!strcmp (key, "noc")) {
	protocol_s_write_integer (pdata, 1);
    } else if (!strcmp (key, "nof")) {
	// FIXME call ifile
	protocol_s_write_integer (pdata, dict_get_size (folders));
    } else {
	protocol_s_write_string (pdata, "ERR");
    }

    protocol_s_send (pdata);
    return -1;
}


static int
do_set (const char *key, const char *value) {
    protocol_s_write_string (pdata, "Not implmented yet");
    protocol_s_send (pdata);
    return -1;
}


static int
read_request (void) {
    int retval;
    protocol_s_request *pr;

    retval = 0;
    pr = protocol_s_read_request (pdata);
    if (!pr)
	return -1;

    switch (pr->type) {
    case REQUEST_OPEN:
	setup_document (pr->parts);
	break;
    case REQUEST_CLOSE:
	retval = -1;
	break;
    case REQUEST_PARTS:
	setup_document (pr->parts);
	break;
    case REQUEST_CLASSIFY:
	do_classify_doc (pr->str, pr->str2);
	break;
    case REQUEST_LEARN:
	do_learn (pr->str);
	break;
    case REQUEST_UNLEARN:
	// FIXME
	break;
    case REQUEST_GET:
	do_get (pr->str);
	break;
    case REQUEST_SET:
	do_set (pr->str, pr->str2);
	break;
    case REQUEST_X:
	break;
    }

    free (pr);

    return retval;
}


static void
handle_session (int fd) {
    int i;

    protocol_s_reinit (pdata, fd);

    /* Receive and process requests */
    while (1) {
	i = protocol_s_receive (pdata);
	if (i)
	    break;
	i = read_request ();
	if (i)
	    break;
    }
}


/**
 * Main program.
 */
int
main (int argc, char *argv[]) {
    /* Configuration */
    pdata = protocol_s_new (15000, NULL);
    ilen = 0;
    olen = 0;
    ifile_noc = 0;
    setup_folders ();

    protocol_s_loop (pdata, &handle_session);

    return 0;
}