def tps_calc_m1(k):
t0 = time.clock()
users, items = ld.check_data("ml-100k/u.data")
mat_u_i = ld.matrice_user_item("ml-100k/u.data", users, items)
mat_cm = ld.remplissage_moyenne_mixte(mat_u_i)
ta = 0 # time.clock() - t0
tps = []
ks = []
for i in k:
t1 = time.clock()
m = mmat.simplifier(mat_cm, i)
t2 = time.clock()
tps += [t2 - t1 + ta]
ks += [i]
return (ks, tps)
def f1():
"""
Affichage des matrices remplies
"""
# Compte le nombre d'users et d'items
users, items = ld.check_data("ml-100k/u.data")
# Construction matrice user/items de u.data
mat_u_i = ld.matrice_user_item("ml-100k/u.data", users, items)
# Différentes approximations par moyennes
mat_cu = ld.remplissage_moyenne_user(mat_u_i)
mat_cf = ld.remplissage_moyenne_film(mat_u_i)
mat_cm = ld.remplissage_moyenne_mixte(mat_u_i)
m = mmat.simplifier(mat_cm, 10)
# Dessin des graphes
plt.imshow(np.dot(m[0], m[1]), interpolation="none", vmin=0, vmax=5, cmap="Reds")
plt.title("Suggestion avec k=10 pour le remplissage mixte")
plt.axis([0, 1681, 942, 0])
plt.colorbar()
plt.xlabel("Film")
plt.ylabel("Utilisateur")
plt.show()
def f3(ran, mode=0):
"""
Permet de calculer les MAE (SVD) pour un range de k et d'afficher le graphe
"""
file_approx = "ml-100k/u1.base"
file_test = "ml-100k/u1.test"
dim1 = ld.check_data(file_approx) # Dim de base
dim2 = ld.check_data(file_test) # Dim de test
# Matrice des predictions
mui = ld.matrice_user_item(file_approx, dim1[0], dim1[1]) # Matrice user item de la base
if mode == 0:
mui_r = ld.remplissage_moyenne_user(mui) # remplissage
elif mode == 1:
mui_r = ld.remplissage_moyenne_film(mui) # remplissage
else:
mui_r = ld.remplissage_moyenne_mixte(mui) # remplissage
Xk, Yk = mmat.simplifier(mui_r, max(ran)) # Matrices des predictions
# Matrice du test
mui_t = ld.matrice_user_item(file_test, dim1[0], dim1[1])
# Calcul des mae
maes = []
print np.array(list(reversed(ran)))
for k in reversed(ran):
Xk, Yk = mmat.reduire(Xk, Yk, k) # Matrices des predictions
maes += [fn.mae(mui_t, Xk, Yk)]
print maes
print maes
return (np.array(list(reversed(ran))), maes)
def add_user(nfile_rate) :
#######Retrieve film rated in nfile_rate
f = open(nfile_rate, "r")
t = f.readlines()
f.close()
rated = []
for l in t :
s = l.split("\t")
if len(s) > 1 :
tup = (s[0], s[1][:-1])
rated += [tup]
######Find the corresponding indexes
m = np.genfromtxt("ml-100k/u.item", dtype=[('myint','i8'),('mystring','S100')],
delimiter = "|")
indexes = []
for i in xrange(len(m)) :
for j in xrange(len(rated)) :
if(m[i][1] == rated[j][0]) :
indexes += [m[i][0]]
######Ajout des index au fichier
f_w = "ml-100k/u.data"
u,i = ld.check_data(f_w)
user = u + 1
f = open(f_w, "a")
for i in xrange(len(indexes)) :
f.write( "%d\t%d\t%d\t%d\n"%(user, indexes[i],
(int) (rated[i][1]), time.clock() ) )
f.close()
print "ADDED USER", ((int) (user)), "WITH", len(rated), "MOVIE RATED"
return user
def approxXY(k, l, nb_iter):
"""
Retourne les matrices X et Y de feature des users et des items
ainsi que la MAE associée.
:param k: degré de réduction de l'approximation
:param l: valeur lambda de contrôle des normes de X et Y
:param nb_iter: nombre d'itérations de l'algorithme d'approximation
On alterne la minimisation sur X et Y, nb_iter fois.
"""
file_approx = "ml-100k/u1.base"
file_test = "ml-100k/u1.test"
#Construction matrice user/items d'apprentissage
users, items = ld.check_data(file_approx)
R = ld.matrice_user_item(file_approx, users, items)
#Construction matrice user/items de test
Rtest = ld.matrice_user_item(file_test, users, items)
MAE = []
m, n = R.shape
X = np.ones((m,k))
Y = np.ones((k,n))
W = np.zeros(R.shape)
#Creation de W
for a in xrange(m):
for b in xrange(n):
if R[a,b]>0 :
W[a,b] = 1
#Parcours des itérations
for j in xrange(nb_iter):
for u in xrange(m):
XdW = np.dot(Y,np.diag(W[u]))
X[u,:] = ( np.linalg.solve( np.dot(XdW,Y.T)+l*np.eye(k), np.dot(XdW,R[u,:].T)) ).T
print ("Xu approximé")
for i in xrange(n):
YdW = np.dot(X.T,np.diag(W[:,i]))
Y[:,i] = (np.linalg.solve(np.dot(YdW,X)+l*np.eye(k), np.dot(YdW,R[:,i]))).T
print ("Yi approximé")
MAE.append(fct.mae(Rtest, X, Y))
print ("La MAE vaut " + str(MAE)+ " a l'iteration numero " + str(j))
return (X,Y,1)
def mae( file1ap, file2te, k, remplissage = "users") :
#Dimension des matrices
d1 = ld.check_data(file1ap)
#Matrice user-item du test
mui_t = ld.matrice_user_item( file2te, d1[0], d1[1] )
#Matrice des suggestions
mui_a = ld.matrice_user_item( file1ap, d1[0], d1[1] ) #Mat u-i
if remplissage == "users" :
muif_a = ld.remplissage_moyenne_user(mui_a) #Remplissage
else :
muif_a = ld.remplissage_moyenne_film(mui_a)
maes = []
for i in xrange(1,k) :
dec = mmat.simplifier(muif_a,i) #Decomposition k
msug = np.dot( dec[0], np.dot( dec[1], dec[2] )) #Matrice sugs
c,s = 0.0,0.0
for i in xrange(d1[1]) :
for u in xrange(d1[0]) :
if mui_t[u,i] <> 0 :
c += 1
s += abs( mui_t[u,i] - msug[u,i] )
maes += [s/c]
return maes
def maes( file1ap, file2te, k, remplissage = "users") :
#Dimension des matrices
d1 = ld.check_data(file1ap)
#Matrice user-item du test
mui_t = ld.matrice_user_item( file2te, d1[0], d1[1] )
#Matrice des suggestions
mui_a = ld.matrice_user_item( file1ap, d1[0], d1[1] )
if remplissage == "users" :
muif_a = ld.remplissage_moyenne_user(mui_a)
else :
muif_a = ld.remplissage_moyenne_film(mui_a)
mae = []
v1 = np.mat(np.ones(d1[0]))
v2 = np.mat(np.ones(d1[1]))
for i in xrange(1,k) :
dec_a = mmat.simplifier(muif_a, i) #Calcul décomposition à i
m_sug = np.dot(dec_a[0], np.dot(dec_a[1], dec_a[2]) ) #Matrice suggestions
#On calcule la mae
m = abs(m_sug - mui_t)
mae += [np.dot(v1, np.dot(m, v2.T))[0,0]/(d1[0]*d1[1])]
return mae
def f2(k):
"""
Permet de sauvegarder sous forme de pickle les matrices de la
decomposition au degré k par SVD
"""
nfile = "decomp_udata_k" + str(k)
# Approximation bas rang avec k = 30
# Compte le nombre d'users et d'items
users, items = ld.check_data("ml-100k/u.data")
# Construction matrice user/items
mat_u_i = ld.matrice_user_item("ml-100k/u.data", users, items)
mat_r = ld.remplissage_moyenne_mixte(mat_u_i)
X, Y = mmat.simplifier(mat_u_i, k)
mmat.save_decomposition(X, Y, nfile)
return nfile