コード例 #1
0
ファイル: matrix.py プロジェクト: batlac/ALAM
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)
コード例 #2
0
ファイル: mainb.py プロジェクト: batlac/ALAM
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)
コード例 #3
0
ファイル: mainb.py プロジェクト: batlac/ALAM
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()
コード例 #4
0
ファイル: mainb.py プロジェクト: batlac/ALAM
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)
コード例 #5
0
ファイル: fonctions.py プロジェクト: superprism/INSA_ALAM
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
コード例 #6
0
ファイル: fonctions.py プロジェクト: superprism/INSA_ALAM
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
コード例 #7
0
ファイル: mainb.py プロジェクト: batlac/ALAM
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