#-*- coding：utf-8

import sys

sys.path.append("svdRec.py")

import svdRec

from numpy import *

from numpy import linalg as la

# U, Sigma, VT = linalg.svd([[1, 1], [7, 7]])

# print(U)

# print(Sigma)

# print(VT)

# Data = svdRec.loadExData()

# U, Sigma, VT = linalg.svd(Data)

# print(Sigma)

#

# Sig3 = mat([[Sigma[0], 0, 0], [0, Sigma[1], 0], [0, 0, Sigma[2]]])

# res = U[:, :3]*Sig3*VT[:3, :]

# print("res:")

# print(res)

#

# myMat = mat(svdRec.loadExData())

# ecl = svdRec.ecludSim(myMat[:, 0], myMat[:, 4])

# print("ecl:")

# print(ecl)

# cos = svdRec.cosSim(myMat[:, 0], myMat[:, 4])

# print("cos:")

# print(cos)

# pears = svdRec.pearsSim(myMat[:, 0], myMat[:, 4])

# print("pears:")

# print(pears)

# myMat = mat(svdRec.loadExData())

# myMat[0, 1] = myMat[0, 0] = myMat[1, 0] = myMat[2, 0] = 4

# myMat[3, 3] = 2

# print("myMat:")

# print(myMat)

#

# tuiJian = svdRec.recommend(myMat, 2)

# print("tuiJian:")

# print(tuiJian)

#

# tuiJian1 = svdRec.recommend(myMat, 2, simMeas = svdRec.ecludSim)

# print("tuiJian1:")

# print(tuiJian1)

#

# tuiJian2 = svdRec.recommend(myMat, 2, simMeas = svdRec.pearsSim)

# print("tuiJian2:")

# print(tuiJian2)

# myMat = mat(svdRec.loadExData2())

# U, Sigma, VT = la.svd(mat(svdRec.loadExData2()))

# print(Sigma)

#

# Sig2 = Sigma**2

# total = sum(Sig2)

# total9 = total*0.9

# print("total9:")

# print(total9)

#

# total3 = sum(Sig2[:3])

# print("total3:")

# print(total3)

# svdRes = svdRec.recommend(myMat, 1, estMethod = svdRec.svdEst)

# print("svdRes:")

# print(svdRes)

originalMat = svdRec.imgCompress(2)

print(originalMat)

print("over!!!")

'''

Created on Mar 8, 2011

@author: Peter

'''

from numpy import *

from numpy import linalg as la

def loadExData():

    return[[0, 0, 0, 2, 2],

           [0, 0, 0, 3, 3],

           [0, 0, 0, 1, 1],

           [1, 1, 1, 0, 0],

           [2, 2, 2, 0, 0],

           [5, 5, 5, 0, 0],

           [1, 1, 1, 0, 0]]

def loadExData2():

    return[[0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 5],

           [0, 0, 0, 3, 0, 4, 0, 0, 0, 0, 3],

           [0, 0, 0, 0, 4, 0, 0, 1, 0, 4, 0],

           [3, 3, 4, 0, 0, 0, 0, 2, 2, 0, 0],

           [5, 4, 5, 0, 0, 0, 0, 5, 5, 0, 0],

           [0, 0, 0, 0, 5, 0, 1, 0, 0, 5, 0],

           [4, 3, 4, 0, 0, 0, 0, 5, 5, 0, 1],

           [0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 4],

           [0, 0, 0, 2, 0, 2, 5, 0, 0, 1, 2],

           [0, 0, 0, 0, 5, 0, 0, 0, 0, 4, 0],

           [1, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0]]

def ecludSim(inA,inB):

    return 1.0/(1.0 + la.norm(inA - inB))

def pearsSim(inA,inB):

    if len(inA) < 3 : return 1.0

    return 0.5+0.5*corrcoef(inA, inB, rowvar = 0)[0][1]

def cosSim(inA,inB):

    num = float(inA.T*inB)

    denom = la.norm(inA)*la.norm(inB)

    return 0.5+0.5*(num/denom)

def standEst(dataMat, user, simMeas, item):

    n = shape(dataMat)[1]

    simTotal = 0.0; ratSimTotal = 0.0

    for j in range(n):

        userRating = dataMat[user,j]

        if userRating == 0: continue

        # test0 = dataMat[:,item].A>0

        # test1 = dataMat[:,j].A>0

        # test2 = logical_and(dataMat[:,item].A>0, dataMat[:,j].A>0)

        overLap = nonzero(logical_and(dataMat[:,item].A>0, dataMat[:,j].A>0))[0]

        if len(overLap) == 0: similarity = 0

        else: similarity = simMeas(dataMat[overLap,item], dataMat[overLap,j])

        print('the %d and %d similarity is: %f' % (item, j, similarity))

        simTotal += similarity

        ratSimTotal += similarity * userRating

    if simTotal == 0: return 0

    else: return ratSimTotal/simTotal

def svdEst(dataMat, user, simMeas, item):

    n = shape(dataMat)[1]

    simTotal = 0.0; ratSimTotal = 0.0

    U,Sigma,VT = la.svd(dataMat)

    Sig4 = mat(eye(4)*Sigma[:4]) #arrange Sig4 into a diagonal matrix

    xformedItems = dataMat.T * U[:,:4] * Sig4.I  #create transformed items

    for j in range(n):

        userRating = dataMat[user,j]

        if userRating == 0 or j==item: continue

        similarity = simMeas(xformedItems[item,:].T, xformedItems[j,:].T)

        print('the %d and %d similarity is: %f' % (item, j, similarity))

        simTotal += similarity

        ratSimTotal += similarity * userRating

    if simTotal == 0: return 0

    else: return ratSimTotal/simTotal

def recommend(dataMat, user, N=3, simMeas=cosSim, estMethod=standEst):

    unratedTest = nonzero(dataMat[user,:].A==0)

    unratedItems = nonzero(dataMat[user,:].A==0)[1]#find unrated items

    if len(unratedItems) == 0: return 'you rated everything'

    itemScores = []

    for item in unratedItems:

        estimatedScore = estMethod(dataMat, user, simMeas, item)

        itemScores.append((item, estimatedScore))

        # testSort = sorted(itemScores, key=lambda jj: jj[1], reverse=True)[:N]

    return sorted(itemScores, key=lambda jj: jj[1], reverse=True)[:N]

def printMat(inMat, thresh=0.8):

    for i in range(32):

        for k in range(32):

            if float(inMat[i,k]) > thresh:

                print(1),

            else: print(0),

        print('')

def imgCompress(numSV=3, thresh=0.8):

    myl = []

    for line in open('0_5.txt').readlines():

        newRow = []

        for i in range(32):

            newRow.append(int(line[i]))

        myl.append(newRow)

    myMat = mat(myl)

    print("****original matrix******")

    printMat(myMat, thresh)

    U,Sigma,VT = la.svd(myMat)

    SigRecon = mat(zeros((numSV, numSV)))

    for k in range(numSV):#construct diagonal matrix from vector

        SigRecon[k,k] = Sigma[k]

    reconMat = U[:,:numSV]*SigRecon*VT[:numSV,:]

    print("****reconstructed matrix using %d singular values******" % numSV)

    printMat(reconMat, thresh)