/**
* SVM trainer
*
* @param dataTrain
* @param dataTest
*/
public static void trainModelLibSVM(Instances dataTrain, Instances dataTest) {
try {
LibSVM classifier = new LibSVM();
CVParameterSelection ps = new CVParameterSelection();
ps.setClassifier(classifier);
ps.setNumFolds(5); // using 5-fold CV
// ps.addCVParameter("C 0.1 0.5 5");
// build and output best options
ps.buildClassifier(dataTrain);
Evaluation eval = new Evaluation(dataTrain);
eval.evaluateModel(ps, dataTest);
System.out.println("Results of the set :::::::::::::::::::::: ");
System.out.println(
"Percentage of correctly classified instances : "
+ eval.pctCorrect()
+ "\n"
+ "Percentage of incorrectly classified instances : "
+ eval.pctIncorrect());
System.out.println("No of correct predictions : " + eval.correct());
System.out.println("TRUTHFUL");
System.out.println(
"Precision : "
+ eval.precision(0)
+ "\n"
+ "Recall : "
+ eval.recall(0)
+ "\n"
+ "F measure/score : "
+ eval.fMeasure(0));
System.out.println("DECEPTIVE");
System.out.println(
"Precision : "
+ eval.precision(0)
+ "\n"
+ "Recall : "
+ eval.recall(1)
+ "\n"
+ "F measure/score : "
+ eval.fMeasure(1));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void execSVM(String expName) {
try {
FileWriter outFile = null;
PrintWriter out = null;
outFile = new FileWriter(expName + "-SVM.results");
out = new PrintWriter(outFile);
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
ProcessTweets tweetsProcessor = null;
System.out.println("***************************************");
System.out.println("***\tEXECUTING TEST\t" + expName + "***");
System.out.println("+++++++++++++++++++++++++++++++++++++++");
out.println("***************************************");
out.println("***\tEXECUTING TEST\t" + expName + "***");
out.println("+++++++++++++++++++++++++++++++++++++++");
out.println("4-Generate classifier " + dateFormat.format(new Date()));
Classifier cls = null;
DataSource sourceTrain = new DataSource(expName + "-train.arff");
Instances dataTrain = sourceTrain.getDataSet();
if (dataTrain.classIndex() == -1) dataTrain.setClassIndex(dataTrain.numAttributes() - 1);
// Entreno el clasificador
// cls = new weka.classifiers.functions.LibSVM();
int clase = dataTrain.numAttributes() - 1;
cls = new weka.classifiers.bayes.ComplementNaiveBayes();
dataTrain.setClassIndex(clase);
cls.buildClassifier(dataTrain);
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream(expName + "-SVM.classifier"));
oos.writeObject(cls);
oos.flush();
oos.close();
DataSource sourceTest = new DataSource(expName + "-test.arff");
Instances dataTest = sourceTest.getDataSet();
dataTest.setClassIndex(clase);
Evaluation eval = new Evaluation(dataTest);
eval.evaluateModel(cls, dataTest);
// Ahora calculo los valores precision, recall y fmeasure. Además saco las matrices de
// confusion
float precision = 0;
float recall = 0;
float fmeasure = 0;
int topeTopics = 8;
for (int ind = 0; ind < topeTopics; ind++) {
precision += eval.precision(ind);
recall += eval.recall(ind);
fmeasure += eval.fMeasure(ind);
}
precision = precision / topeTopics;
recall = recall / topeTopics;
fmeasure = fmeasure / topeTopics;
System.out.println("++++++++++++++ CNB ++++++++++++++++++++");
System.out.println(eval.toMatrixString());
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.printf("Precision: %.3f\n", precision);
System.out.printf("Recall: %.3f\n", recall);
System.out.printf("F-measure: %.3f\n", fmeasure);
System.out.println("***************************************");
out.println("++++++++++++++ CNB ++++++++++++++++++++");
out.println(eval.toMatrixString());
out.println("+++++++++++++++++++++++++++++++++++++++");
out.printf("Precision: %.3f\n", precision);
out.printf("Recall: %.3f\n", recall);
out.printf("F-measure: %.3f\n", fmeasure);
out.println("***************************************");
// OTRO CLASIFICADOR ZeroR
cls = new weka.classifiers.rules.ZeroR();
dataTrain.setClassIndex(clase);
cls.buildClassifier(dataTrain);
eval = new Evaluation(dataTest);
eval.evaluateModel(cls, dataTest);
precision = 0;
recall = 0;
fmeasure = 0;
for (int ind = 0; ind < topeTopics; ind++) {
precision += eval.precision(ind);
recall += eval.recall(ind);
fmeasure += eval.fMeasure(ind);
}
precision = precision / topeTopics;
recall = recall / topeTopics;
fmeasure = fmeasure / topeTopics;
System.out.println("++++++++++++++ ZEROR ++++++++++++++++++++");
System.out.println(eval.toMatrixString());
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.printf("Precision: %.3f\n", precision);
System.out.printf("Recall: %.3f\n", recall);
System.out.printf("F-measure: %.3f\n", fmeasure);
System.out.println("***************************************");
out.println("++++++++++++++ ZEROR ++++++++++++++++++++");
out.println(eval.toMatrixString());
out.println("+++++++++++++++++++++++++++++++++++++++");
out.printf("Precision: %.3f\n", precision);
out.printf("Recall: %.3f\n", recall);
out.printf("F-measure: %.3f\n", fmeasure);
out.println("***************************************");
// OTRO CLASIFICADOR J48
/*
cls = new weka.classifiers.trees.J48();
dataTrain.setClassIndex(clase);
cls.buildClassifier(dataTrain);
eval = new Evaluation(dataTest);
eval.evaluateModel(cls, dataTest);
precision=0;
recall=0;
fmeasure=0;
for(int ind=0; ind<topeTopics; ind++)
{
precision += eval.precision(ind);
recall += eval.recall(ind);
fmeasure += eval.fMeasure(ind);
}
precision = precision / topeTopics;
recall = recall / topeTopics;
fmeasure = fmeasure / topeTopics;
System.out.println("++++++++++++++ J48 ++++++++++++++++++++");
System.out.println(eval.toMatrixString());
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.printf("Precision: %.3f\n", precision);
System.out.printf("Recall: %.3f\n", recall);
System.out.printf("F-measure: %.3f\n", fmeasure);
System.out.println("***************************************");
out.println("++++++++++++++ J48 ++++++++++++++++++++");
out.println(eval.toMatrixString());
out.println("+++++++++++++++++++++++++++++++++++++++");
out.printf("Precision: %.3f\n", precision);
out.printf("Recall: %.3f\n", recall);
out.printf("F-measure: %.3f\n", fmeasure);
out.println("***************************************");
//OTRO SMO
cls = new weka.classifiers.functions.SMO();
dataTrain.setClassIndex(clase);
cls.buildClassifier(dataTrain);
eval = new Evaluation(dataTest);
eval.evaluateModel(cls, dataTest);
precision=0;
recall=0;
fmeasure=0;
for(int ind=0; ind<topeTopics; ind++)
{
precision += eval.precision(ind);
recall += eval.recall(ind);
fmeasure += eval.fMeasure(ind);
}
precision = precision / topeTopics;
recall = recall / topeTopics;
fmeasure = fmeasure / topeTopics;
System.out.println("++++++++++++++ SMO ++++++++++++++++++++");
System.out.println(eval.toMatrixString());
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.printf("Precision: %.3f\n", precision);
System.out.printf("Recall: %.3f\n", recall);
System.out.printf("F-measure: %.3f\n", fmeasure);
System.out.println("***************************************");
out.println("++++++++++++++ SMO ++++++++++++++++++++");
out.println(eval.toMatrixString());
out.println("+++++++++++++++++++++++++++++++++++++++");
out.printf("Precision: %.3f\n", precision);
out.printf("Recall: %.3f\n", recall);
out.printf("F-measure: %.3f\n", fmeasure);
out.println("***************************************");
*/
out.flush();
out.close();
dataTest.delete();
dataTrain.delete();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void exec(PrintWriter printer) {
try {
FileWriter outFile = null;
PrintWriter out = null;
if (printer == null) {
outFile = new FileWriter(id + ".results");
out = new PrintWriter(outFile);
} else out = printer;
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
ProcessTweets tweetsProcessor = null;
System.out.println("***************************************");
System.out.println("***\tEXECUTING TEST\t" + id + "***");
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.println("Train size:" + traincorpus.size());
System.out.println("Test size:" + testcorpus.size());
out.println("***************************************");
out.println("***\tEXECUTING TEST\t***");
out.println("+++++++++++++++++++++++++++++++++++++++");
out.println("Train size:" + traincorpus.size());
out.println("Test size:" + testcorpus.size());
String cloneID = "";
boolean clonar = false;
if (baseline) {
System.out.println("***************************************");
System.out.println("***\tEXECUTING TEST BASELINE\t***");
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.println("Train size:" + traincorpus.size());
System.out.println("Test size:" + testcorpus.size());
out.println("***************************************");
out.println("***\tEXECUTING TEST\t***");
out.println("+++++++++++++++++++++++++++++++++++++++");
out.println("Train size:" + traincorpus.size());
out.println("Test size:" + testcorpus.size());
BaselineClassifier base = new BaselineClassifier(testcorpus, 8);
precision = base.getPrecision();
recall = base.getRecall();
fmeasure = base.getFmeasure();
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.printf("Precision: %.3f\n", precision);
System.out.printf("Recall: %.3f\n", recall);
System.out.printf("F-measure: %.3f\n", fmeasure);
System.out.println("***************************************");
out.println("+++++++++++++++++++++++++++++++++++++++");
out.printf("Precision: %.3f\n", precision);
out.printf("Recall: %.3f\n", recall);
out.printf("F-measure: %.3f\n", fmeasure);
out.println("***************************************");
out.flush();
out.close();
return;
} else {
System.out.println("Stemming: " + stemming);
System.out.println("Lematization:" + lematization);
System.out.println("URLs:" + urls);
System.out.println("Hashtags:" + hashtags);
System.out.println("Mentions:" + mentions);
System.out.println("Unigrams:" + unigrams);
System.out.println("Bigrams:" + bigrams);
System.out.println("TF:" + tf);
System.out.println("TF-IDF:" + tfidf);
out.println("Stemming: " + stemming);
out.println("Lematization:" + lematization);
out.println("URLs:" + urls);
out.println("Hashtags:" + hashtags);
out.println("Mentions:" + mentions);
out.println("Unigrams:" + unigrams);
out.println("Bigrams:" + bigrams);
out.println("TF:" + tf);
out.println("TF-IDF:" + tfidf);
}
// Si tengo los tweets procesados, me evito un nuevo proceso
System.out.println("1-Process tweets " + dateFormat.format(new Date()));
out.println("1-Process tweets " + dateFormat.format(new Date()));
List<ProcessedTweet> train = null;
String[] ids = id.split("-");
cloneID = ids[0] + "-" + (Integer.valueOf(ids[1]) + 6);
if (((Integer.valueOf(ids[1]) / 6) % 2) == 0) clonar = true;
if (new File(id + "-train.ptweets").exists()) {
train = ProcessedTweetSerialization.fromFile(id + "-train.ptweets");
tweetsProcessor =
new ProcessTweets(stemming, lematization, urls, hashtags, mentions, unigrams, bigrams);
if (lematization) {
tweetsProcessor.doLematization(train);
}
if (stemming) {
tweetsProcessor.doStemming(train);
}
} else {
tweetsProcessor =
new ProcessTweets(stemming, lematization, urls, hashtags, mentions, unigrams, bigrams);
// Esto del set training es un añadido para poder diferenciar los idiomas de las url en el
// corpus paralelo
// tweetsProcessor.setTraining(true);
train = tweetsProcessor.processTweets(traincorpus);
// tweetsProcessor.setTraining(false);
ProcessedTweetSerialization.toFile(id + "-train.ptweets", train);
/*
if (clonar)
{
File f = new File (id+"-train.ptweets");
Path p = f.toPath();
CopyOption[] options = new CopyOption[]{
StandardCopyOption.REPLACE_EXISTING,
StandardCopyOption.COPY_ATTRIBUTES
};
Files.copy(p, new File (cloneID+"-train.ptweets").toPath(), options);
Files.copy(p, new File (ids[0]+"-"+(Integer.valueOf(ids[1])+12)+"-train.ptweets").toPath(), options);
Files.copy(p, new File (ids[0]+"-"+(Integer.valueOf(ids[1])+18)+"-train.ptweets").toPath(), options);
Files.copy(p, new File (ids[0]+"-"+(Integer.valueOf(ids[1])+24)+"-train.ptweets").toPath(), options);
Files.copy(p, new File (ids[0]+"-"+(Integer.valueOf(ids[1])+30)+"-train.ptweets").toPath(), options);
}
*/
}
// Generamos las BOW. Igual que antes, si existen no las creo.
System.out.println("2-Fill topics " + dateFormat.format(new Date()));
out.println("2-Fill topics " + dateFormat.format(new Date()));
TopicsList topics = null;
if (new File(id + ".topics").exists()) {
topics = TopicsSerialization.fromFile(id + ".topics");
if (tf) topics.setSelectionFeature(TopicDesc.TERM_TF);
else topics.setSelectionFeature(TopicDesc.TERM_TF_IDF);
topics.prepareTopics();
} else {
topics = new TopicsList();
if (tf) topics.setSelectionFeature(TopicDesc.TERM_TF);
else topics.setSelectionFeature(TopicDesc.TERM_TF_IDF);
System.out.println("Filling topics " + dateFormat.format(new Date()));
topics.fillTopics(train);
System.out.println("Preparing topics topics " + dateFormat.format(new Date()));
// Aquí tengo que serializar antes de preparar, porque si no no puedo calcular los tf y
// tfidf
System.out.println("Serializing topics topics " + dateFormat.format(new Date()));
/*
if (clonar)
{
TopicsSerialization.toFile(cloneID+".topics", topics);
}
*/
topics.prepareTopics();
TopicsSerialization.toFile(id + ".topics", topics);
}
System.out.println("3-Generate arff train file " + dateFormat.format(new Date()));
out.println("3-Generate arff train file " + dateFormat.format(new Date()));
// Si el fichero arff no existe, lo creo. en caso contrario vengo haciendo lo que hasta ahora,
// aprovechar trabajo previo
if (!new File(id + "-train.arff").exists()) {
BufferedWriter bw = topics.generateArffHeader(id + "-train.arff");
int tope = traincorpus.size();
if (tweetsProcessor == null)
tweetsProcessor =
new ProcessTweets(
stemming, lematization, urls, hashtags, mentions, unigrams, bigrams);
for (int indTweet = 0; indTweet < tope; indTweet++) {
topics.generateArffVector(bw, train.get(indTweet));
}
bw.flush();
bw.close();
}
// Ahora proceso los datos de test
System.out.println("5-build test dataset " + dateFormat.format(new Date()));
out.println("5-build test dataset " + dateFormat.format(new Date()));
List<ProcessedTweet> test = null;
if (new File(id + "-test.ptweets").exists())
test = ProcessedTweetSerialization.fromFile(id + "-test.ptweets");
else {
if (tweetsProcessor == null)
tweetsProcessor =
new ProcessTweets(
stemming, lematization, urls, hashtags, mentions, unigrams, bigrams);
test = tweetsProcessor.processTweets(testcorpus);
ProcessedTweetSerialization.toFile(id + "-test.ptweets", test);
/*
if (clonar)
{
File f = new File (id+"-test.ptweets");
Path p = f.toPath();
CopyOption[] options = new CopyOption[]{
StandardCopyOption.REPLACE_EXISTING,
StandardCopyOption.COPY_ATTRIBUTES
};
Files.copy(p, new File (cloneID+"-test.ptweets").toPath(), options);
}
*/
}
// Si el fichero arff no existe, lo creo. en caso contrario vengo haciendo lo que hasta ahora,
// aprovechar trabajo previo
if (!new File(id + "-test.arff").exists()) {
BufferedWriter bw = topics.generateArffHeader(id + "-test.arff");
int tope = testcorpus.size();
if (tweetsProcessor == null)
tweetsProcessor =
new ProcessTweets(
stemming, lematization, urls, hashtags, mentions, unigrams, bigrams);
for (int indTweet = 0; indTweet < tope; indTweet++) {
topics.generateArffVector(bw, test.get(indTweet));
}
bw.flush();
bw.close();
}
int topeTopics = topics.getTopicsList().size();
topics.getTopicsList().clear();
// Genero el clasificador
// FJRM 25-08-2013 Lo cambio de orden para intentar liberar la memoria de los topics y tener
// más libre
System.out.println("4-Generate classifier " + dateFormat.format(new Date()));
out.println("4-Generate classifier " + dateFormat.format(new Date()));
Classifier cls = null;
DataSource sourceTrain = null;
Instances dataTrain = null;
if (new File(id + "-MNB.classifier").exists()) {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(id + "-MNB.classifier"));
cls = (Classifier) ois.readObject();
ois.close();
} else {
sourceTrain = new DataSource(id + "-train.arff");
dataTrain = sourceTrain.getDataSet();
if (dataTrain.classIndex() == -1) dataTrain.setClassIndex(dataTrain.numAttributes() - 1);
// Entreno el clasificador
cls = new weka.classifiers.bayes.NaiveBayesMultinomial();
int clase = dataTrain.numAttributes() - 1;
dataTrain.setClassIndex(clase);
cls.buildClassifier(dataTrain);
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream(id + "-MNB.classifier"));
oos.writeObject(cls);
oos.flush();
oos.close();
// data.delete();//no borro para el svm
}
// Ahora evaluo el clasificador con los datos de test
System.out.println("6-Evaluate classifier MNB " + dateFormat.format(new Date()));
out.println("6-Evaluate classifier MNB" + dateFormat.format(new Date()));
DataSource sourceTest = new DataSource(id + "-test.arff");
Instances dataTest = sourceTest.getDataSet();
int clase = dataTest.numAttributes() - 1;
dataTest.setClassIndex(clase);
Evaluation eval = new Evaluation(dataTest);
eval.evaluateModel(cls, dataTest);
// Ahora calculo los valores precision, recall y fmeasure. Además saco las matrices de
// confusion
precision = 0;
recall = 0;
fmeasure = 0;
for (int ind = 0; ind < topeTopics; ind++) {
precision += eval.precision(ind);
recall += eval.recall(ind);
fmeasure += eval.fMeasure(ind);
}
precision = precision / topeTopics;
recall = recall / topeTopics;
fmeasure = fmeasure / topeTopics;
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.println(eval.toMatrixString());
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.printf("Precision: %.3f\n", precision);
System.out.printf("Recall: %.3f\n", recall);
System.out.printf("F-measure: %.3f\n", fmeasure);
System.out.println("***************************************");
out.println("+++++++++++++++++++++++++++++++++++++++");
out.println(eval.toMatrixString());
out.println("+++++++++++++++++++++++++++++++++++++++");
out.printf("Precision: %.3f\n", precision);
out.printf("Recall: %.3f\n", recall);
out.printf("F-measure: %.3f\n", fmeasure);
out.println("***************************************");
/* NO BORRAR
System.out.println("7-Evaluate classifier SVM"+dateFormat.format(new Date()));
out.println("7-Evaluate classifier SVM"+dateFormat.format(new Date()));
if (new File(id+"-SVM.classifier").exists())
{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(id+"-SVM.classifier"));
cls = (Classifier) ois.readObject();
ois.close();
}
else
{
if (dataTrain==null)
{
sourceTrain = new DataSource(id+"-train.arff");
dataTrain = sourceTrain.getDataSet();
if (dataTrain.classIndex() == -1)
dataTrain.setClassIndex(dataTrain.numAttributes() - 1);
}
//Entreno el clasificador
cls = new weka.classifiers.functions.LibSVM();
clase = dataTrain.numAttributes()-1;
dataTrain.setClassIndex(clase);
cls.buildClassifier(dataTrain);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(id+"-SVM.classifier"));
oos.writeObject(cls);
oos.flush();
oos.close();
dataTrain.delete();
}
eval.evaluateModel(cls, dataTest);
precision=0;
recall=0;
fmeasure=0;
for(int ind=0; ind<topeTopics; ind++)
{
precision += eval.precision(ind);
recall += eval.recall(ind);
fmeasure += eval.fMeasure(ind);
}
precision = precision / topeTopics;
recall = recall / topeTopics;
fmeasure = fmeasure / topeTopics;
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.println(eval.toMatrixString());
System.out.println("+++++++++++++++++++++++++++++++++++++++");
System.out.printf("Precision: %.3f\n", precision);
System.out.printf("Recall: %.3f\n", recall);
System.out.printf("F-measure: %.3f\n", fmeasure);
System.out.println("***************************************");
out.println("+++++++++++++++++++++++++++++++++++++++");
out.println(eval.toMatrixString());
out.println("+++++++++++++++++++++++++++++++++++++++");
out.printf("Precision: %.3f\n", precision);
out.printf("Recall: %.3f\n", recall);
out.printf("F-measure: %.3f\n", fmeasure);
out.println("***************************************");
*/
System.out.println("Done " + dateFormat.format(new Date()));
out.println("Done " + dateFormat.format(new Date()));
if (printer == null) {
out.flush();
out.close();
}
// Intento de liberar memoria
if (dataTrain != null) dataTrain.delete();
if (dataTest != null) dataTest.delete();
if (train != null) train.clear();
if (test != null) test.clear();
if (topics != null) {
topics.getTopicsList().clear();
topics = null;
}
if (dataTest != null) dataTest.delete();
if (cls != null) cls = null;
if (tweetsProcessor != null) tweetsProcessor = null;
System.gc();
} catch (Exception e) {
e.printStackTrace();
}
}
public void runFilter() throws Exception {
System.out.println("filtering attributes...");
System.out.println("running weka filters and weka-libsvm");
File svmfile = new File(sentiAnalysis.DIR.concat(sentiAnalysis.outout.concat(".libsvm")));
LibSVMLoader libl = new LibSVMLoader();
libl.setFile(svmfile);
Instances data = libl.getDataSet();
NumericToNominal nm = new NumericToNominal(); // Converting last index
// attribute to type
// nominal from numeric
nm.setAttributeIndices("last"); // as the last index would be class
// label for the data
nm.setInputFormat(data);
filteredData = Filter.useFilter(data, nm); // filtered data stored in
// new Instances object
AttrNo = filteredData.numAttributes(); // number of attributes in given
// file
RecordNo = filteredData.numInstances(); // Number of records in given
// file
lowerBound = 0;
upperBound = AttrNo - 1;
AttributeSelection atsl = new AttributeSelection();
Ranker search = new Ranker();
InfoGainAttributeEval infog = new InfoGainAttributeEval(); // Applying
// Attribute
// Selection
// using
// InfoGain
// evaluator
// with
// Ranker
// search
atsl.setEvaluator(infog);
atsl.setSearch(search);
atsl.SelectAttributes(filteredData);
InfoGain = atsl.rankedAttributes();
SelectedAttributes = atsl.selectedAttributes();
// count non zero infoGain
int count = 0;
for (int i = 0; i < InfoGain.length; i++) {
count = (InfoGain[i][1] > 0) ? count + 1 : count;
}
System.out.println("writing attributes with non-zero InfoGain...");
FileWriter svmout =
new FileWriter(sentiAnalysis.DIR.concat(sentiAnalysis.outout.concat("_new.libsvm")));
for (int i = 0; i < RecordNo; i++) {
int index = 1;
svmout.write((int) filteredData.instance(i).value(filteredData.classIndex()) + " ");
for (int j = 0; j < count; j++) {
svmout.write(
index + ":" + (int) filteredData.instance(i).value((int) InfoGain[j][0]) + " ");
index++;
}
svmout.write("\n");
}
svmout.close();
// filtered
File newsvm = new File(sentiAnalysis.DIR.concat(sentiAnalysis.outout.concat("_new.libsvm")));
LibSVMLoader liblnew = new LibSVMLoader();
liblnew.setFile(newsvm);
Instances newdata = liblnew.getDataSet();
nm = new NumericToNominal(); // Converting last index attribute to type
// nominal from numeric
nm.setAttributeIndices("last"); // as the last index would be class
// label for the data
nm.setInputFormat(newdata);
Instances filteredDataNew = Filter.useFilter(newdata, nm); // filtered
// data
// stored in
// new
// Instances
// object
// test file
File newsvmtest =
new File(sentiAnalysis.DIR.concat(sentiAnalysis.outout.concat("_test.libsvm")));
LibSVMLoader libltest = new LibSVMLoader();
libltest.setFile(newsvmtest);
Instances newdatatest = libltest.getDataSet();
nm = new NumericToNominal(); // Converting last index attribute to type
// nominal from numeric
nm.setAttributeIndices("last"); // as the last index would be class
// label for the data
nm.setInputFormat(newdatatest);
Instances filteredDataTest = Filter.useFilter(newdatatest, nm); // filtered
// data
// stored
// in
// new
// Instances
// object
// weka.classifiers.functions.LibSVM -S 0 -K 2 -D 3 -G 0.0 -R 0.0 -N 0.5
// -M 40.0 -C 1.0 -E 0.001 -P 0.1 -seed 1
String[] options = new String[1];
options[0] = "-S 0 -K 2 -D 3 -G 0.1 -R 0.0 -N 0.5 -M 40.0 -C 1.0 -E 0.001 -P 0.1 -seed 1 -h 0";
System.out.println("building classifier...");
LibSVM svm_model = new LibSVM();
svm_model.setOptions(options); // set the options
svm_model.buildClassifier(filteredData); // build classifier
DecimalFormat df = new DecimalFormat("0.00");
System.out.println("running cross validation...");
Evaluation eval = new Evaluation(filteredData);
// eval.crossValidateModel(svm_model, filteredDataNew, 10, new
// Random(1));
eval.evaluateModel(svm_model, filteredDataTest);
FileWriter results =
new FileWriter(sentiAnalysis.DIR.concat(sentiAnalysis.outout.concat("_results.txt")));
results.write("Classifier 1: Support Vector Machines\n");
results.write("Positive class precision: " + df.format(eval.precision(0)) + "\n");
results.write("Positive class recall: " + df.format(eval.recall(0)) + "\n");
results.write("Positive class f-score: " + df.format(eval.fMeasure(0)) + "\n");
results.write("Negative class precision: " + df.format(eval.precision(0)) + "\n");
results.write("Negative class recall: " + df.format(eval.precision(0)) + "\n");
results.write("Negative class f-score: " + df.format(eval.fMeasure(0)) + "\n");
System.out.println("generating results...");
System.out.println("*" + sentiAnalysis.outout + "*\t" + "\tPositive\tNegative\tNeutral");
System.out.println(
"Precision\t"
+ df.format(eval.precision(0))
+ "\t"
+ df.format(eval.precision(2))
+ "\t"
+ df.format(eval.precision(1)));
System.out.println(
"Recall\t"
+ df.format(eval.recall(0))
+ "\t"
+ df.format(eval.recall(2))
+ "\t"
+ df.format(eval.recall(1)));
System.out.println(
"F-score\t"
+ df.format(eval.fMeasure(0))
+ "\t"
+ df.format(eval.fMeasure(2))
+ "\t"
+ df.format(eval.fMeasure(1)));
results.close();
}