Merge branch 'master' of https://github.com/klerisson/prefrec.git

Author: Myllene

pom.xml

@@ -66,6 +66,11 @@
 			<artifactId>cprefminermulti</artifactId>
 			<version>1.0.4</version>
 		</dependency>
+		<dependency>
+			<groupId>org.battelle</groupId>
+			<artifactId>clodhopper-core</artifactId>
+			<version>1.0.0</version>
+		</dependency>
 	</dependencies>
 
 	<build>

prefrec-execution/src/main/java/br/ufu/facom/lsi/prefrec/execution/crossvalidation/CrossValidation.java

@@ -6,7 +6,6 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
-
 import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -62,16 +61,19 @@ public void execute() {
 			Clusterer clusterer = new Clusterer();
 			//clusterer.execute(representer.getPrefMatrixScorer(), new String[]
 			 //{
-			 //"DBSCAN", "euclidian", "0.1", "4" });
+			 //"DBSCAN", "cosine", "1", "4" });
 			//clusterer.execute(representer.getPrefMatrixScorer(),
 			 //new String[] { "MULTIKMEANS" });
 			//clusterer.execute(representer.getPrefMatrixScorer(),
-				//	new String[] { "AFFINITY" });
+			//new String[] { "KMEANSPLUSPLUS" });
+		            clusterer.execute(representer.getPrefMatrixScorer(),
+					new String[] { "AFFINITY" ,String.valueOf(i)});
+			
+	//	clusterer.execute(representer.getPrefMatrixScorer(), new String[]
+		// {
+			// "FUZZY", "4", "1.2" });
+			//clusterer.execute(representer.getPrefMatrixScorer(), new String[]{"XMEANS"});
 
-			clusterer.execute(representer.getPrefMatrixScorer(), new String[]
-			 {
-			 "FUZZY", "4", "1.2" });
-
 			//clusterer.execute(representer.getPrefMatrixScorer(), new String[]{""});
 
 			Agregator agregator = new Agregator(clusterer.getCluster());
@@ -86,7 +88,7 @@ public void execute() {
 			try {
 
 				miner.buildModels(new ArrayList<Double[][]>(agregator
-						.getConcensualMatrixMap().keySet()));
+						.getConcensualMatrixMap().keySet()), itemList);
 			} catch (Exception e1) {
 				e1.printStackTrace();
 			}

prefrec-pref-clusterer/src/main/java/br/ufu/facom/lsi/prefrec/clusterer/Clusterer.java

@@ -3,6 +3,7 @@
 import gov.sandia.cognition.learning.algorithm.clustering.AffinityPropagation;
 import gov.sandia.cognition.math.DivergenceFunction;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.LinkedHashMap;
@@ -15,10 +16,14 @@
 import org.apache.commons.math3.ml.clustering.DBSCANClusterer;
 import org.apache.commons.math3.ml.clustering.DoublePoint;
 import org.apache.commons.math3.ml.clustering.FuzzyKMeansClusterer;
-import org.apache.commons.math3.ml.clustering.KMeansPlusPlusClusterer;
 import org.apache.commons.math3.ml.clustering.MultiKMeansPlusPlusClusterer;
 import org.apache.commons.math3.ml.distance.DistanceMeasure;
+import org.battelle.clodhopper.tuple.ArrayTupleList;
+import org.battelle.clodhopper.tuple.TupleList;
+import org.battelle.clodhopper.xmeans.XMeansClusterer;
+import org.battelle.clodhopper.xmeans.XMeansParams;
 
+import br.ufu.facom.lsi.prefrec.clusterer.apache.KMeansPlusPlusClusterer;
 import br.ufu.facom.lsi.prefrec.clusterer.distance.CosineDistance;
 import br.ufu.facom.lsi.prefrec.clusterer.distance.MyEuclideanDistance;
 import br.ufu.facom.lsi.prefrec.clusterer.distance.MySimilarityDivergence;
@@ -58,7 +63,7 @@ public void execute(PrefMatrixScorer pms, String[] args) {
 						dm);
 
 				List<Cluster<DoublePoint>> clusters = dbscan
-						.cluster(toDoublePointList(pms));
+						.cluster(toDoublePointList(pms, 0));
 				System.out.println(clusters.size());
 				this.cluster = clusterVectorToMatrix(clusters, pms);
 				break;
