public class Logger {
private final JSONObject callLog;
private static final String SEPARATOR = System.getProperty("line.separator");
public Logger() {
callLog = new JSONObject();
}
private void logTimestamp() {
callLog.put("timestamp", System.currentTimeMillis());
}
private void logTargetClass(Object target) {
callLog.put("class", target.getClass().getName());
}
private void logMethod(Method method) {
callLog.put("method", method.getName());
}
public void logMethodCall(Method method, Object[] args, Object target) throws Throwable {
Throwable caught = null;
Object returnValue = null;
logTimestamp();
logTargetClass(target);
logMethod(method);
logArguments(args);
}
private void logArguments(Object[] args) {
IdentityHashMap<Iterable, Boolean> identityHashMap = new IdentityHashMap<Iterable, Boolean>();
if (args != null) {
callLog.put("arguments", logIterable(Arrays.asList(args), identityHashMap));
} else {
callLog.put("arguments", new JSONArray());
}
}
private Object logIterable(
Iterable iterable, IdentityHashMap<Iterable, Boolean> identityHashMap) {
if (identityHashMap.containsKey(iterable)) {
return "cyclic";
}
identityHashMap.put(iterable, true);
JSONArray iterableValues = new JSONArray();
if (iterable != null) {
for (Object value : iterable) {
if (value instanceof Iterable) {
iterableValues.put(logIterable((Iterable) value, identityHashMap));
} else if ((value != null) && (value.getClass().isArray())) {
iterableValues.put(value.toString());
} else {
iterableValues.put(value);
}
}
}
return iterableValues;
}
public void logReturnValue(Object returnValue) {
IdentityHashMap<Iterable, Boolean> identityHashMap = new IdentityHashMap<Iterable, Boolean>();
if (returnValue == null) {
callLog.put("returnValue", JSONObject.NULL);
} else if (!(returnValue instanceof Iterable)) {
callLog.put("returnValue", returnValue);
} else {
callLog.put("returnValue", logIterable((Iterable) returnValue, identityHashMap));
}
}
public void logThrown(Throwable thrown) {
callLog.put("thrown", thrown.toString());
}
// for test purposes
public JSONObject getResultObject() {
return callLog;
}
@Override
public String toString() {
return (callLog.toString(2) + SEPARATOR);
}
}
/**
* Parses a text file of JSONs into an array of tweets
*
* @param textFile The textfile containing the JSONs
*/
public parseJSON() {
// get folder paths
String currentDir = System.getProperty("user.dir");
String root = currentDir;
String textFile = root + "/tweet_input/tweets.txt";
String outputFolderF1 = root + "/tweet_output/f1.txt";
String outputFolderF2 = root + "/tweet_output/f2.txt";
int numTweets = 0;
int numGoodTweets = 0;
hashtagEdges hashEdges = new hashtagEdges();
// try objects
try {
// create a reader object for tweet's textfile and read-in first line
BufferedReader reader = new BufferedReader(new FileReader(textFile));
String currentJSON = reader.readLine();
// System.out.println(textFile);
// initate a writer object with the outputFolder name
PrintWriter writerF1 = new PrintWriter(outputFolderF1, "UTF-8");
PrintWriter writerF2 = new PrintWriter(outputFolderF2, "UTF-8");
// create an array list to save parsedTweets and declare problem variables
List<parsedTweet> tweetList = new ArrayList<parsedTweet>();
String tweetText, tweetTime;
JSONObject objJSON;
String[] hashArray;
parsedTweet tweetObj;
float currentAverage;
while (currentJSON != null) {
try {
objJSON = new JSONObject(currentJSON);
// if the JSON has a text and time stamp, process it
numTweets = numTweets + 1;
if (objJSON.has("created_at") && objJSON.has("text")) {
// get timestamp and text from JSON object
tweetTime = objJSON.getString("created_at");
tweetText = objJSON.getString("text");
// create a tweet object and add it to folder
tweetObj = new parsedTweet(tweetTime, tweetText, currentJSON);
tweetList.add(tweetObj);
// update hashObjet
hashArray = tweetObj.hashtags.toArray(new String[tweetObj.hashtags.size()]);
currentAverage = hashEdges.updateEdges(hashArray, tweetTime);
// write correctly-formated cleen-tweet to output folder
writerF1.println(tweetObj.formatTweet());
numGoodTweets = numGoodTweets + 1;
writerF2.format("%.2f%n", currentAverage);
}
} catch (Exception e) {
System.out.println("Error in parseJSON - 1");
e.printStackTrace();
}
// read next line (which has the next JSON object)
currentJSON = reader.readLine();
}
writerF1.close();
writerF2.close();
} catch (Exception e) {
System.out.println("Error in parseJSON - 2");
e.printStackTrace();
}
}
public static void main(String[] args) throws Throwable {
DATASET = System.getProperty("dataset", "movielens-pos.json");
TRAINPERCENT = Double.parseDouble(System.getProperty("trainPercent", "0.8"));
TESTPERCENT = Double.parseDouble(System.getProperty("testPercent", "0.5"));
RUNS = Integer.parseInt(System.getProperty("runs", "1"));
PREDICTIONS = Integer.parseInt(System.getProperty("predictions", "1"));
// rand = new Random( Integer.parseInt( System.getProperty( "seed", "1" ) ) );
rand = new Random();
System.out.println("File: " + DATASET);
System.out.println("Train Percent: " + TRAINPERCENT);
System.out.println("Test Percent: " + TESTPERCENT);
System.out.println("Runs: " + RUNS);
System.out.println("Predictions: " + PREDICTIONS);
docs = DatasetOld.loadDataset(DATASET);
for (Algorithm alg : algs) {
System.out.print(alg.name + "\t");
double total = 0.0;
long trainTime = 0;
long predictTime = 0;
for (int run = 0; run < RUNS; run++) {
ArrayList<HashMap<Integer, Double>> traindocs = new ArrayList<HashMap<Integer, Double>>();
ArrayList<HashMap<Integer, Double>> testdocs = new ArrayList<HashMap<Integer, Double>>();
for (HashMap<Integer, Double> doc : docs) {
if (rand.nextDouble() < TRAINPERCENT) traindocs.add(doc);
else testdocs.add(doc);
}
long startTime = System.nanoTime();
alg.train(traindocs);
trainTime += System.nanoTime() - startTime;
int successes = 0;
for (HashMap<Integer, Double> testdoc : testdocs) {
HashMap<Integer, Double> givenwords = new HashMap<Integer, Double>();
HashSet<Integer> testwords = new HashSet<Integer>();
for (int word : testdoc.keySet()) {
if (rand.nextDouble() < TESTPERCENT) {
testwords.add(word);
} else {
givenwords.put(word, testdoc.get(word));
}
}
startTime = System.nanoTime();
double[] scores = alg.predict(givenwords);
predictTime += System.nanoTime() - startTime;
// System.out.println(Arrays.toString( scores ));
PriorityQueue<Pair> pq = new PriorityQueue<Pair>();
for (int i = 0; i < scores.length; i++) {
if (givenwords.containsKey(i)) {
continue;
}
if (pq.size() < PREDICTIONS) {
pq.add(new Pair(i, scores[i]));
}
if (scores[i] > pq.peek().score) {
pq.poll();
pq.add(new Pair(i, scores[i]));
}
}
while (!pq.isEmpty()) {
Pair pair = pq.poll();
// System.out.println( WordIndex.get( pair.word ) + "\t" + pair.score + "\t" +
// testwords.contains( pair.word ) );
if (testwords.contains(pair.word)) {
successes++;
}
}
}
total += (double) successes / PREDICTIONS / testdocs.size();
}
System.out.println(
total / RUNS
+ "\t"
+ (trainTime / 1000000000.0 / RUNS)
+ "\t"
+ (predictTime / 1000000000.0 / RUNS));
}
}
