---

AML.java

gehe zur Dokumentation dieser Datei

/*
 * $Source: /shared/cvsroot/diplom/app/src/java/de/picana/clusterer/AML.java,v $
 * $Author: mstolpe $
 * $Date: 2003/04/22 09:51:27 $
 * $Revision: 1.3 $
 * $Release$ 
 *
 * Created on 5. M?rz 2003, 21:50
 *
 * Copyright 2002 by Marco Stolpe
 */

package de.picana.clusterer;

import de.picana.control.*;
import de.picana.logging.*;
import de.picana.math.*;

import java.io.*;
import java.util.*;

import weka.core.*;


public class AML extends GenericML {
    
    private double rho;
    private boolean pruning = true;
 

    public AML() {
    }
    
    
    public void init(ParameterSet params, Logger logger) {
        
        super.init(params, logger);
        
        rho = 0.0;
        try {
            rho = Double.parseDouble((String)params.getParameter("rho"));
        } catch (NumberFormatException nfe) {}   
    }

    
    protected void buildFirst() {
        
        statwriter.println("algo_clusterer_name:AML");
        statwriter.println("algo_clusterer_rho:" + rho);
                
        int i, j;
        MLVector vec, vec_i, vec_j;
        HashMap max_index = new HashMap();
        
        double max_dist = 0.0;
        double dist = 0.0;
        
        for (i=0; i < freq_table.size(); i++) {
            
            vec_i = (MLVector)freq_table.get(i);
               
            for (j=0; j < i; j++) {
        
                vec_j = (MLVector)freq_table.get(j);
        
                dist = Distance.weighted_euklidian(
                       vec_i.value, vec_i.freq, vec_j.value, vec_j.freq,
                       rho, training_set.numInstances());
                
                //dist = Distance.euklidian(vec_i.value, vec_j.value);
                
                if (dist > max_dist) {
                    max_index.clear();
                    max_dist = dist;
            
                    max_index.put(new IntegerPair(i, j), new Integer(1));
                    logger.info(LOGSRC, "Found new maximum distance " + max_dist);
                   
                } else if (dist == max_dist) {
                    max_index.put(new IntegerPair(i, j), new Integer(1));
                }
            }
        }
        
        Iterator keys = max_index.keySet().iterator();
        while (keys.hasNext()) {
            IntegerPair pair = (IntegerPair)keys.next();
            MLVector vec_a = (MLVector)freq_table.get(pair.a);
            MLVector vec_b = (MLVector)freq_table.get(pair.b);
            logger.debug(LOGSRC, "(" + pair.a + ") " + vec_a.toString() + " - " +
                         "(" + pair.b + ") " + vec_b.toString() + " = " + max_dist); 
        }

        IntegerPair pair = (IntegerPair)getRandomElement(max_index.keySet());
        MLVector vec_a = (MLVector)freq_table.get(pair.a);
        MLVector vec_b = (MLVector)freq_table.get(pair.b);
        centroids.add(vec_a);
        logger.info(LOGSRC, "centroid[0] = " + vec_a.toString());
        centroids.add(vec_b);
        logger.info(LOGSRC, "centroid[1] = " + vec_b.toString());
    }
    

    protected void buildRest() {
        
        int i, j, k;
        MLVector vec;
        MLVector vec_a;
        MLVector vec_b;
        List max_index = new ArrayList();
        
        double max_dist;
        double min_dist;
        double act_dist;
                
        for (i=0; i < num_clusters-2; i++) {
        
            max_dist = 0.0;
            max_index.clear();
            
            for (j=0; j < freq_table.size(); j++) {
            
                vec_a = (MLVector)freq_table.get(j);
               
                min_dist = Double.MAX_VALUE;
                
                for (k=0; k < centroids.size(); k++) {
                    
                    vec_b = (MLVector)centroids.get(k);
                    
                    act_dist = Distance.weighted_euklidian(
                       vec_a.value, vec_a.freq, vec_b.value,
                       rho, training_set.numInstances());
                    
                    //act_dist = Distance.euklidian(vec_a.value, vec_b.value);
                    
                    if (act_dist < min_dist)
                        min_dist = act_dist;
                }
                
                if (min_dist > max_dist) {
                    
                    max_index.clear();
                    max_index.add(new Integer(j));
                    max_dist = min_dist;
                    
                } else if (min_dist == max_dist) {

                    max_index.add(new Integer(j));
                }                
            }
            
            Integer index = (Integer)getRandomElement(max_index);
            vec = (MLVector)freq_table.get(index.intValue());
            centroids.add(vec);
            logger.info(LOGSRC, "centroid[" + (i+2) + "] = " + vec.toString());
        }
    }
}

---