@@ -68,16 +73,17 @@ public void execute(PrefMatrixScorer pms, String[] args) {
 						Integer.parseInt(args[1]), Double.parseDouble(args[2]));
 
 				List<CentroidCluster<DoublePoint>> clustersFuzzy = fkmc
-						.cluster(toDoublePointList(pms));
+						.cluster(toDoublePointList(pms, 0));
 
 				this.cluster = clusterVectorToMatrix(clustersFuzzy, pms);
 				break;
 
 			case "AFFINITY":
 				AffinityPropagation<DoublePoint> ap = new AffinityPropagation<>();
+				int indx = Integer.parseInt(args[1]);
 				DivergenceFunction<DoublePoint, DoublePoint> df = new MySimilarityDivergence();
 				ap.setDivergence(df);
-				ap.learn(toDoublePointList(pms));
+				ap.learn(toDoublePointList(pms, indx));
 
 				List<gov.sandia.cognition.learning.algorithm.clustering.cluster.CentroidCluster<DoublePoint>> clustersAff = ap
 						.getResult();
@@ -89,35 +95,79 @@ public void execute(PrefMatrixScorer pms, String[] args) {
 			case "KMEANSPLUSPLUS":
 				MyEuclideanDistance distance = new MyEuclideanDistance();
 				KMeansPlusPlusClusterer<DoublePoint> kMeanPlusPlus = new KMeansPlusPlusClusterer<>(
-						12, -1, distance);
+						5, -1, distance);
 				List<CentroidCluster<DoublePoint>> clustersMKmeansPlusPlus = kMeanPlusPlus
-						.cluster(toDoublePointList(pms));
+						.cluster(toDoublePointList(pms, 0));
 				this.cluster = clusterVectorToMatrix(clustersMKmeansPlusPlus,
 						pms);
 				break;
 
 			case "MULTIKMEANS":
