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 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)