main.cpp

/* EECS 298 Project - MC sentiment analysis 
   Movie review dataset is from
      https://www.kaggle.com/datasets/lakshmi25npathi/imdb-dataset-of-50k-movie-reviews
*/

#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cmath>
#include <fstream>
#include <set>
using namespace std;

#include "DataLoader.hpp"
#include "VocabClassifier.hpp"
#include "NullClassifier.hpp"
#include "NaiveBayesClassifier.hpp"

/* EFFECTS: loads the training data and feeds it to classifier */
void train(Classifier &classifier, int train_rows) {
    DataLoader trainingData("dataset_train.csv");

    vector<string> words;
    bool isPositive;
    for (int i = 0; i < train_rows; i++) {
        if (!trainingData.nextRecord(words, isPositive)) {
            cout << "Error: ran out of rows when training!" << endl;
            exit(1);
        }
        classifier.train(words, isPositive);
        words.clear();
    }
    classifier.trainingFinished();
}

struct ConfusionMatrix {
    int true_positive = 0;
    int false_positive = 0;
    int true_negative = 0;
    int false_negative = 0;
};

/* EFFECTS: loads the test data and feeds it to classifier.
            Returns the confusion matrix describing the classifier's
             performance.             
*/
ConfusionMatrix test(Classifier &classifier, int test_rows, vector<bool> &ConfusionVector) {
    // make predictions
    ConfusionMatrix result;

    DataLoader testData("dataset_test.csv");
    vector<string> words;
    bool isPositive;
    for (int i = 0; i < test_rows; i++) {
        if (!testData.nextRecord(words, isPositive)) {
            cout << "Error: ran out of rows when testing!" << endl;
            exit(1);
        }
        bool predictedPositive = classifier.classify(words);

        if (predictedPositive && isPositive) {
            result.true_positive += 1;
            ConfusionVector[i] = true;
        } else if (predictedPositive && !isPositive) {
            result.false_positive += 1;
            ConfusionVector[i] = false;
        } else if (!predictedPositive && isPositive) {
            result.false_negative += 1;
            ConfusionVector[i] = false;
        } else {
            result.true_negative += 1;
            ConfusionVector[i] = true;
        }

        words.clear();
    }
    return result;
}

// void accuracy_vs_examples(ofstream& of) {

//     of << "examples,vocab_accuracy,null_accuracy,naive_bayes_accuracy\n";
//     Classifier *classifiers[3];

//     for (int i = 0; i <= 15; i++) {
//         VocabClassifier vocab;
//         NullClassifier null;
//         NaiveBayesClassifier nbc;
//         classifiers[0] = &vocab;
//         classifiers[1] = &null;
//         classifiers[2] = &nbc;
        
//         of << pow(2, i);
//         for (int j = 0; j < 3; j++){
//             ConfusionMatrix matrix;
//             double accuracy;
//             train(*classifiers[j], pow(2, i));
//             matrix = test(*classifiers[j], 1000);
//             accuracy = (matrix.true_positive + matrix.true_negative) / 1000.0;
//             of << "," << accuracy;
//         }
//         of << endl;
//     }
// }



int main() {
    const int train_rows = 10000;
    const int test_rows = 1000;

    std::vector<bool> ConfusionVector1;
    ConfusionVector1.resize(test_rows);
    std::vector<bool> ConfusionVector2;
    ConfusionVector2.resize(test_rows);

    // Replace this with an instance of any classifier
    VocabClassifier classifier1;
    train(classifier1, train_rows);
    ConfusionMatrix result1 = test(classifier1, test_rows, ConfusionVector1);

    cout << "Confusion Matrix:" << endl;
    cout << "TP: " << result1.true_positive << endl;
    cout << "FP: " << result1.false_positive << endl;
    cout << "FN: " << result1.false_negative << endl;
    cout << "TN: " << result1.true_negative << endl;
    cout << endl;

    int correct1 = result1.true_positive + result1.true_negative;
    cout << "Accuracy: " << correct1 << "/" << test_rows << endl;
    cout << "Percent: " << (float(correct1) / test_rows) * 100 << endl;
    cout << endl;

    NaiveBayesClassifier classifier2;
    train(classifier2, train_rows);
    ConfusionMatrix result2 = test(classifier2, test_rows, ConfusionVector2);

    cout << "Confusion Matrix:" << endl;
    cout << "TP: " << result2.true_positive << endl;
    cout << "FP: " << result2.false_positive << endl;
    cout << "FN: " << result2.false_negative << endl;
    cout << "TN: " << result2.true_negative << endl;
    cout << endl;

    int correct2 = result2.true_positive + result2.true_negative;
    cout << "Accuracy: " << correct2 << "/" << test_rows << endl;
    cout << "Percent: " << (float(correct2) / test_rows) * 100 << endl;
    cout << endl;

    




    // first column is vocab, second column is nbc

    ofstream of;

    of.open("comparison.csv");
    if (!of.is_open()) {
        cout << "File could not be opened!" << endl;
        return 1;
    }

    DataLoader testData("dataset_test.csv");
    vector<string> words;
    bool isPositive;
    vector<int> bothCorrect;
    vector<int> vocabCorrect;
    vector<int> nbcCorrect;
    vector<int> neitherCorrect;
    double bothCorrectDuplicateCount = 0;
    double vocabCorrectDuplicateCount = 0;
    double nbcCorrectDuplicateCount = 0;
    double neitherCorrectDuplicateCount = 0;

    for (int i = 0; i < test_rows; i++){
        // of << ConfusionVector1[i] << "," << ConfusionVector2[i] << endl;
        if (!testData.nextRecord(words, isPositive)) {
            cout << "Error: ran out of rows when testing!" << endl;
            exit(1);
        }   
        set<string> nonDuplicateWords(words.begin(), words.end());
        int duplicates = words.size() - nonDuplicateWords.size();
        words.clear();
        if (ConfusionVector1[i] && ConfusionVector2[i]) {
            bothCorrect.push_back(duplicates);
            bothCorrectDuplicateCount += duplicates;
        } else if (ConfusionVector1[i] && !ConfusionVector2[i]) {
            vocabCorrect.push_back(duplicates);
            vocabCorrectDuplicateCount += duplicates;
        } else if (!ConfusionVector1[i] && ConfusionVector2[i]) {
            nbcCorrect.push_back(duplicates);
            nbcCorrectDuplicateCount += duplicates;
        } else {
            neitherCorrect.push_back(duplicates);
            neitherCorrectDuplicateCount += duplicates;
        }
    }

    bothCorrectDuplicateCount /= bothCorrect.size();
    vocabCorrectDuplicateCount /= vocabCorrect.size();
    nbcCorrectDuplicateCount /= nbcCorrect.size();
    neitherCorrectDuplicateCount /= neitherCorrect.size();

    of << "BothCorrect, NbcCorrect, VocabCorrect, NeitherCorrect" << endl;
    of << bothCorrectDuplicateCount << "," << nbcCorrectDuplicateCount << "," << vocabCorrectDuplicateCount << "," << neitherCorrectDuplicateCount << endl;
    of << bothCorrect.size() << "," << nbcCorrect.size() << "," << vocabCorrect.size() << "," << neitherCorrect.size() << endl;

    of.close();

    // ofstream of;

    // of.open("accuracy_vs_examples.csv");
    // if (!of.is_open()) {
    //     cout << "File could not be opened!" << endl;
    //     return 1;
    // }

    // accuracy_vs_examples(of);

    // of.close();

    return 0;
}