-				KMeansPlusPlusClusterer<DoublePoint> kMean = new KMeansPlusPlusClusterer<>(
+				org.apache.commons.math3.ml.clustering.KMeansPlusPlusClusterer<DoublePoint> kMean = new org.apache.commons.math3.ml.clustering.KMeansPlusPlusClusterer<>(
 						12);
-				MultiKMeansPlusPlusClusterer<DoublePoint> mKMeans = new MultiKMeansPlusPlusClusterer<>(
+				MultiKMeansPlusPlusClusterer<DoublePoint> mKMeans = new MultiKMeansPlusPlusClusterer<DoublePoint>(
 						kMean, 200);
 				List<CentroidCluster<DoublePoint>> clustersMKmeans = mKMeans
-						.cluster(toDoublePointList(pms));
+						.cluster(toDoublePointList(pms, 0));
 				this.cluster = clusterVectorToMatrix(clustersMKmeans, pms);
 				break;
 
-			default:
+			case "XMEANS":
+				int tupleLength = pms.getMatrixMap().entrySet().size();
+				Long key = pms.getMatrixMap().keySet().iterator().next();
+				int tupleCount = pms.getMatrixMap().get(key)[0].length;
+				tupleCount = tupleCount * tupleCount;
+				double[] data = new double[tupleLength * tupleCount];
+				int counter = 0;
+				for (Long k : pms.getMatrixMap().keySet()) {
+					Double[][] d = pms.getMatrixMap().get(k);
+					matrixLength = d.length;
+					for (int i = 0; i < matrixLength; i++) {
+						for (int j = 0; j < d[i].length; j++) {
+							if (d[i][j] == null) {
+								data[counter] = 0.0;
+							} else {
+								data[counter] = d[i][j];
+							}
+							counter++;
+						}
+					}
+				}
+
+				TupleList tupleData = new ArrayTupleList(tupleLength,
+						tupleCount, data);
+
+				XMeansParams.Builder builder = new XMeansParams.Builder();
+				XMeansParams params = builder.minClusters(3).maxClusters(10)
+						.build();
+				XMeansClusterer xmeans = new XMeansClusterer(tupleData, params);
+
+				Thread t = new Thread(xmeans);
+				t.start();
+
+				List<org.battelle.clodhopper.Cluster> clusterResult = null;
+				try {
+					// This blocks!
+					clusterResult = xmeans.get();
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+
+				this.cluster = clusterToMatrix(clusterResult, pms);
 
+				break;
+			default:
+				// No cluster
 				Map<Long, List<Map<Long, Double[][]>>> matrix = new LinkedHashMap<>();
 
 				List<Map<Long, Double[][]>> clusterList = new ArrayList<>();
 				for (Long id : pms.getMatrixMap().keySet()) {
-					
+
 					Map<Long, Double[][]> userMatrix = new LinkedHashMap<>();
 					Double[][] matrixDouble = pms.getMatrixMap().get(id);
 					userMatrix.put(id, matrixDouble);
 					clusterList.add(userMatrix);
-					
+
 				}
 				matrix.put(0L, clusterList);
 				this.cluster = matrix;
@@ -129,6 +179,18 @@ public void execute(PrefMatrixScorer pms, String[] args) {
 		}
 	}
 
+	private Map<Long, List<Map<Long, Double[][]>>> clusterToMatrix(
+			List<org.battelle.clodhopper.Cluster> clusterResult,
+			PrefMatrixScorer pms) {
+
+		Map<Long, List<Map<Long, Double[][]>>> matrix = new LinkedHashMap<>();
+
+		// TODO
+
+		return matrix;
+
+	}
+
 	private Map<Long, List<Map<Long, Double[][]>>> clusterAffinityVectorToMatrix(
 			List<gov.sandia.cognition.learning.algorithm.clustering.cluster.CentroidCluster<DoublePoint>> clusters,
 			PrefMatrixScorer pms) {
@@ -145,16 +207,6 @@ private Map<Long, List<Map<Long, Double[][]>>> clusterAffinityVectorToMatrix(
 				Long id = userScoreDoublePoint.get(dp);
 				Double[][] matrixDouble = pms.getMatrixMap().get(id);
 
-				// for(int k = 0; k < matrixDouble.length; k++){
-				// for(int h = 0; h < matrixDouble[k].length; h++){
-
-				// System.out.print(matrixDouble[k][h]);
-				// System.out.print(" ");
-
-				// }
-				// System.out.println();
-				// }
-
 				userMatrix.put(id, matrixDouble);
 				clusterList.add(userMatrix);
 			}
@@ -204,24 +256,36 @@ private <T extends Cluster<DoublePoint>> Map<Long, List<Map<Long, Double[][]>>>
 
 	}
 
-	private List<DoublePoint> toDoublePointList(PrefMatrixScorer pms) {
+	private List<DoublePoint> toDoublePointList(PrefMatrixScorer pms, int indx)
+			throws IOException {
 
 		List<DoublePoint> result = new ArrayList<>();
+		// BufferedWriter bw = new BufferedWriter(new
+		// FileWriter("matrix_round"+indx));
 
 		for (Long key : pms.getMatrixMap().keySet()) {
 			Double[][] d = pms.getMatrixMap().get(key);
 			List<Double> pointList = new ArrayList<>();
+
 			matrixLength = d.length;
+			// int count=0;
+			// Double[] rawRm = new Double[d.length*d.length];
 			for (int i = 0; i < matrixLength; i++) {
-				for (int j = i+1; j < d[i].length; j++) {//teste era j=i+1
+
+				for (int j = i + 1; j < d[i].length; j++) {// teste era j=i+1
 					if (d[i][j] == null) {
 						d[i][j] = 0.0;
 						pointList.add(d[i][j]);
 					} else {
 						pointList.add(d[i][j]);
 					}
+					// rawRm[count] = d[i][j];
+					// bw.write(String.valueOf(rawRm[count]) + ";");
+					// count++;
+
 				}
 			}
+			// bw.write("\n");
 			// Create double point and add to the result list
 			Double[] ds = pointList.toArray(new Double[pointList.size()]);
 			DoublePoint dp = new DoublePoint(ArrayUtils.toPrimitive(ds));
@@ -230,6 +294,8 @@ private List<DoublePoint> toDoublePointList(PrefMatrixScorer pms) {
 			// the matrix score
 			userScoreDoublePoint.put(dp, key);
 		}
+		// bw.flush();
+		// bw.close();
 		return result;
 	}