In [1]:

    

from sklearn.linear_model import SGDRegressor
from _collections import defaultdict
import time
import timeit

from numpy.linalg import norm
import scipy.optimize
import random
from sets import Set

import numpy as np
import pickle


    

In [2]:

    

def parseData(fname):
  for l in open(fname):
    yield eval(l)
    
def parseTxt(fname):
  for l in open(fname):
    yield l.strip().split(" ")

print "Reading train..."
train = list(parseData("/home/iizhaki/oasis/CSE255/Project2/assignment2/train.json"))


    

    




Reading train...

In [2]:

    




    

In [2]:

    




    

In [3]:

    

print "done"

allXs = []
allYs = []
for l in train:
  user, item, rating = l['reviewerID'], l['itemID'], l['rating']
  allXs.append([user, item])
  allYs.append(float(rating))


    

    




done

In [3]:

    




    

In [3]:

    




    

In [4]:

    

lambd = 1.0
alpha = 0
X = allXs
y = allYs
Ntrain = len(y)
data = zip(X, y)

numU = 0
numI = 0
allUs = {}
allUrs = {}
allIs = {}
allIrs = {}
fastData = []
for [u, i], Rui in data:
    if u not in allUs:
        allUs[u] = numU
        allUrs[numU] = u
        numU += 1
    if i not in allIs:
        allIs[i] = numI
        allIrs[numI] = i
        numI += 1
    fastData.append((allUs[u], allIs[i], Rui))


Iu = np.zeros(numU)
Ii = np.zeros(numI)
uToRI = [[]] * numU
iToRU = [[]] * numI
for (u, i, Rui) in fastData:
    Iu[u] += 1
    Ii[i] += 1
    if uToRI[u] == []:
        uToRI[u] = [(i, Rui)]
    else:
        uToRI[u].append((i, Rui))
    if iToRU[i] == []:
        iToRU[i] = [(u, Rui)]
    else:
        iToRU[i].append((u, Rui))


    

In [5]:

    

print "Done"


    

    




Done

In [6]:

    

# Objective
def func(theta, X, y, lam):
    diff = numpy.dot(X,theta) - y
    diffSq = numpy.dot(diff,diff) 
    diffSqReg = diffSq  + lam * numpy.dot(theta,theta)
    #print "offset =", diffSqReg
    return diffSqReg

# Derivative
def fprime(theta, X, y, lam):
    diff = numpy.dot(X,theta) - y
    res = 2 * numpy.dot(X.T,diff)    + 2 * lam * theta
    #print "gradient =", res
    return res


    

In [9]:

    

def miniFunc(Data, Alpha, BetaU, BetaI, GammaU, GammaI, Lambd):
    part1 = 0
    for (u, i, Rui) in Data:
        part1 += ((Alpha + BetaU[u] + BetaI[i] + np.dot(GammaU[u], GammaI[i]) - Rui) ** 2)
    
    part2 = sum(BetaU * BetaU) + sum(BetaI * BetaI)
    part3 = sum(GammaU * GammaU) + sum(GammaI * GammaI)
    
    print part1, part2, part3
    return part1 + Lambd * (part2 + part3)

oldVal = 0
betaU = np.zeros(numU)
betaI = np.zeros(numI)
gammaU = [[]] * numU
gammaI = [[]] * numI
for u in range(numU):
    gammaU[u] = [0, 0, 0]
for i in range(numI):
    gammaI[i] = [5.0, 5.0, 5.0]

