FilmTrust_all_users.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i8h3I9xjfcz3"
      },
      "source": [
        "## Implementation on Film Trust Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3hSm6c-Bfcz6"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "from scipy.sparse import csc_matrix\n",
        "from scipy.stats.stats import pearsonr\n",
        "#data user\n",
        "df=pd.read_table('ratings.txt',sep=' ',names=['uid','iid','rating'])\n",
        "data=df.values\n",
        "df.head()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s_0x9bqmfcz8"
      },
      "outputs": [],
      "source": [
        "#Rating Matrix/// \n",
        "df['uid'] = df['uid'].astype(\"category\")\n",
        "df['iid'] = df['iid'].astype(\"category\")\n",
        "reviews = csc_matrix((df['rating'].astype(float), \n",
        "                         (df['uid'].cat.codes,\n",
        "                          df['iid'].cat.codes)))\n",
        "reviews.shape\n",
        "ratings_matrix = reviews.toarray()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k9hcYvZMfc0B"
      },
      "source": [
        "## TCFACO: Trust-aware collaborative Þltering method based on ant colony optimization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1LogWrOkfc0B"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "from scipy.sparse import csc_matrix\n",
        "from scipy.stats.stats import pearsonr\n",
        "#data user\n",
        "df=pd.read_table('ratings.txt',sep=' ',names=['uid','iid','rating'])\n",
        "data=df.values\n",
        "df.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aSRH5NoLfc0B"
      },
      "outputs": [],
      "source": [
        "#Rating Matrix\n",
        "\n",
        "df['uid'] = df['uid'].astype(\"category\")\n",
        "df['iid'] = df['iid'].astype(\"category\")\n",
        "reviews = csc_matrix((df['rating'].astype(float), \n",
        "                         (df['uid'].cat.codes,\n",
        "                          df['iid'].cat.codes)))\n",
        "reviews.shape\n",
        "ratings_matrix = reviews.toarray()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xpFkqnFefc0B"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from scipy.sparse import csc_matrix\n",
        "from scipy.stats.stats import pearsonr\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "from sklearn.metrics.pairwise import cosine_similarity\n",
        "import networkx as nx\n",
        "import sys\n",
        "np.set_printoptions(threshold=sys.maxsize)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ELhFoz_Tfc0C"
      },
      "outputs": [],
      "source": [
        "#Inputs\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from scipy.sparse import csc_matrix\n",
        "from scipy.stats.stats import pearsonr\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "import networkx as nx\n",
        "import sys\n",
        "np.set_printoptions(threshold=sys.maxsize)\n",
        "#Trust network\n",
        "G = nx.read_weighted_edgelist('trust.txt', delimiter=',')\n",
        "G.remove_nodes_from(nx.isolates(G));"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VDrC22dvfc0C"
      },
      "outputs": [],
      "source": [
        "##define function\n",
        "# find next node, define a function\n",
        "def ChooseNextNode(sim,xj,current_node,Select_users,visitednodes):\n",
        "    next_node=1\n",
        "    TH=2*np.min(1/sim[:,xj])\n",
        "    for i in range(len(Select_users)):\n",
        "        for j in range(len(visitednodes)):\n",
        "            if int(Select_users[i,0])!= int(visitednodes[j]):\n",
        "                s=int(Select_users[i,0])\n",
        "                if sim[s,xj]!= 0:\n",
        "                   Pj=1/sim[s,xj]     \n",
        "                   if Pj<TH:\n",
        "                     if s !=current_node: \n",
        "                       next_node=s\n",
        "    return next_node"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xqa5qqBBfc0C"
      },
      "outputs": [],
      "source": [
        "## define vars\n",
        "num_users=len(df['uid'].unique())\n",
        "dau=np.zeros(num_users)\n",
        "nodes=G.nodes()\n",
        "dis=[]\n",
        "k=1\n",
        "Similarity = np.ones(num_users)*-1\n",
        "Tau= np.zeros(num_users)   \n",
        "Wau= np.zeros(num_users) \n",
        "Select_users= np.zeros((num_users,4))\n",
        "sim=np.random.random((num_users,num_users)) \n",
        "Q=1 #is a constant         \n",
        "alpha=1;        # Phromone Exponential Weight\n",
        "beta=1;         # Heuristic Exponential Weight\n",
        "nA=3;\n",
        "nIter=1;\n",
        "ku=3;\n",
        "xj=7\n",
        "tau=np.zeros(nA)\n",
        "r=np.zeros(nA)\n",
        "estimated_r=np.zeros(nA)\n",
        "next_node=0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iU3cCTs0fc0C"
      },
      "outputs": [],
      "source": [
        "dmax=0\n",
        "ListTrueRating=[]\n",
        "listpredict=[]\n",
        "\n",
        "#Target user\n",
        "for Target_user in range(20):\n",
        "    ## Step I: Selecting some users using rating and trust information\n",
        "    UserId = int(data[Target_user,1])\n",
        "    #1.Compute similarity values between the target user 𝑎 and the others using\n",
        "\n",
        "    # 𝑆𝑈 =Select a set of users where there similarities to 𝑎 are higher than \n",
        "    for i in range(num_users):\n",
        "            if  i!=UserId:\n",
        "                a_r= ratings_matrix[UserId ,:]\n",
        "                u_r= ratings_matrix[i ,:]\n",
        "                cor=pearsonr(a_r,u_r)\n",
        "                Similarity[i,]=cor[0]\n",
        "                a=str(UserId) \n",
        "                u=str(i) \n",
        "                if a in nodes and u in nodes : \n",
        "\n",
        "                #eq(6)\n",
        "                    a_r= ratings_matrix[UserId ,:]\n",
        "                    u_r= ratings_matrix[i ,:]\n",
        "                    cor=pearsonr(a_r,u_r)\n",
        "                    Similarity[i,]=cor[0]\n",
        "\n",
        "                #eq(5)\n",
        "                    for g in nx.connected_component_subgraphs(G):\n",
        "                        if len(dis)>90 and len(dis)<91:\n",
        "                            dis.append(nx.average_shortest_path_length(g))\n",
        "                            dmax=max(dis)      \n",
        "\n",
        "                #eq(4)   \n",
        "                    try:\n",
        "                     dau[i]=nx.shortest_path_length(G,a,u) \n",
        "                     Tau[i]=(dmax-dau[i]+1)/dmax\n",
        "                    except nx.NetworkXNoPath:\n",
        "                     Tau[i]=0\n",
        "                #eq(3) \n",
        "                if Similarity[i]+Tau[i] !=0 and Similarity[i]*Tau[i]!=0:\n",
        "                   Wau[i]=(2*Similarity[i]*Tau[i])/ (Similarity[i]+Tau[i])\n",
        "                elif Similarity[i]==0 and Tau[i]!=0:\n",
        "                   Wau[i]= Tau[i]\n",
        "                elif Similarity[i]!=0 and Tau[i]==0:\n",
        "                   Wau[i]= Similarity[i]\n",
        "\n",
        "                #selet users who their similarities to the target user is higher than Theta\n",
        "                Theta=0.2\n",
        "                if Wau[i]>Theta:\n",
        "                   Select_users[i,0]=data[i,0]\n",
        "                   Select_users[i,1]=data[i,1]\n",
        "                   Select_users[i,2]=data[i,2]\n",
        "                   Select_users[i,3]=Wau[i]\n",
        "\n",
        "    SU = Select_users[[i for i, x in enumerate(Select_users) if x.any()]] \n",
        "    ## Step II: Selecting top-users with ant colony and computes the weight degree\n",
        "    #create graph of select_users\n",
        "    n=len(SU)\n",
        "    rv= np.zeros(n)  \n",
        "    A = [[0] * n] * n \n",
        "    A = np.array(A)\n",
        "    for i in range(n):\n",
        "      for j in range(n):\n",
        "          A[i,j]=100*sim[i,j]\n",
        "    A=A/100\n",
        "    G2 = nx.from_numpy_matrix(np.array(A)) \n",
        "    color_map = []\n",
        "    for node in G2:\n",
        "        if node ==Target_user:\n",
        "            color_map.append('red')\n",
        "        else: color_map.append('blue')      \n",
        "    ## Initialize pheromone values\n",
        "    nIter=50\n",
        "    users=[]\n",
        "    pheromone=[]\n",
        "    for i in range(nIter):\n",
        "        # place ants randomly\n",
        "        Q=1    \n",
        "        for ant in range(nA):\n",
        "            visitednodes= np.zeros(ku)     \n",
        "            #find current node of ant\n",
        "            current_node=np.random.randint(0,len(Select_users)) \n",
        "            visitednodes[0] = current_node\n",
        "            for k in range(1,ku):\n",
        "                # Choose the next unvisited user 𝑢 using (7)\n",
        "                nextnode=ChooseNextNode(sim,xj,current_node,Select_users,visitednodes)\n",
        "                current_node=nextnode\n",
        "                visitednodes[k]= current_node\n",
        "            #print(visitednodes)\n",
        "            #Predict missing rating of active user using top using selected user\n",
        "            for i in range(len(visitednodes)):\n",
        "               sum1=0\n",
        "               sum2=0\n",
        "               if visitednodes[i]!=0:\n",
        "                  Iu=len(Select_users) \n",
        "                  rv=data[int(visitednodes[i]),2]\n",
        "                  #eq(11) \n",
        "                  for i in range(len(visitednodes)):\n",
        "                      sum1=0\n",
        "                      sum2=0\n",
        "                      if visitednodes[i]!=0:\n",
        "                         rv=Select_users[i,2] \n",
        "                         sum1=sum1+sim[i,xj]*rv\n",
        "                         sum2=sum2+sim[i,xj]\n",
        "                         estimated_r=sum1/sum2\n",
        "                         ru=Select_users[xj,2]\n",
        "                         #eq(12) \n",
        "                         fitness=np.abs(estimated_r-ru)/Iu \n",
        "            #eq(7)             \n",
        "            p=np.mean(fitness)\n",
        "            #eq(10) \n",
        "            tau[ant]=(1-p)*tau[ant]+Q\n",
        "            #print(tau[ant])\n",
        "            users.append(visitednodes)      \n",
        "            pheromone.append(tau[ant]) \n",
        "    ##Step III: Prediction\n",
        "    top_k_users=[]\n",
        "    #Sort the users based on their pheromone values in decreasing order\n",
        "    pheromone=np.asarray(pheromone)\n",
        "    idx=pheromone.argsort()[::-1][:n]\n",
        "\n",
        "    ##Choose the top-k users with highest pheromones as final user\n",
        "    top=5\n",
        "    for k in range(top):\n",
        "        top_k_users.append(users[idx[k]])\n",
        "\n",
        "    ##Predict unknown rating values for a  \n",
        "    rating_user=[];\n",
        "    for i in range(top):\n",
        "         rating_user.append(data[int(np.asarray(top_k_users[i][0]))][2])\n",
        "\n",
        "    rating_predict=np.mean(rating_user)   \n",
        "    listpredict.append(rating_predict)\n",
        "    rating_true=data[Target_user,2]\n",
        "    ListTrueRating.append(rating_true)\n",
        "  \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xacI3p97fc0D"
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import mean_absolute_error\n",
        "MAE=mean_absolute_error(ListTrueRating, listpredict) \n",
        "print('MAE TCFACO=',MAE)\n",
        "from sklearn.metrics import mean_squared_error\n",
        "RMSE=mean_squared_error(ListTrueRating, listpredict, squared=False)\n",
        "print('RMSE TCFACO=',RMSE)"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.6"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}