tuigraph.java

常用机器学习算法,java编写源代码,内含常用分类算法,包括说明文档

	    System.out.println("merging: " + curRef.getString() + ":" + bestAntecedent.getString());
	}
	else {
	    mortClustering.addToClustering(curRef);
	    System.out.println("merging: " + curRef.getString() + ":NULL");
	}
	return mortClustering;
    }
		
    // this is gross to have to do this
    public static List getMentionsFromPairs (List pairs)
    {
	ArrayList mentions = new ArrayList();
	Iterator i = pairs.iterator();
	while (i.hasNext()) {
	    Instance inst = (Instance) i.next();
	    MentionPair pair = (MentionPair)inst.getSource();
	    Mention ant = pair.getAntecedent();
	    Mention ref = pair.getReferent();
	    if ((ant != null) && !mentions.contains(ant))
		mentions.add(ant);
	    if ((ref != null) && !mentions.contains(ref))
		mentions.add(ref);
	}
	return mentions;
    }

    public static void normalizeGraphEdges (MappedGraph graph)
    {
	Set edges = graph.getGraph().getEdgeSet();
	Iterator iter = edges.iterator();
	double highestEdge = 0.0;

	while (iter.hasNext()) {
	    WeightedEdge e = (WeightedEdge)iter.next();
	    double curWeightMag = Math.abs(e.getWeight());
	    if (curWeightMag > highestEdge)
		highestEdge = curWeightMag;
	}
	Iterator i2 = edges.iterator();
	while (i2.hasNext()) {
	    WeightedEdge e = (WeightedEdge)i2.next();
	    //System.out.println("Setting edge: " + (e.getWeight() / highestEdge));
	    e.setWeight ((double)(e.getWeight() / highestEdge));
	}
	
    }

    // go through pairs and if the have the same entity reference
    public static KeyClustering collectAllKeyClusters (List trainingMentionPairs)
    {
	Set allMentions = new LinkedHashSet();
	Iterator all = trainingMentionPairs.iterator();
	while (all.hasNext()) {
	    MentionPair p = (MentionPair)((Instance)all.next()).getSource();
	    Mention ant = p.getAntecedent();
	    Mention ref = p.getReferent();
	    if (ant != null)
		allMentions.add(ant);
	    if (ref != null)
		allMentions.add(ref);
	}
	KeyClustering keyClustering = new KeyClustering();
	Iterator i = trainingMentionPairs.iterator();
	while (i.hasNext()) {
	    Instance inst = (Instance)i.next();
	    MentionPair pair = (MentionPair)inst.getSource();
	    String entId = pair.getEntityReference();
	    Mention referent = pair.getReferent();
	    Mention antecedent = pair.getAntecedent();
	    if (entId != null) {
		if (antecedent != null) {
		    keyClustering.addToClustering(entId, antecedent);
		    allMentions.remove(antecedent);
		}
		if (referent != null) {
		    keyClustering.addToClustering(entId, referent);
		    allMentions.remove(referent);
		}
	    }
	}
	// add back all remaining clusters as singletons
	Iterator rem = allMentions.iterator();
	int singletonIds = 0;
	while (rem.hasNext()) {
	    String sid = new String("s").concat(new Integer(singletonIds).toString());
	    keyClustering.addToClustering(sid, (Mention)rem.next());
	    singletonIds++;
	}

	return keyClustering;
    }

    private static void coalesceNewPair (Set keyClusters, Instance inst)
    {
	
	if (inst.getLabeling().toString().equals("yes")) {
	    MentionPair pair = (MentionPair)inst.getSource();
	    //System.out.println("Current clusters: ");
	    //printClusters(keyClusters);
	    if (!pair.nullPair()) {
		Iterator i = keyClusters.iterator();
		boolean addedToExisting = false;
		while (i.hasNext()) {
		    Set cluster = (Set)i.next();
		    if ((cluster.contains(pair.getAntecedent())) ||
			(cluster.contains(pair.getReferent()))) {
			cluster.add (pair.getReferent());
			cluster.add (pair.getAntecedent());
			addedToExisting = true;
		    }
		}
		if (!addedToExisting) {
		    LinkedHashSet newS = new LinkedHashSet();
		    newS.add(pair.getAntecedent());
		    newS.add(pair.getReferent());
		    keyClusters.add(newS);
		}
	    } else {
		LinkedHashSet newS = new LinkedHashSet();
		MalletPhrase newPh = pair.getReferent().getMalletPhrase();
		newS.add (pair.getReferent());
		Iterator i = keyClusters.iterator();
		while (i.hasNext()) {
		    Set cluster = (Set)i.next();
			System.out.println("Creating " + pair.getReferent() + 
					   " when it already exists in " + cluster);
		}
		keyClusters.add(newS);
	    }
	}
    }

    private static void printClusters (Set clusters)
    {
	System.out.println("[[[");
	Iterator i = clusters.iterator();
	while (i.hasNext()) {
	    Object cl = i.next();
	    if (cl instanceof Set)
		printCluster((Set)cl);
	}
	System.out.println("]]]");
    }
    private static void printCluster (Set cluster)
    {
	System.out.print("(");
	Iterator i = cluster.iterator();
	while (i.hasNext()) {
	    Mention men = (Mention)i.next();
	    men.getMalletPhrase().printPreTerms();
	    System.out.print(" - " + men.getUniqueEntityIndex());
	    System.out.println("++" + men);
	}
	System.out.println(") ");
    }

    private static boolean referentPronoun (Mention referent)
    {
	String refString = referent.getString();
	for (int i=0; i < pronounsSize; i++) {
	    if (((String)pronouns[i]).equals(refString)) {
		return true;
	    }
	}
	return false;
    }

    private static boolean referentNNP (Mention referent)
    {
	MalletPreTerm ph = referent.getMalletPhrase().getHeadPreTerm();
	if ((ph.getPartOfSpeech() != null) && (ph.getPartOfSpeech().equals("NNP")))
	    return true;
	else
	    return false;
    }

    // the VotedPeception would be roughly the same but would pass in a
    // Matrix2 instead of a classifier and just do a dotproduct with feature vector
    // and subtract these to get the egde weight
    // use the rowDotProduct method
    private static void constructEdgesUsingModel (MappedGraph graph, MaxEnt cl, Instance pair)
    {
	MentionPair mentionPair = (MentionPair)pair.getSource(); // this needs to get stored in source
	Mention antecedent = mentionPair.getAntecedent();
	Mention referent =   mentionPair.getReferent();
	double  edgeVal = 0.0;
	//LabelVector labelVec = cl.classify(pair).getLabelVector();

	/*
	// this just uses positive label (always positive if this is a MaxEnt classifier)
	for (int i=0; i < labelVec.singleSize(); i++) {
	    if (labelVec.labelAtLocation(i).toString().equals("yes"))
		edgeVal = labelVec.valueAtLocation(i);
	}
	*/
	/*
	double posVal = 0.0;
	double negVal = 0.0;
	for (int i=0; i < labelVec.singleSize(); i++) {
	    if (labelVec.labelAtLocation(i).toString().equals("yes"))
		posVal = labelVec.valueAtLocation(i);
	    if (labelVec.labelAtLocation(i).toString().equals("no"))
		negVal = labelVec.valueAtLocation(i);
		}
	edgeVal = posVal - negVal;  // this will give us positive and negative values
	*/
	double [] rawParams = cl.getParameters();
	Matrix2 parameters = new Matrix2(rawParams,2,Array.getLength(rawParams)/2);
	edgeVal = (double)parameters.rowDotProduct(0,(FeatureVector)pair.getData())
	    - (double)parameters.rowDotProduct(1,(FeatureVector)pair.getData());
	
	if (mentionPair.nullPair()) {
	    if (referentPronoun (referent)) {
		try {
		    graph.addVertexMap (referent);
		} catch (Exception e) {e.printStackTrace();}
	    }
	}
	//else if ((referentPronoun(referent)) || (referentNNP(referent) && referentNNP(antecedent))) {
	//else if ((referentPronoun(referent))) {
	//else if (false) {
	else if (true) {
	    try {
		//System.out.println("Setting edge " + antecedent + "-" + referent +
		//	       " in graph to " + edgeVal);
		graph.addEdgeMap (antecedent, referent, edgeVal);
	    } catch (Exception e) {e.printStackTrace();}
	} else if (mentionPair.getEntityReference() != null) {
	    try {
		graph.addEdgeMap (antecedent, referent, 100.0);
	    } catch (Exception e) {e.printStackTrace();}
	} else
	    try {
		graph.addEdgeMap (antecedent, referent, -100.0);
	    } catch (Exception e) {e.printStackTrace();}
	
    }

    // construct edges using key labels
    private static void constructEdgesUsingTargets (MappedGraph graph, Instance pair)
    {
	MentionPair mentionPair = (MentionPair)pair.getSource(); // this needs to get stored in source
	//FeatureVector vec = (FeatureVector)pair.getData();
	//Iterator vIterator = graph.getGraph().getVerticesIterator();
	Mention antecedent = mentionPair.getAntecedent();
	Mention referent =   mentionPair.getReferent();
	

	// in this case, simply add the referent to graph with no edges
	if (mentionPair.nullPair()) {
	    try {
		graph.addVertexMap (referent);
	    } catch (Exception e) {e.printStackTrace();}
	    return;
	}

	if (mentionPair.getEntityReference() != null) {
	    try {
		graph.addEdgeMap (antecedent, referent, 1000.0);
	    } catch (Exception e) {e.printStackTrace();}
	}
	
	/*
	else {
	    try {
		graph.addEdgeMap (antecedent, referent, -1000.0);
	    } catch (Exception e) {e.printStackTrace();}
	    } */
    }

}