Coursera Recommender System assignment for User-User collaborative filtering

Assignment1.csv

UserUserCollaborativeFiltering.java

import com.opencsv.CSVReader;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.bidimap.TreeBidiMap;
import org.apache.commons.math3.stat.correlation.PearsonsCorrelation;

import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;


class UserUserCollaborativeFiltering {

    static boolean isNormalized;

    public static void main(String args[]) throws IOException {
        double correlationMatrix[][];
        double dataMatrix[][] = new double[25][100];
        CSVReader reader = new CSVReader(new FileReader("/home/rajarshee/Documents/Assignment1.csv"));
        String temp[] = reader.readNext();
        BidiMap<Integer, String> userID = new TreeBidiMap<>();
        BidiMap<Integer, String> movieID = new TreeBidiMap<>();
        for (int i = 1; i < temp.length; i++)
            userID.put(i - 1, temp[i]);
        String[] line;
        int j = 0;
        while ((line = reader.readNext()) != null) {
            movieID.put(j, line[0]);
            for (int i = 1; i < 26; i++)
                dataMatrix[i - 1][j] = (line[i].length() == 0) ? -1 : Double.parseDouble(line[i]);
            j++;

        }
        String user = "89";
        isNormalized = true;
        correlationMatrix = getCorrelationMatrix(dataMatrix);
        List<Pair> sortedNeighbors = neighbors(userID.getKey(user), correlationMatrix);
        List<Pair> predictions = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            double n = 0, d = 0;
            for (j = 0; j < 5; j++) {
                if (dataMatrix[sortedNeighbors.get(j).u][i] != -1) {
                    n += (dataMatrix[sortedNeighbors.get(j).u][i] - getMean(sortedNeighbors.get(j).u, dataMatrix)) * correlationMatrix[userID.getKey(user)][sortedNeighbors.get(j).u];
                    d += correlationMatrix[userID.getKey(user)][sortedNeighbors.get(j).u];
                }
            }
            predictions.add(new Pair(i, (d == 0) ? -1 : getMean(userID.getKey(user), dataMatrix) + n / d));
        }
        Collections.sort(predictions);
        predictions.forEach(p -> System.out.println(movieID.get(p.u) + "," + p.v));

    }

    public static void displayData(double[][] d) {
        for (int i = 0; i < d.length; i++) {
            for (double x : d[i])
                System.out.print(x + "\t");
            System.out.println();
        }
    }

    public static double[][] getCorrelationMatrix(double d[][]) {
        double correlationMatrix[][] = new double[25][25];
        for (int i = 0; i < 25; i++) {
            for (int j = 0; j < 25; j++) {
                correlationMatrix[i][j] = getCorrelation(i, j, d);
            }
        }
        return correlationMatrix;
    }

    public static double getCorrelation(int i, int j, double d[][]) {
        List<Double> x = new ArrayList<>(), y = new ArrayList<>();

        for (int k = 0; k < 100; k++) {
            if (d[i][k] != -1 && d[j][k] != -1) {
                x.add(d[i][k]);
                y.add(d[j][k]);
            }
        }
        return new PearsonsCorrelation().correlation(x.stream().mapToDouble(t -> t).toArray(), y.stream().mapToDouble(t -> t).toArray());
    }

    public static List<Pair> neighbors(int i, double[][] corr) {
        double[] temp = corr[i];
        BidiMap<Integer, Double> bm = new TreeBidiMap<>();
        List<Pair> l = new ArrayList<>();
        for (int j = 0; j < temp.length; j++) {
            if (j != i) {
                l.add(new Pair(j, temp[j]));
            }
        }
        Collections.sort(l);
        return l;
    }

    public static double getMean(int i, double[][] d) {
        if (!isNormalized)
            return 0;
        double sum = 0;
        int n = 0;
        for (double x : d[i]) {
            if (x != -1) {
                sum += x;
                ++n;
            }
        }
        return sum / n;
    }
}

class Pair implements Comparable<Pair> {

    public int u;
    public double v;

    Pair(int u, double v) {
        this.u = u;
        this.v = v;
    }

    @Override
    public int compareTo(Pair o) {
        return (o.v > this.v) ? 1 : ((o.v == this.v) ? 0 : -1);
    }

    @Override
    public String toString() {
        return u + ":" + v;
    }
}