it = 0
while True:
    lastAlpha = alpha
    lastBetaU = list(betaU)
    lastBetaI = list(betaI)
    lastGammaU = list(gammaU)
    lastGammaI = list(gammaI)
    
    #----------------------
    start = time.time()
    #----------------------
    
    # Alpha stage
    alpha = 0
    for (u, i, Rui) in fastData:
        gu = gammaU[u]
        gi = gammaI[i]
        alpha += Rui - (betaU[u] + betaI[i] + np.dot(gu, gi))
    alpha = alpha / Ntrain
    
    #----------------------
    #end = time.time()
    #finished = end - start
    #print "Alpha time: ", finished
    #----------------------
    
    #----------------------
    #start = time.time()
    #----------------------

    # BetaU stage 
    betaU.fill(0)
    for (u, i, Rui) in fastData:
        gu = gammaU[u]
        gi = gammaI[i]
        betaU[u] += (Rui - (alpha + betaI[i] + np.dot(gu, gi)))
    betaU = betaU / (lambd + Iu)
        
    #----------------------
    #end = time.time()
    #finished = end - start
    #print "BetaU time: ", finished
    #----------------------
        
    #----------------------
    #start = time.time()
    #----------------------
        
    # BetaI stage 
    betaI.fill(0)
    for (u, i, Rui) in fastData:
        gu = gammaU[u]
        gi = gammaI[i]
        betaI[i] += (Rui - (alpha + betaU[u] + np.dot(gu, gi)))
    betaI = betaI / (lambd + Ii)
        
    #----------------------
    #end = time.time()
    #finished = end - start
    #print "BetaI time: ", finished
    #----------------------
    
    #----------------------
    #start = time.time()
    #----------------------

    # GammaU stage 
    for u in range(numU):
        gi = []
        y = []
        for (i, Rui) in uToRI[u]:
            gi.append(gammaI[i])
            y.append(Rui - (alpha + betaU[u] + betaI[i]))
                    
        #clf = SGDRegressor(n_iter = 100, alpha = 1)
        #clf.fit(gi, y)
        #thetas = clf.coef_

        #thetas, _, _, _ = np.linalg.lstsq(gi, y)
        #thetas, _, _ = scipy.optimize.fmin_l_bfgs_b(func, np.array(gammaU[u]).T, fprime, args = (np.array(gi), np.array(y).T, lambd))
        thetas = scipy.optimize.differential_evolution(func, (1., 5.), args = (np.array(gi), np.array(y).T, lambd))
        
        gammaU[u] = thetas
            
    #----------------------
    #end = time.time()
    #finished = end - start
    #print "GammaU time: ", finished
    #----------------------
        
    #----------------------
    #start = time.time()
    #----------------------
        
    # GammaI stage 
    for i in range(numI):
        gu = []
        y = []
        for (u, Rui) in iToRU[i]:
            gu.append(gammaU[u])
            y.append(Rui - (alpha + betaU[u] + betaI[i]))
            
        #clf = SGDRegressor(n_iter = 100, alpha = 1)
        #clf.fit(gu, y)
        #thetas = clf.coef_
            
        #thetas, _, _, _ = np.linalg.lstsq(gu, y)
        #thetas, _, _ = scipy.optimize.fmin_l_bfgs_b(func, np.array(gammaI[i]).T, fprime, args = (np.array(gu), np.array(y).T, lambd))
        thetas = scipy.optimize.differential_evolution(func, (1., 5.), args = (np.array(gu), np.array(y).T, lambd))
        gammaI[i] = thetas
    
    #----------------------
    #end = time.time()
    #finished = end - start
    #print "GammaI time: ", finished
    #----------------------
    
    #----------------------
    #start = time.time()
    #----------------------
    newVal = miniFunc(fastData, alpha, betaU, betaI, np.array(gammaU), np.array(gammaI), lambd)
    #----------------------
    end = time.time()
    finished = end - start
    print "miniFunc time: ", finished,  " --> Diff: ", (oldVal - newVal), newVal
    #----------------------

    if oldVal > 0 and oldVal < newVal:
        alpha = lastAlpha
        betaU = lastBetaU
        betaI = lastBetaI
        gammaU = lastGammaU
        gammaI = lastGammaI
        break
        
    it += 1
    if False:
        it = 0
        pickle.dump(alpha, open("/home/iizhaki/oasis/CSE255/Project2/assignment2/idan_predictions_Rating_a_TFC.pck", "wb"))
        pickle.dump(betaU, open("/home/iizhaki/oasis/CSE255/Project2/assignment2/idan_predictions_Rating_bu_TFC.pck", "wb"))
        pickle.dump(betaI, open("/home/iizhaki/oasis/CSE255/Project2/assignment2/idan_predictions_Rating_bi_TFC.pck", "wb"))
        pickle.dump(gammaU, open("/home/iizhaki/oasis/CSE255/Project2/assignment2/idan_predictions_Rating_gu_TFC.pck", "wb"))
        pickle.dump(gammaI, open("/home/iizhaki/oasis/CSE255/Project2/assignment2/idan_predictions_Rating_gi_TFC.pck", "wb"))
        pickle.dump(oldVal, open("/home/iizhaki/oasis/CSE255/Project2/assignment2/idan_predictions_Rating_val_TFC.pck", "wb"))
    oldVal = newVal
    
