diff --git a/src/main/java/org/aksw/simba/lemming/metrics/single/edgemanipulation/distribution.java b/src/main/java/org/aksw/simba/lemming/metrics/single/edgemanipulation/distribution.java new file mode 100644 index 00000000..2ddc9802 --- /dev/null +++ b/src/main/java/org/aksw/simba/lemming/metrics/single/edgemanipulation/distribution.java @@ -0,0 +1,28 @@ +package org.aksw.simba.lemming.metrics.single.edgemanipulation; + +import org.aksw.simba.lemming.ColouredGraph; +import org.aksw.simba.lemming.metrics.single.SingleValueMetric; +import org.aksw.simba.lemming.mimicgraph.colourmetrics.utils.PoissonDistribution; +import grph.Grph.DIRECTION; + +public class distribution extends VertexDegrees{ + + + private ColouredGraph graph; + private SingleValueMetric nodeMetric; + private SingleValueMetric edgeMetric; + + EdgeModification edge = new EdgeModification(graph, nodeMetric, edgeMetric); + + public distribution(ColouredGraph graph) { + super(graph); + super.computeVerticesDegree(graph); + } + + public int degree = getVertexDegree(0, DIRECTION.in); + public double mean = 0.2; + public double j = 0.1; + PoissonDistribution pd = new PoissonDistribution(); + public double prob = pd.getProbabilityOf(0, mean); + +} \ No newline at end of file diff --git a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/AbstractGraphGeneration.java b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/AbstractGraphGeneration.java index 7c7cf93c..4df4c36a 100644 --- a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/AbstractGraphGeneration.java +++ b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/AbstractGraphGeneration.java @@ -75,7 +75,7 @@ public abstract class AbstractGraphGeneration extends BasicGraphGenerator { protected IOfferedItem mEdgeColoProposer; private Random mRandom ; - protected long seed; + protected static long seed; protected BitSet mRdfTypePropertyColour; diff --git a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/BiasedGraphGenerator.java b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/BiasedGraphGenerator.java new file mode 100644 index 00000000..bc36f3e8 --- /dev/null +++ b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/BiasedGraphGenerator.java @@ -0,0 +1,328 @@ +package org.aksw.simba.lemming.mimicgraph.generator; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.Set; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; + +import grph.Grph; + +import org.aksw.simba.lemming.ColouredGraph; +import org.aksw.simba.lemming.metrics.dist.ObjectDistribution; +import org.aksw.simba.lemming.mimicgraph.colourmetrics.AvrgInDegreeDistBaseVEColo; +import org.aksw.simba.lemming.mimicgraph.colourmetrics.AvrgOutDegreeDistBaseVEColo; +import org.aksw.simba.lemming.mimicgraph.colourmetrics.TripleColourDistributionMetric; +import org.aksw.simba.lemming.mimicgraph.colourmetrics.utils.IOfferedItem; +import org.aksw.simba.lemming.mimicgraph.colourmetrics.utils.OfferedItemByRandomProb; +import org.aksw.simba.lemming.mimicgraph.colourmetrics.utils.PoissonDistribution; +import org.aksw.simba.lemming.mimicgraph.constraints.TripleBaseSetOfIDs; +import org.aksw.simba.lemming.mimicgraph.constraints.TripleBaseSingleID; +import org.aksw.simba.lemming.util.Constants; +import org.aksw.simba.lemming.util.RandomUtil; +import org.apache.jena.ext.com.google.common.primitives.Doubles; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.carrotsearch.hppc.BitSet; +import com.carrotsearch.hppc.ObjectObjectOpenHashMap; + +import grph.DefaultIntSet; +import it.unimi.dsi.fastutil.ints.IntSet; + +/* + * Graph generation based on the probability of Vertices calculated based on the weights assigned to them. + * The weights which are assigned to the single vertices are generated by the Knuth's Poisson Distribution Algorithm. + * + * @author Abhilash Kandarpa (abhilash@mail.uni-paderborn.de) + * + * */ + +public class BiasedGraphGenerator extends AbstractGraphGeneration implements IGraphGeneration { + + private static final Logger LOGGER = LoggerFactory.getLogger(BiasedGraphGenerator.class); + + private Map>> mTrippleMapOfTailHeadEdgeRates; + private List mLstEVColorMapping; + private Map> mMapEdgeIdsToTripleColours; + + protected ObjectObjectOpenHashMap>> mapPossibleODegreePerOEColo; + protected ObjectObjectOpenHashMap>> mapPossibleIDegreePerIEColo; + + public BiasedGraphGenerator(int iNumberOfVertices, ColouredGraph[] origGrphs, int iNumberOfThreads, long seed) { + super(iNumberOfVertices, origGrphs, iNumberOfThreads, seed); + // TODO Auto-generated constructor stub + LOGGER.warn("Inside the BiasedGraphGenerator Method!!! "); + // Find a class of the head and tail vertices. + // After the classes of the vertices are fixed then compute a statistic from the + // events of the previously existing vertices of the graph. + // Let the statistic be Poisson distribution generated variable from the events + // of the previous vertices. + // Assign the variable value as a weight to the chosen vertex. + mTrippleMapOfTailHeadEdgeRates = new HashMap>>(); + + } + + public ColouredGraph generateGraph(ColouredGraph[] graph){ + if(mNumberOfThreads == 1){ + LOGGER.info("Run graph generation with single thread!"); + generateGraphSingleThread(); + }else{ + LOGGER.info("Run graph generation with "+mNumberOfThreads+ " threads!"); + mNumberOfThreads = 1; + generateGraphSingleThread(); + } + return mMimicGraph; + } + + private static int getPoissonRandom(double mean) { + Random r = new Random(); + double L = Math.exp(-mean); + int k = 0; + double p = 1.0; + do { + p = p * r.nextDouble(); + k++; + } while (p > L); + return k - 1; + } + + // This method generates a random graph. We have to modify this using the + // Poisson Distribution. + private void generateGraphSingleThread() { + Set setVertColo = mMapColourToVertexIDs.keySet(); + + for (BitSet tailColo : setVertColo) { + LOGGER.info("Tail Color : "+ setVertColo); + Map> mapHeadEdgeToGrpTriples = null; + try { + mapHeadEdgeToGrpTriples = mTrippleMapOfTailHeadEdgeRates.get(tailColo); + } + catch(NullPointerException e) { + LOGGER.info("Catching null pointer Exception here at 106 "+mapHeadEdgeToGrpTriples+ ";"+ tailColo ); + //continue; + } + /* + * if (mapHeadEdgeToGrpTriples == null) continue; + */ + + for (BitSet headColo : setVertColo) { + LOGGER.info("Head Color : "+ setVertColo); + if (mapHeadEdgeToGrpTriples.containsKey(headColo)) { + + Map mapEdgeToGrpTriples = mapHeadEdgeToGrpTriples.get(headColo); + + if (mapEdgeToGrpTriples == null) + continue; + + Set setEdgeColours = mapEdgeToGrpTriples.keySet(); + + for (BitSet edgeColo : setEdgeColours) { + TripleBaseSetOfIDs triple = mapEdgeToGrpTriples.get(edgeColo); + + if (triple != null && triple.edgeIDs.size() > 0) { + double noOfEdges = triple.edgeIDs.size(); + + ObjectObjectOpenHashMap> mapTailIdProposers = mapPossibleODegreePerOEColo + .get(edgeColo); + ObjectObjectOpenHashMap> mapHeadIdProposers = mapPossibleIDegreePerIEColo + .get(edgeColo); + + IntSet setOfRandomTailIds = getRandomVerticesWithDegree(triple.tailColour, triple.noOfTails, + mapTailIdProposers); + IntSet setOfRandomHeadIds = getRandomVerticesWithDegree(triple.headColour, triple.noOfHeads, + mapHeadIdProposers); + + if ((setOfRandomHeadIds == null || setOfRandomHeadIds.size() == 0) + || (setOfRandomTailIds == null || setOfRandomTailIds.size() == 0)) { + LOGGER.error("There exists no vertices in " + triple.tailColour + " or " + + triple.headColour + " colour"); + continue; + } + + IOfferedItem tailIdsProposer = mapTailIdProposers.get(triple.tailColour); + IOfferedItem headIdsProposer = mapHeadIdProposers.get(triple.headColour); + + triple.headIDs.addAll(setOfRandomHeadIds); + triple.tailIDs.addAll(setOfRandomTailIds); + + Set setTailIds = new HashSet(); + setTailIds.addAll(setOfRandomTailIds); + Set setHeadIds = new HashSet(); + setHeadIds.addAll(setOfRandomHeadIds); + + /* + * Till this point we have the list of all HeadIDs in setHeadIds and all TailIDs + * in setTailIds. We have to find out the mean of the all the degrees of head + * and tail IDs and run those through the Poisson Distribution function in order + * to generate a random number that we can assign as a weight to a single + * vertex. Repeat the process until there are no single vertices left in + * triple.headIds or triple.tailIds. Then using the weights calculate the + * probability of each vertex to be chosen for sampling. + */ + ColouredGraph graph = new ColouredGraph(); + double hmean = 0.0, tmean = 0.0; + int hcount = 0, tcount = 0; + HashMap setHeadSingles = new HashMap(); + HashMap setTailSingles = new HashMap(); + Iterator hitr = setHeadIds.iterator(); + Iterator titr = setTailIds.iterator(); + while (hitr.hasNext() || titr.hasNext()) { + if (hitr.hasNext()) { + if (graph.getGraph().getOutEdgeDegree(hitr.next()) > 0) { + hmean = hmean + graph.getGraph().getOutEdgeDegree(hitr.next()); + hcount++; + } else { + setHeadSingles.put(hitr.next(), null); + } + } + if (titr.hasNext()) { + if (graph.getGraph().getInEdgeDegree(titr.next()) > 0) { + tmean = tmean + graph.getGraph().getInEdgeDegree(titr.next()); + tcount++; + } else { + setTailSingles.put(titr.next(), null); + } + } + } + hmean = hmean / hcount; + tmean = tmean / tcount; + assignWeights(hmean, tmean, setHeadSingles, setTailSingles); + /* + * standardize the amount of edges and vertices this makes sure there is no pair + * of vertices are connected by 2 edges in same colour + */ + /* + * if(setHeadIds.size() * setTailIds.size() < noOfEdges){ + * LOGGER.warn("Not generate " + (noOfEdges - (setHeadIds.size() * + * setTailIds.size())) + " edges in "+ edgeColo ); noOfEdges = setHeadIds.size() + * * setTailIds.size(); } + * + * int headId = -1; int i = 0 ; while(i < noOfEdges){ + * + * setOfRandomHeadIds = new DefaultIntSet(triple.headIDs.size()); + * setOfRandomHeadIds.addAll(triple.headIDs); + * + * // select a random tail int tailId = + * tailIdsProposer.getPotentialItem(setTailIds); + * + * int[] arrConnectedHeads = getConnectedHeads(tailId, edgeColo).toIntArray(); + * for(int connectedHead: arrConnectedHeads){ + * if(setOfRandomHeadIds.contains(connectedHead)) + * setOfRandomHeadIds.remove(connectedHead); } + * + * if(setOfRandomHeadIds.size() == 0 ){ + * LOGGER.warn("No heads any more! Consider another tail"); continue; } + * Set setFilteredHeadIDs = new HashSet(setOfRandomHeadIds); + * + * headId = headIdsProposer.getPotentialItem(setFilteredHeadIDs); + * + * if(connectableVertices(tailId, headId, triple.edgeColour)){ + * mMimicGraph.addEdge(tailId, headId, edgeColo); i++; } + * + * }// end while + */ + } + } + } + } + } + } + + private void assignWeights(Double hmean, Double tmean, HashMap setHeadSingles, + HashMap setTailSingles) { + + int total_weight = 0; + + LOGGER.info("Head mean : "+ hmean+ "Tail mean : "+ tmean); + for (int id : setHeadSingles.keySet()) { + int weight = getPoissonRandom(hmean); + setHeadSingles.replace(id, weight); + total_weight = total_weight + weight; + LOGGER.info("Head vertices and their weights : "+ setHeadSingles.get(id)+ ";"+ setHeadSingles.get(weight)); + } + getProbability(setHeadSingles, total_weight); + total_weight = 0; + + for (int id : setTailSingles.keySet()) { + int weight = getPoissonRandom(tmean); + setTailSingles.replace(id, weight); + total_weight = total_weight + weight; + LOGGER.info("Tail vertices and their weights : "+ setTailSingles.get(id)+ ";"+ setTailSingles.get(weight)); + } + getProbability(setTailSingles, total_weight); + } + + private void getProbability(HashMap setSingles, int weight) { + + HashMap VertexList = new HashMap(); + + for (int id : setSingles.keySet()) { + double probability = (setSingles.get(id) / weight); + VertexList.put(id, probability); + } + } + + private IntSet getRandomVerticesWithDegree(BitSet vertColo, double iNoOfVertices, + ObjectObjectOpenHashMap> mapVertexIdsProposers) { + IntSet setVertices = new DefaultIntSet(mMapColourToVertexIDs.get(vertColo).size()); + setVertices.addAll(mMapColourToVertexIDs.get(vertColo)); + + // invalid setVertices + if (setVertices == null || setVertices.size() == 0) + return null; + + Set tmpSetOfVertices = new HashSet(setVertices); + IOfferedItem vertexIdsProposer = mapVertexIdsProposers.get(vertColo); + + if (vertexIdsProposer != null) { + int[] arrVertices = setVertices.toIntArray(); + IntSet res = new DefaultIntSet(Constants.DEFAULT_SIZE); + + if (iNoOfVertices >= arrVertices.length) { + iNoOfVertices = arrVertices.length; + return setVertices; + } + + while (iNoOfVertices > 0) { + int vertId = vertexIdsProposer.getPotentialItem(tmpSetOfVertices); + if (!res.contains(vertId) && !mReversedMapClassVertices.containsKey(vertId)) { + res.add(vertId); + iNoOfVertices--; + tmpSetOfVertices.remove(vertId); + } + + if (tmpSetOfVertices.size() == 0) { + LOGGER.warn("Could not found more " + iNoOfVertices + " vertices of " + vertColo); + break; + } + + boolean havingMore = false; + Iterator iter = tmpSetOfVertices.iterator(); + while (iter.hasNext()) { + int availableId = iter.next(); + if (!mReversedMapClassVertices.containsKey(availableId) && !res.contains(availableId)) { + havingMore = true; + break; + } + } + + if (!havingMore) { + LOGGER.warn("Could not get " + iNoOfVertices + " vertices of " + vertColo); + break; + } + } + + return res; + } + return null; + } + +} diff --git a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationClusteringBased2.java b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationClusteringBased2.java index fbeba8ab..c22ab951 100644 --- a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationClusteringBased2.java +++ b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationClusteringBased2.java @@ -1,17 +1,24 @@ package org.aksw.simba.lemming.mimicgraph.generator; import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; +import java.util.LinkedHashMap; import java.util.List; +import java.util.ListIterator; import java.util.Map; +import java.util.Properties; import java.util.Random; import java.util.Set; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; +import java.util.stream.Stream; import org.aksw.simba.lemming.ColouredGraph; import org.aksw.simba.lemming.metrics.dist.ObjectDistribution; @@ -31,18 +38,19 @@ import com.carrotsearch.hppc.BitSet; import com.carrotsearch.hppc.ObjectObjectOpenHashMap; +import com.google.common.collect.Multiset.Entry; import grph.DefaultIntSet; import it.unimi.dsi.fastutil.ints.IntSet; public class GraphGenerationClusteringBased2 extends AbstractGraphGeneration implements IGraphGeneration{ - private static final Logger LOGGER = LoggerFactory.getLogger(GraphGenerationClusteringBased2.class); + protected static final Logger LOGGER = LoggerFactory.getLogger(GraphGenerationClusteringBased2.class); - private Map>> mTrippleMapOfTailHeadEdgeRates; - private List mLstEVColorMapping; - private Map> mMapEdgeIdsToTripleColours; -// private long seed; + protected Map>> mTrippleMapOfTailHeadEdgeRates; + protected List mLstEVColorMapping; + protected Map> mMapEdgeIdsToTripleColours; +// protected long seed; /* * the key1: the out-edge's colors, the key2: the vertex's colors and the value is the map of potential degree @@ -56,7 +64,10 @@ public class GraphGenerationClusteringBased2 extends AbstractGraphGeneration imp */ protected ObjectObjectOpenHashMap>> mapPossibleIDegreePerIEColo; - public GraphGenerationClusteringBased2(int iNumberOfVertices, ColouredGraph[] origGrphs, int iNumberOfThreads, long seed) { + Set edges = null; + ColouredGraph[] origGrph = null; + protected ArrayList probabilitiesList = new ArrayList(); + public GraphGenerationClusteringBased2(int iNumberOfVertices, ColouredGraph[] origGrphs, int iNumberOfThreads, long seed, boolean isPoissonFlow) { super(iNumberOfVertices, origGrphs, iNumberOfThreads, seed); mTrippleMapOfTailHeadEdgeRates = new HashMap>>(); @@ -82,8 +93,11 @@ public GraphGenerationClusteringBased2(int iNumberOfVertices, ColouredGraph[] or //assign specific number of vertices to each grouped triple computeNoOfVerticesInTriples(); + + origGrph = origGrphs; } + public ColouredGraph generateGraph(){ if(mNumberOfThreads == 1){ LOGGER.info("Run graph generation with single thread!"); @@ -100,7 +114,7 @@ public ColouredGraph generateGraph(){ return mMimicGraph; } - private void testInfo(){ + protected void testInfo(){ Set setVertColo = mMapColourToVertexIDs.keySet(); for(BitSet tailColo: setVertColo){ @@ -130,8 +144,7 @@ private void testInfo(){ continue; } - System.out.println("[T:"+tailColo+"]="+triple.tailIDs.size()+ - " [E:"+edgeColo+"]="+triple.edgeIDs.size()+ " [H:"+headColo+"]="+triple.headIDs.size()); + System.out.println("[T:"+tailColo+"]="+triple.tailIDs.size()+" [E:"+edgeColo+"]="+triple.edgeIDs.size()+" [H:"+headColo+"]="+triple.headIDs.size()); } } } @@ -143,7 +156,7 @@ private void testInfo(){ /** * assign vertices to triples */ - private void assignVerticesToTriples(){ + protected void assignVerticesToTriples(){ Set setVertColo = mMapColourToVertexIDs.keySet(); for(BitSet tailColo: setVertColo){ @@ -166,6 +179,8 @@ private void assignVerticesToTriples(){ Set setEdgeColours = mapEdgeToGrpTriples.keySet(); + edges = setEdgeColours; + for(BitSet edgeColo: setEdgeColours){ if(!mapEdgeToGrpTriples.containsKey(edgeColo)){ @@ -209,7 +224,7 @@ private void assignVerticesToTriples(){ } } - private void generateGraphMultiThreads(){ + protected void generateGraphMultiThreads(){ //exploit all possible threads int iNumberOfThreads = mNumberOfThreads; //int iNumberOfThreads = 4; @@ -221,7 +236,6 @@ private void generateGraphMultiThreads(){ for(int i = 0 ; i < lstAssignedEdges.size() ; i++){ final IntSet setOfEdges = lstAssignedEdges.get(i); - Runnable worker = new Runnable() { @Override public void run() { @@ -296,6 +310,8 @@ public void run() { BitSet checkedColo = tripleColours.get(1); BitSet headColo = tripleColours.get(2); + //System.out.println("Here at 318 printing the values of tailColo : "+tailColo+" and headColo : "+headColo); + if(checkedColo.equals(edgeColo)){ Map> mapHeadEdgeTriples = mTrippleMapOfTailHeadEdgeRates.get(tailColo); @@ -325,6 +341,28 @@ public void run() { IOfferedItem tailIdsProposer = mapTailIdProposers.get(tailColo); IOfferedItem headIdsProposer = mapHeadIdProposers.get(headColo); + List> verticesList = new ArrayList>(); + for(BitSet edge : edges) { + //System.out.println("Printing the size of Edge color : "+edge.size()+" ; and the set : "+edge+" ; and the whole list : "+edges); + verticesList = PoissonFlow(triples, edge, origGrph); + for(ArrayList vertices : verticesList) { + int headId = vertices.get(0); + int tailId = vertices.get(1); + //System.out.println("Printing at 387 the vertices."+ tailId +" ; "+ headId +" ; "+ edge); + + boolean isFoundVerticesConnected = connectIfPossible(tailId, headId, edge); + if(isFoundVerticesConnected){ + System.out.println("Printing at 389 as the vertices are connected."+ tailId +" ; "+ headId +" ; "+ edge); + j++; + continue; + } + else { + System.out.println("Printing at 394 as the vertices are not connected."+ tailId +" ; "+ headId +" ; "+ edge); + } + } + } + + // select a random tail int tailId = -1; int iAttemptToGetTailIds = 1000; @@ -358,13 +396,11 @@ public void run() { } Set setHeadIds = new HashSet(setHeadIDs); + + //System.out.println("Printing the value at 362 : "+ setHeadIDs.size() +";"+ setTailIds.size()); + int headId = headIdsProposer.getPotentialItem(setHeadIds); - boolean isFoundVerticesConnected = connectIfPossible(tailId, headId, edgeColo); - if(isFoundVerticesConnected){ - j++; - continue; - } }else{ LOGGER.error("Not match edge colour: " + checkedColo + " and "+ edgeColo); @@ -395,7 +431,7 @@ public void run() { }; } - private void generateGraphSingleThread(){ + protected void generateGraphSingleThread(){ Set setVertColo = mMapColourToVertexIDs.keySet(); @@ -450,19 +486,30 @@ private void generateGraphSingleThread(){ * this makes sure there is no pair of vertices are connected by * 2 edges in same colour */ + + if(setHeadIds.size() * setTailIds.size() < noOfEdges){ - LOGGER.warn("Not generate " + (noOfEdges - (setHeadIds.size() * setTailIds.size())) + " edges in "+ edgeColo ); + LOGGER.warn("Not generate " + (noOfEdges - (setHeadIds.size() * setTailIds.size())) + " edges in "+ edgeColo+" at 462."); noOfEdges = setHeadIds.size() * setTailIds.size(); } int headId = -1; int i = 0 ; while(i < noOfEdges){ + + /* + * ArrayList vertices = new ArrayList(); for(int j=0; + * j setFilteredHeadIDs = new HashSet(setOfRandomHeadIds); + LOGGER.info("Printing the value of setFilteredHeadIDs at 491 : "+ setFilteredHeadIDs); + headId = headIdsProposer.getPotentialItem(setFilteredHeadIDs); + + /* + * headId = vertices.get(0); tailId = vertices.get(1); + */ if(connectableVertices(tailId, headId, triple.edgeColour)){ mMimicGraph.addEdge(tailId, headId, edgeColo); + //System.out.println("Printing at 523 as the vertices are connected."); i++; } }// end while @@ -491,7 +545,51 @@ private void generateGraphSingleThread(){ } } - private IntSet getRandomVertices(BitSet vertColo, double iNoOfVertices){ + protected List> PoissonFlow(TripleBaseSetOfIDs triples, BitSet edge, ColouredGraph[] origGrph) { + // TODO Auto-generated method stub + /* + * int hcount = 0, tcount = 0; setHeadSingles = new HashMap(); + * setTailSingles = new HashMap(); Iterator hitr = + * setHeadIds.iterator(); Iterator titr = setTailIds.iterator(); + * //System.out.println("In here at 516 : "+setHeadIds.size()+ ";" + + * setTailIds.size()); while (hitr.hasNext()) { if + * (origGrph2.getGraph().getOutEdgeDegree(hitr.next()) > 0) { + * //System.out.println("In here at 550 : "+origGrph2.getGraph().getOutEdgeDegree( + * hitr.next())); hmean = hmean + + * origGrph2.getGraph().getOutEdgeDegree(hitr.next()); hcount++; } else { + * setHeadSingles.put(hitr.next(), null); } } while (titr.hasNext()) { if + * (origGrph2.getGraph().getInEdgeDegree(titr.next()) > 0) { + * //System.out.println("In here at 559 : "+origGrph2.length.getInEdgeDegree(titr. + * next())); tmean = tmean + origGrph2.getGraph().getInEdgeDegree(titr.next()); + * tcount++; } else { setTailSingles.put(titr.next(), null); } } hmean = hmean / + * hcount; tmean = tmean / tcount; + */ + AvrgOutDegreeDistBaseVEColo avrgOutDegreeAnalyzer = new AvrgOutDegreeDistBaseVEColo(origGrph); + + AvrgInDegreeDistBaseVEColo avrgInDegreeAnalyzer = new AvrgInDegreeDistBaseVEColo(origGrph); + + Set setTailColours = mColourMapper.getTailColoursFromEdgeColour(edge); + Set setHeadColours = mColourMapper.getTailColoursFromEdgeColour(edge); + //System.out.println("Printing the values of setTailColours and setHeadColours sizes : "+setTailColours.size()+" ; "+setHeadColours.size()); + List> verticesList = new ArrayList>(); + for(int i=0; i setTailIds = new HashSet(); + setTailIds.addAll(triples.tailIDs); + Set setHeadIds = new HashSet(); + setHeadIds.addAll(triples.headIDs); + ArrayList vertices = new ArrayList(); + //System.out.println("Printing the vertices here at 570 "+setHeadIds.size()+" ; "+setTailIds.size()); + vertices = assignWeights(avrgInDegree, avrgOutDegree, setHeadIds, setTailIds); + //System.out.println("Printing the vertices here at 570 "+ vertices+" ; "+setHeadIds.size()+" ; "+setTailIds.size()); + verticesList.add(vertices); + } + + return verticesList; + } + + protected IntSet getRandomVertices(BitSet vertColo, double iNoOfVertices){ IntSet setVertices = mMapColourToVertexIDs.get(vertColo); if(setVertices != null){ @@ -538,7 +636,7 @@ private IntSet getRandomVertices(BitSet vertColo, double iNoOfVertices){ return null; } - private IntSet getRandomVerticesWithDegree(BitSet vertColo, double iNoOfVertices, ObjectObjectOpenHashMap> mapVertexIdsProposers){ + protected IntSet getRandomVerticesWithDegree(BitSet vertColo, double iNoOfVertices, ObjectObjectOpenHashMap> mapVertexIdsProposers){ IntSet setVertices = new DefaultIntSet(mMapColourToVertexIDs.get(vertColo).size()); setVertices.addAll(mMapColourToVertexIDs.get(vertColo)); @@ -560,6 +658,9 @@ private IntSet getRandomVerticesWithDegree(BitSet vertColo, double iNoOfVertices } while(iNoOfVertices > 0){ + + LOGGER.info("Printing the value of tmpSetOfVertices at 610 : "+ tmpSetOfVertices); + int vertId = vertexIdsProposer.getPotentialItem(tmpSetOfVertices); if(!res.contains(vertId) && !mReversedMapClassVertices.containsKey(vertId)){ res.add(vertId); @@ -595,7 +696,7 @@ private IntSet getRandomVerticesWithDegree(BitSet vertColo, double iNoOfVertices return null; } - private void computeEVColoDist(ColouredGraph[] origGrphs){ + protected void computeEVColoDist(ColouredGraph[] origGrphs){ for(ColouredGraph grph: origGrphs){ TripleColourDistributionMetric colorMapping = new TripleColourDistributionMetric(); colorMapping.applyWithSingleThread(grph); @@ -603,7 +704,7 @@ private void computeEVColoDist(ColouredGraph[] origGrphs){ } } - private void computeAverageEVColoDistribution(){ + protected void computeAverageEVColoDistribution(){ Set setVertColours = mMapColourToVertexIDs.keySet(); Set setEdgeColours = mMapColourToEdgeIDs.keySet(); @@ -660,7 +761,7 @@ private void computeAverageEVColoDistribution(){ } } - private void putToMap(BitSet firstKey, BitSet secondKey, BitSet thirdKey, TripleBaseSetOfIDs val, + protected void putToMap(BitSet firstKey, BitSet secondKey, BitSet thirdKey, TripleBaseSetOfIDs val, Map>> changedMap){ if(changedMap == null){ changedMap = new HashMap>>(); @@ -688,7 +789,7 @@ private void putToMap(BitSet firstKey, BitSet secondKey, BitSet thirdKey, Triple } } - private void computeNoOfEdgesInTriples() { + protected void computeNoOfEdgesInTriples() { Set setEdgeColo = mMapColourToEdgeIDs.keySet(); Set setVertColo = mMapColourToVertexIDs.keySet(); @@ -756,7 +857,7 @@ private void computeNoOfEdgesInTriples() { LOGGER.info("Done assing edges to grouped triples"); } - private void computeNoOfVerticesInTriples(){ + protected void computeNoOfVerticesInTriples(){ Set setVertColours = mMapColourToVertexIDs.keySet(); Set setEdgeColours = mMapColourToEdgeIDs.keySet(); @@ -812,7 +913,7 @@ private void computeNoOfVerticesInTriples(){ } } - private void computePotentialIODegreePerVert(ColouredGraph[] origGrphs){ + protected void computePotentialIODegreePerVert(ColouredGraph[] origGrphs){ // compute for each vertex's colour, the average in-degree associated with a specific edge's colour AvrgOutDegreeDistBaseVEColo avrgOutDegreeAnalyzer = new AvrgOutDegreeDistBaseVEColo(origGrphs); @@ -836,7 +937,6 @@ private void computePotentialIODegreePerVert(ColouredGraph[] origGrphs){ seed++; double avrgOutDegree = avrgOutDegreeAnalyzer.getAvarageOutDegreeOf(tailColo, edgeColo); - // get list tailIDs int[] arrTailIDs = mMapColourToVertexIDs.get(tailColo).toIntArray(); double[] possOutDegreePerTailIDs = new double[arrTailIDs.length]; @@ -883,7 +983,6 @@ private void computePotentialIODegreePerVert(ColouredGraph[] origGrphs){ seed++; double avrgInDegree = avrgInDegreeAnalyzer.getAvarageInDegreeOf(edgeColo, headColo); - int [] arrHeadIDs = mMapColourToVertexIDs.get(headColo).toIntArray(); double[] possInDegreePerHeadDs = new double[arrHeadIDs.length]; @@ -918,6 +1017,98 @@ private void computePotentialIODegreePerVert(ColouredGraph[] origGrphs){ } } + protected ArrayList assignWeights(Double hmean, Double tmean, Set setHeadIDs, Set setTailIDs) { + + int total_weight = 0; + HashMap setHeadSingles = new HashMap(); + HashMap setTailSingles = new HashMap(); + //System.out.println("Head mean : "+ hmean+ " ; Tail mean : "+ tmean); + for (int id : setHeadIDs) { + //System.out.println("In the for loop here @ 1027."); + int weight = getPoissonRandom(hmean); + setHeadSingles.put(id, weight); + total_weight = total_weight + weight; + //System.out.println("Head vertices and their weights : "+ id+ ";"+ weight); + } + + int HeadVertex = getProbability(setHeadSingles, total_weight); + + total_weight = 0; + for (int id1 : setTailIDs) { + //System.out.println("In here at 1018 testing"); + int weight1 = getPoissonRandom(tmean); + setTailSingles.put(id1, weight1); + total_weight = total_weight + weight1; + //System.out.println("Tail vertices and their weights : "+ id1+ ";"+ weight1); + } + int TailVertex = getProbability(setTailSingles, total_weight); + + ArrayList VerticesList = new ArrayList(); + if(HeadVertex!=-1 && TailVertex!=-1) { + VerticesList.add(HeadVertex); + VerticesList.add(TailVertex); + } + + return VerticesList; + } + + protected int getProbability(HashMap setSingles, int weight) { + + HashMap VertexList = new HashMap(); + + for (int id : setSingles.keySet()) { + double probability = ((double)setSingles.get(id) / (double)weight); + VertexList.put(id, probability); + } + //System.out.println("Vertices and their probabilities: " + VertexList); + + /* + * Stream> sorted = + * VertexList.entrySet().stream().sorted(Collections.reverseOrder(HashMap.Entry. + * comparingByValue())).limit(1); Map VerList = + * sorted.collect(Collectors.toMap(HashMap.Entry::getKey,HashMap.Entry::getValue + * )); for(Object i : VerList.keySet()) { int id = (Integer) i; double + * probability = (Double) VerList.get(i); VertexList.clear(); VertexList.put(id, + * probability); //System.out.println("Vertices : " + VertexList.keySet()+ + * "; and their probabilities : "+ VertexList.values()); return VertexList; } + */ + + //Implementing Roulette wheel selection. + Random rand = new Random(); //instance of random class + double double_random=rand.nextDouble(); + ArrayList vertList = new ArrayList(); + double start = 0.0, end = 0.0; + for(int id : VertexList.keySet()) { + ArrayList l = new ArrayList<>(); + start = end; + end = start+VertexList.get(id); + l.add(id); + l.add(start); + l.add(end); + vertList.add(l); + } + int id = -1; + for(List v : vertList){ + if(double_random >= (double)v.get(1) && double_random < (double)v.get(2)){ + //System.out.println("Printing the id here : "+ v.get(0)); + id = (int) v.get(0); + } + } + return id; + } + + protected static int getPoissonRandom(double mean) { + Random r = new Random(); + double L = Math.exp(-mean); + int k = 0; + double p = 1.0; + do { + p = p * r.nextDouble(); + k++; + } while (p > L); + ////System.out.println("In 1085 printing the value of k-1 : "+(k-1)); + return k - 1; + } @Override public TripleBaseSingleID getProposedTriple(boolean isRandom){ int maxIterationFor1EdgeColo = Constants.MAX_ITERATION_FOR_1_COLOUR; @@ -987,39 +1178,49 @@ public TripleBaseSingleID getProposedTriple(boolean isRandom){ } Set setTmpTails = new HashSet(offeredGrpTriple.tailIDs); - int tId = tailIdsProposer.getPotentialItem(setTmpTails); - int[] arrConnectedHeads = getConnectedHeads(tId, offeredGrpTriple.edgeColour).toIntArray(); - - IntSet setAvailableHeads = new DefaultIntSet(offeredGrpTriple.headIDs.size()); - setAvailableHeads.addAll(offeredGrpTriple.headIDs); + //LOGGER.info("Printing the value of setTmpTails at 1085 : "+ setTmpTails); + + if(tailIdsProposer.getPotentialItem(setTmpTails) != null) { + + int tId = tailIdsProposer.getPotentialItem(setTmpTails); - for(int connectedHead : arrConnectedHeads){ - if(setAvailableHeads.contains(connectedHead)){ - setAvailableHeads.remove(connectedHead); + int[] arrConnectedHeads = getConnectedHeads(tId, offeredGrpTriple.edgeColour).toIntArray(); + + IntSet setAvailableHeads = new DefaultIntSet(offeredGrpTriple.headIDs.size()); + setAvailableHeads.addAll(offeredGrpTriple.headIDs); + + for(int connectedHead : arrConnectedHeads){ + if(setAvailableHeads.contains(connectedHead)){ + setAvailableHeads.remove(connectedHead); + } + } + + if(setAvailableHeads.size() == 0){ + continue; + } + + Set setTmpHeads = new HashSet(setAvailableHeads); + + //LOGGER.info("Printing the value of setTmpHeads at 1106 : "+ setTmpHeads); + + if(headIdsProposer.getPotentialItem(setTmpHeads) != null) { + int hId = headIdsProposer.getPotentialItem(setTmpHeads); + + TripleBaseSingleID singleTriple = new TripleBaseSingleID(); + singleTriple.edgeColour = offeredGrpTriple.edgeColour; + //head + singleTriple.headId = hId; + singleTriple.headColour = offeredGrpTriple.headColour; + + //tail + singleTriple.tailId = tId; + singleTriple.tailColour = offeredGrpTriple.tailColour; + + maxIterationFor1EdgeColo = Constants.MAX_ITERATION_FOR_1_COLOUR; + return singleTriple; } } - - if(setAvailableHeads.size() == 0){ - continue; - } - - Set setTmpHeads = new HashSet(setAvailableHeads); - int hId = headIdsProposer.getPotentialItem(setTmpHeads); - - - TripleBaseSingleID singleTriple = new TripleBaseSingleID(); - singleTriple.edgeColour = offeredGrpTriple.edgeColour; - //head - singleTriple.headId = hId; - singleTriple.headColour = offeredGrpTriple.headColour; - - //tail - singleTriple.tailId = tId; - singleTriple.tailColour = offeredGrpTriple.tailColour; - - maxIterationFor1EdgeColo = Constants.MAX_ITERATION_FOR_1_COLOUR; - return singleTriple; } maxIterationFor1EdgeColo --; } diff --git a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationRandomly.java b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationRandomly.java index b04fa2de..1e541c41 100644 --- a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationRandomly.java +++ b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationRandomly.java @@ -332,5 +332,5 @@ private void generateGraphSingleThread(){ maxIterationFor1EdgeColo = Constants.MAX_ITERATION_FOR_1_COLOUR; } } - + } diff --git a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationRandomly2.java b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationRandomly2.java index 007d3d3e..00a0b789 100644 --- a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationRandomly2.java +++ b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationRandomly2.java @@ -549,5 +549,5 @@ private void computePotentialIODegreePerVert(ColouredGraph[] origGrphs){ } } } - + } diff --git a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationSimpleApproach.java b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationSimpleApproach.java index 427c35d8..2a32e72c 100644 --- a/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationSimpleApproach.java +++ b/src/main/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationSimpleApproach.java @@ -466,6 +466,4 @@ public TripleBaseSingleID getProposedTriple(boolean isRandom){ return super.getProposedTriple(true); } } - - } diff --git a/src/main/java/org/aksw/simba/lemming/tools/GraphGenerationTest.java b/src/main/java/org/aksw/simba/lemming/tools/GraphGenerationTest.java index d1d3bf61..910804a9 100644 --- a/src/main/java/org/aksw/simba/lemming/tools/GraphGenerationTest.java +++ b/src/main/java/org/aksw/simba/lemming/tools/GraphGenerationTest.java @@ -25,6 +25,7 @@ import org.aksw.simba.lemming.metrics.single.StdDevVertexDegree; import org.aksw.simba.lemming.metrics.single.edgetriangles.EdgeTriangleMetric; import org.aksw.simba.lemming.metrics.single.nodetriangles.NodeTriangleMetric; +import org.aksw.simba.lemming.mimicgraph.generator.BiasedGraphGenerator; import org.aksw.simba.lemming.mimicgraph.generator.GraphGenerationClusteringBased; import org.aksw.simba.lemming.mimicgraph.generator.GraphGenerationClusteringBased2; import org.aksw.simba.lemming.mimicgraph.generator.GraphGenerationRandomly; @@ -55,6 +56,7 @@ public static void main(String[] args) { IGraphGeneration mGrphGenerator; IDatasetManager mDatasetManager; boolean isStop = true; + boolean isPoissonFlow = true; // For this test, we do not need assertions ClassLoader.getSystemClassLoader().setDefaultAssertionStatus(false); @@ -192,8 +194,8 @@ public static void main(String[] args) { }else if(typeGenerator.equalsIgnoreCase("C")){ mGrphGenerator = new GraphGenerationClusteringBased(mNumberOfDesiredVertices, graphs, iNumberOfThreads, seed); }else if(typeGenerator.equalsIgnoreCase("CD")){ - mGrphGenerator = new GraphGenerationClusteringBased2(mNumberOfDesiredVertices, graphs, iNumberOfThreads, seed); - } else{ + mGrphGenerator = new GraphGenerationClusteringBased2(mNumberOfDesiredVertices, graphs, iNumberOfThreads, seed, isPoissonFlow); + }else{ mGrphGenerator = new GraphGenerationRandomly(mNumberOfDesiredVertices, graphs, iNumberOfThreads, seed); } diff --git a/src/test/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationClusteringBased2Test.java b/src/test/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationClusteringBased2Test.java new file mode 100644 index 00000000..b3e46b0b --- /dev/null +++ b/src/test/java/org/aksw/simba/lemming/mimicgraph/generator/GraphGenerationClusteringBased2Test.java @@ -0,0 +1,56 @@ +package org.aksw.simba.lemming.mimicgraph.generator; + +import static org.junit.Assert.assertTrue; + +import java.util.Random; + +import org.junit.Test; + +public class GraphGenerationClusteringBased2Test{ + + @Test + public void test() { + + int[] mean = {7,30, 4, 8, 50, 100, 25, 1}; + for(int m : mean) { + double diff = 0.0, diff1 = 0.0; + for(int l = 0; l < 1000; l++){ + int j = 10000; + double k = 0.0; + while(j>0){ + int i = getPoissonRandom(m); + //System.out.println("In 7 printing the value of i : "+i); + k += i; + j--; + + } + if((k/10000)>m){ + diff = (k/10000)-m; + } + else{ + diff = m-(k/10000); + } + //System.out.println("printing k : "+ (k/10000) +" and k - 30 : "+ diff); + diff1 += diff; + //break; + + } + System.out.println("Printng the value of diff : "+(diff1/1000)+" and percentage of error : "+ (((diff1/1000)/m)*100)); + assertTrue((((diff1/1000)/m)*100) < 1); + } + //fail("Not yet implemented"); + } + + static int getPoissonRandom(double mean) { + Random r = new Random(); + double L = Math.exp(-mean); + int k = 0; + double p = 1.0; + do { + p = p * r.nextDouble(); + k++; + } while (p > L); + //System.out.println("In 1085 printing the value of k-1 : "+(k-1)); + return k - 1; + } +} diff --git a/src/test/java/org/aksw/simba/lemming/mimicgraph/generator/Test.java b/src/test/java/org/aksw/simba/lemming/mimicgraph/generator/Test.java new file mode 100644 index 00000000..221d8faf --- /dev/null +++ b/src/test/java/org/aksw/simba/lemming/mimicgraph/generator/Test.java @@ -0,0 +1,18 @@ +package org.aksw.simba.lemming.mimicgraph.generator; +import org. junit.runner.JUnitCore; +import org. junit.runner. Result; +import org. junit.runner.notification.Failure; + +public class Test { + public static void main(String[] args) { + + Result result = JUnitCore.runClasses(GraphGenerationClusteringBased2Test.class); + + for (Failure failure : result.getFailures()) { + System.out.println("at 12"+failure.toString()); + } + + System.out.println("At 15 : "+result.wasSuccessful()); + } +} + \ No newline at end of file