print alpha


    

    




---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-9-607c3a70e713> in <module>()
    100         #thetas, _, _, _ = np.linalg.lstsq(gi, y)
    101         #thetas, _, _ = scipy.optimize.fmin_l_bfgs_b(func, np.array(gammaU[u]).T, fprime, args = (np.array(gi), np.array(y).T, lambd))
--> 102         thetas = scipy.optimize.differential_evolution(func, (1., 5.), args = (np.array(gi), np.array(y).T, lambd))
    103 
    104         gammaU[u] = thetas

/oasis/scratch/iizhaki/temp_project/PV/python-virtualEnv3/lib/python2.7/site-packages/scipy/optimize/_differentialevolution.pyc in differential_evolution(func, bounds, args, strategy, maxiter, popsize, tol, mutation, recombination, seed, callback, disp, polish, init)
    199                                          callback=callback,
    200                                          disp=disp,
--> 201                                          init=init)
    202     return solver.solve()
    203 

/oasis/scratch/iizhaki/temp_project/PV/python-virtualEnv3/lib/python2.7/site-packages/scipy/optimize/_differentialevolution.pyc in __init__(self, func, bounds, args, strategy, maxiter, popsize, tol, mutation, recombination, seed, maxfun, callback, disp, polish, init)
    356         self.maxiter = maxiter or 1000
    357         self.maxfun = (maxfun or ((self.maxiter + 1) * popsize *
--> 358                                   np.size(self.limits, 1)))
    359 
    360         # population is scaled to between [0, 1].

/oasis/scratch/iizhaki/temp_project/PV/python-virtualEnv3/lib/python2.7/site-packages/numpy/core/fromnumeric.pyc in size(a, axis)
   2534     else:
   2535         try:
-> 2536             return a.shape[axis]
   2537         except AttributeError:
   2538             return asarray(a).shape[axis]

IndexError: tuple index out of range

In [15]:

    

print "Done"


    

    




Done

In [16]:

    

print (oldVal - newVal), newVal


    

    




0.0 455746.797566

In [25]:

    

testRest = np.array(list(parseTxt("/home/iizhaki/oasis/CSE255/Project2/assignment2/pairs_Rating.txt")))
myPredictions = open("/home/iizhaki/oasis/CSE255/Project2/assignment2/idan_predictions_Rating_" + str(lambd) + "_" + str(alpha) + "_" + str(oldVal) + "_TFC.txt", 'w')
myPredictions.write(str(testRest[0][0]) + '\n')

mse = 0
for currLine in testRest[1:]:
    u, i = currLine[0].split("-")
    if u in allUs:
        bu = betaU[allUs[u]]
        gu = gammaU[allUs[u]]
    else:
        bu = 0
        gu = [0, 0, 0]
    if i in allIs:
        bi = betaI[allIs[i]]
        gi = gammaI[allIs[i]]
    else:
        bi = 0
        gi = [0, 0, 0]
    p = alpha + bu + bi + np.dot(gu, gi)
    if p > 5.0:
        p = 5.0
    if p < 1.0:
        p = 1.0
    myPredictions.write(u + '-' + i + ',' + str(p) + '\n')

myPredictions.flush()
myPredictions.close()


    

In [ ]:

    




    

In [ ]:

    




    

In [18]:

    




    

    




[[ 1  1  1]
 [ 4  4  4]
 [ 9  9  9]
 [16 16 16]]

In [ ]: