RepScoreCode.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'dataV2'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-efee695386bd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mdataV2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mmath\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mexp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'dataV2'"
     ]
    }
   ],
   "source": [
    "from dataV2 import *\n",
    "from math import exp\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os.path\n",
    "from os import path\n",
    "from scipy.stats import norm\n",
    "import math\n",
    "import datetime\n",
    "from dateutil.parser import parse\n",
    "\n",
    "\n",
    "def create_user_reps(uberDict, csvPath=None):\n",
    "    \"\"\"When this function is called, if there is no existing UserRepScore.csv, will create and save a DataFrame with the columns\n",
    "    Users, Score, Questions, Influence, Index, and LastDate. Each row corresponds to a unique UserID and their influence, score, and\n",
    "    the 30 most recent question scores. This function also gets rid of any user that has not answered a question for 60 days, so that\n",
    "    their scores do not affect the standard distribution of scores.\"\"\"\n",
    "    if path.exists(csvPath):\n",
    "        user_rep = CSV_to_userid(csvPath)\n",
    "\n",
    "    else:\n",
    "        user_rep = pd.DataFrame(\n",
    "            columns=['Users', 'Score', 'Questions', 'Influence', 'Index', 'LastDate'] + [str(x) for x in range(30)])\n",
    "    date = datetime.datetime.today().date()\n",
    "\n",
    "    for article_sha256 in uberDict.keys():\n",
    "\n",
    "        for question_num in uberDict[article_sha256]['quesData'].keys():\n",
    "            # TODO make this not hardCoded, it's identical to data_utils get quesiton userid but we had importerror\n",
    "            # users_q = data[article_num][question_num][1][1][0]\n",
    "            users_q = get_question_userid(uberDict, article_sha256, question_num)\n",
    "\n",
    "            for ids in users_q:\n",
    "                if ids == 0:\n",
    "                    continue\n",
    "                if ids not in user_rep.loc[:, 'Users'].tolist():\n",
    "                    user_rep = user_rep.append(pd.Series([ids, 1, 1, 1, 0, date] + list(np.zeros(30)),\n",
    "                                                         index=['Users', 'Score', 'Questions', 'Influence',\n",
    "                                                                'Index', 'LastDate'] + [str(x) for x in range(30)]),\n",
    "                                               ignore_index=True)\n",
    "\n",
    "    for id in user_rep.loc[:, 'Users'].tolist():\n",
    "        if (date - (user_rep.loc[user_rep['Users'] == id, 'LastDate'].iloc[0])).days > 60:\n",
    "            user_rep = user_rep[user_rep.Users != id]\n",
    "\n",
    "    return user_rep\n",
    "\n",
    "\n",
    "def do_rep_calculation_nominal(userID, answers, answer_choice, highlight_answer, hlUsers, starts, ends, article_length,\n",
    "                               user_rep_df,\n",
    "                               checkListScale=1):\n",
    "    \"\"\"Using the same DataFrame of UserIDs, Rep Scores, and number of questions, changes the values of the DataFrame\n",
    "    such that if the user in the list of UserIDs gets their answer right, 1 is added to their score, and 0 if they are\n",
    "    wrong.\"\"\"\n",
    "    if type(answer_choice) == str or type(highlight_answer) == str or len(highlight_answer) == 0:\n",
    "        return 0\n",
    "\n",
    "    checked = zip(answers, userID)\n",
    "    highlight_answer_array = np.zeros(article_length)\n",
    "    winners = []\n",
    "\n",
    "    for t in checked:\n",
    "        user = t[1]\n",
    "        answer = t[0]\n",
    "\n",
    "        if (answer == answer_choice):\n",
    "\n",
    "            do_math(user_rep_df, user, checkListScale)\n",
    "            winners.append(user)\n",
    "        else:\n",
    "            do_math(user_rep_df, user, 0)\n",
    "    for h in highlight_answer:\n",
    "        highlight_answer_array[h] = 1\n",
    "\n",
    "    for x in userID:\n",
    "        user_highlight = np.zeros(article_length)\n",
    "        for user_h, user_s, user_e in zip(hlUsers, starts, ends):\n",
    "            incrementer = user_s\n",
    "            if user_h == x:\n",
    "                while incrementer <= user_e:\n",
    "                    user_highlight[incrementer] = 1\n",
    "                    incrementer += 1\n",
    "        score = 1 - np.sum(np.absolute(highlight_answer_array - user_highlight)) / article_length\n",
    "        do_math(user_rep_df, x, score)\n",
    "\n",
    "\n",
    "def gaussian_mean(answers):\n",
    "    \"\"\"This function is used to find the gaussian mean for calculating the reward for a user who answered\n",
    "     ordinal questions.\"\"\"\n",
    "    result = []\n",
    "    std = np.std(answers)\n",
    "    mean = np.mean(answers)\n",
    "    total = 0\n",
    "    for i in answers:\n",
    "        gauss = 1 / (std * np.sqrt(2 * np.pi)) * np.exp(-0.5 * ((i - mean) / std) ** 2)\n",
    "        result.append(i * (gauss * 10) ** 2)\n",
    "        total += (gauss * 10) ** 2\n",
    "\n",
    "    return sum(result) / total\n",
    "\n",
    "\n",
    "def do_rep_calculation_ordinal(userID, answers, answer_aggregated, num_of_choices, highlight_answer, hlUsers, starts,\n",
    "                               ends,\n",
    "                               article_length, user_rep_df):\n",
    "    \"\"\"Using the same dataframe of userIDs, rep scores, and number of questions, changes the vals of the dataframe\n",
    "    such that the they receive the distance calculated by gaussian_mean function from the average answer chosen as a ratio of 0 to 1,\n",
    "    and that is added to their rep score.\"\"\"\n",
    "\n",
    "    if type(answer_aggregated) == str or type(highlight_answer) == str:\n",
    "        return 0\n",
    "    checked = zip(answers, userID)\n",
    "    highlight_answer_array = np.zeros(article_length)\n",
    "    score_dict = {}\n",
    "\n",
    "    answer_choice = gaussian_mean(answers)\n",
    "\n",
    "    for h in highlight_answer:\n",
    "        highlight_answer_array[h] = 1\n",
    "\n",
    "    for t in range(len(userID)):\n",
    "        user = userID[t]\n",
    "        answer = answers[t]\n",
    "\n",
    "        points = (1 - abs(answer_choice - answer) / num_of_choices)\n",
    "        do_math(user_rep_df, user, points)\n",
    "        score_dict[user] = points\n",
    "\n",
    "    for x in userID:\n",
    "        points = score_dict[x]\n",
    "        user_highlight = np.zeros(article_length)\n",
    "\n",
    "        for user_h, user_s, user_e in zip(hlUsers, starts, ends):\n",
    "            incrementer = user_s\n",
    "            if user_h == x:\n",
    "                while incrementer <= user_e:\n",
    "                    user_highlight[incrementer] = 1\n",
    "                    incrementer += 1\n",
    "\n",
    "        score = points * (1 - np.sum(np.absolute(highlight_answer_array - user_highlight)) / article_length)\n",
    "\n",
    "        do_math(user_rep_df, x, score)\n",
    "\n",
    "\n",
    "def getUserHighlights(userId, hlUsers, starts, ends, length):\n",
    "    \"\"\"Gets the UserHighlights for a specific user.\"\"\"\n",
    "    hlUsers = np.array(hlUsers)\n",
    "    starts = np.array(starts)\n",
    "    ends = np.array(ends)\n",
    "    userMask = hlUsers == userId\n",
    "\n",
    "    uStarts = starts[userMask]\n",
    "    uEnds = ends[userMask]\n",
    "    hlArr = startsToBool(uStarts, uEnds, length)\n",
    "    return hlArr\n",
    "\n",
    "\n",
    "def startsToBool(starts, ends, length):\n",
    "    \"\"\"Turns highlights into boolean lists\"\"\"\n",
    "    out = np.zeros(length)\n",
    "    for i in range(len(starts)):\n",
    "        for x in range(starts[i], ends[i]):\n",
    "            out[x] = 1\n",
    "    return out\n",
    "\n",
    "\n",
    "def checkDuplicates(answers, userID, starts, ends, article_length):\n",
    "    checked = []\n",
    "    int_users = {}\n",
    "    # Changed this to just starts, ends; guaranteed no duplicates of answers or userID\n",
    "    for i in range(len(starts)):\n",
    "        if [starts[i], ends[i]] not in checked:\n",
    "            checked.append([starts[i], ends[i]])\n",
    "    for x in checked:\n",
    "        article_array = np.zeros(article_length).tolist()\n",
    "        if x[0] not in int_users.keys():\n",
    "\n",
    "            article_array[x[2]:x[3] + 1] = np.ones(x[3] - x[2] + 1).tolist()\n",
    "            int_users[x[0]] = article_array\n",
    "        else:\n",
    "            article_array = int_users[x[0]]\n",
    "            article_array[x[2]:x[3] + 1] = np.ones(x[3] - x[2] + 1).tolist()\n",
    "            int_users[x[0]] = article_array\n",
    "\n",
    "    return checked, int_users\n",
    "\n",
    "\n",
    "def do_math(data, userID, reward):\n",
    "    \"\"\"This function takes in the points added to one user and updates the UserRep DataFrame to update that one user's score\n",
    "    using the equations set for calculating reputation.\"\"\"\n",
    "    if userID == 0:\n",
    "        return\n",
    "    oldlast30mean = np.mean(np.array(data.loc[data['Users'] == userID, [str(x) for x in range(30)]]))\n",
    "\n",
    "    user = data.loc[data['Users'] == userID]\n",
    "\n",
    "    data.loc[data['Users'] == userID, 'LastDate'] = datetime.datetime.today().date()\n",
    "    index = data.loc[data['Users'] == userID, 'Index'].tolist()[0]\n",
    "    data.loc[data['Users'] == userID, str(int(index))] = reward\n",
    "\n",
    "    last30 = data.loc[data['Users'] == userID, [str(x) for x in range(30)]]\n",
    "    last30mean = np.mean(np.array(last30.dropna(axis=1)))\n",
    "\n",
    "    if (index < 29):\n",
    "        data.loc[data['Users'] == userID, 'Index'] = index + 1\n",
    "    else:\n",
    "        data.loc[data['Users'] == userID, 'Index'] = 0\n",
    "    n = float(user['Questions'].iloc[0])\n",
    "    if (n > 29):\n",
    "        r = (float(user['Score'].iloc[0]) - oldlast30mean * .5) * 2\n",
    "\n",
    "    else:\n",
    "        r = float(user['Score'].iloc[0])\n",
    "\n",
    "    points = r * n\n",
    "    points = points + reward\n",
    "\n",
    "    n = n + 1\n",
    "    data.loc[data['Users'] == userID, 'Questions'] = n\n",
    "\n",
    "    if n > 29:\n",
    "        data.loc[data['Users'] == userID, 'Score'] = (points / n) * .5 + last30mean * .5\n",
    "    else:\n",
    "\n",
    "        data.loc[data['Users'] == userID, 'Score'] = (points / n)\n",
    "\n",
    "    influence, data = get_user_rep(userID, data, True)\n",
    "    userid_to_CSV(data)\n",
    "\n",
    "\n",
    "def calc_influence(data, userID):\n",
    "    \"\"\"Taking in a list of UserID's, this will take the repuation score of each User and output a list of their influence\n",
    "    based on their reputation score.\"\"\"\n",
    "    return_vals = list()\n",
    "    for u in userID:\n",
    "        r = data.loc[data['Users'] == u]['Score']\n",
    "        inf = 2 / (1 + exp(-r + 5))\n",
    "        return_vals.append(inf)\n",
    "    return return_vals\n",
    "\n",
    "\n",
    "def user_rep_task(uberDict, task_csv, user_rep_df):\n",
    "    \"\"\"This is the function every time agreement is calculated. To use, input the master data structure, the agreed upon\n",
    "    answers csv, and the pre-existing user_rep dataframe created by function create_user_reps.\"\"\"\n",
    "\n",
    "    agreement_output = pd.read_csv(task_csv)\n",
    "    for i in agreement_output.itertuples():\n",
    "        article_sha = i[2]\n",
    "        agreement = i[9]\n",
    "        task_num = i[3]\n",
    "        question_num = i[6]\n",
    "        question_type = i[8]\n",
    "        highlights = i[12]\n",
    "        if highlights == 'L' or highlights == 'M' or highlights == 'U':\n",
    "            None\n",
    "        else:\n",
    "\n",
    "            highlights = get_indices_hard(i[12])\n",
    "        num_of_users = i[16]\n",
    "        users = get_question_userid(uberDict, task_num, question_num)\n",
    "        answers = get_question_answers(uberDict, task_num, question_num)\n",
    "\n",
    "        user_highlights_id = get_question_hlUsers(uberDict, task_num, question_num)\n",
    "        user_highlights_start = get_question_start(uberDict, task_num, question_num)\n",
    "        user_highlights_end = get_question_end(uberDict, task_num, question_num)\n",
    "        user_highlights_answer = get_question_hlAns(uberDict, task_num, question_num)\n",
    "        article_len = get_text_length(uberDict, task_num, question_num)\n",
    "        number_of_answers = i[17]\n",
    "        if agreement == 'L' or agreement == 'M' or agreement == 'U' or agreement == 0 or type(article_len) == pd.Series:\n",
    "            pass\n",
    "        else:\n",
    "\n",
    "            agreement = (agreement)\n",
    "            if question_type == 'nominal':\n",
    "                do_rep_calculation_nominal(users, answers, agreement, highlights, user_highlights_id,\n",
    "                                           user_highlights_start, user_highlights_end, article_len,\n",
    "                                           user_rep_df=user_rep_df)\n",
    "\n",
    "            if question_type == 'ordinal':\n",
    "                hl_users = get_question_hlUsers(uberDict, task_num, question_num)\n",
    "\n",
    "                do_rep_calculation_ordinal(users, answers, agreement, number_of_answers, highlights, hl_users,\n",
    "                                           user_highlights_start, user_highlights_end, article_len,\n",
    "                                           user_rep_df=user_rep_df)\n",
    "            elif question_type == 'checklist':\n",
    "                i = 0\n",
    "                user_array = [0] * num_of_users\n",
    "                answer_array = [0] * num_of_users\n",
    "                highlight_users_array = []\n",
    "                highlight_starts = []\n",
    "                highlight_ends = []\n",
    "                for a, u in zip(answers, users):\n",
    "                    if i == num_of_users:\n",
    "                        break\n",
    "                    if int(a) == int(agreement):\n",
    "                        user_array[i] = u\n",
    "                        answer_array[i] = 1\n",
    "                    else:\n",
    "                        if u not in user_array:\n",
    "                            user_array[i] = u\n",
    "                    i += 1\n",
    "\n",
    "                for h_a, h_u, h_s, h_e in zip(user_highlights_answer, user_highlights_id, user_highlights_start,\n",
    "                                              user_highlights_end):\n",
    "                    if h_a == agreement:\n",
    "                        highlight_users_array.append(h_u)\n",
    "                        highlight_starts.append(h_s)\n",
    "                        highlight_ends.append(h_e)\n",
    "                do_rep_calculation_nominal(user_array, answer_array, 1, highlights, highlight_users_array,\n",
    "                                           highlight_starts, highlight_ends, article_len, user_rep_df)\n",
    "\n",
    "\n",
    "def userid_to_CSV(dataframe):\n",
    "    \"\"\"This function will save the User Rep Score dataframe as UserRepScores.csv\"\"\"\n",
    "\n",
    "    dataframe.to_csv(\"UserRepScores.csv\")\n",
    "\n",
    "\n",
    "def CSV_to_userid(path):\n",
    "    \"\"\"This function will take in the path name of the UserRepScore.csv and output the dataframe corresponding.\"\"\"\n",
    "\n",
    "    csv = pd.read_csv(path, index_col=False)\n",
    "    dataframe = csv.loc[:,\n",
    "                ['Users', 'Score', 'Questions', 'Influence', 'Index', 'LastDate'] + [str(x) for x in range(30)]]\n",
    "    dataframe['LastDate'] = [x.date() for x in pd.to_datetime(dataframe['LastDate'], infer_datetime_format=True)]\n",
    "\n",
    "    return dataframe\n",
    "\n",
    "\n",
    "def last30_to_CSV(dataframe):\n",
    "    \"\"\"This function will save the last 30 questions rep points dataframe as last30.csv\"\"\"\n",
    "    dataframe.to_csv(\"last30.csv\")\n",
    "\n",
    "\n",
    "def CSV_to_last30(path):\n",
    "    \"\"\"This function opens the csv of the last 30 questions rep points dataframe as last30.csv\"\"\"\n",
    "    return pd.read_csv(path, index_col=False).loc[:, ['Users', 'Index'] + list(range(30))]\n",
    "\n",
    "\n",
    "def get_user_rep(id, repDF, useRep=False):\n",
    "    \"\"\"This function takes in the existing UserRep DataFrame and calculates the influence of a user by taking in\n",
    "    every users' score into a CDF and calculate the number of standard deviations that user is from the average,\n",
    "    and using that multiplied by a multiplier X.\"\"\"\n",
    "    if repDF is None or not useRep:\n",
    "        return 1, repDF\n",
    "\n",
    "    else:\n",
    "        x = 2\n",
    "        users = repDF.loc[:, 'Users']\n",
    "        question = np.array(repDF.loc[:, \"Questions\"])\n",
    "\n",
    "        scores = np.array(repDF.loc[:, 'Score'])\n",
    "        avg_scores = np.mean(scores)\n",
    "        std_scores = math.sqrt(np.mean((scores - avg_scores) ** 2))\n",
    "        for u in users.tolist():\n",
    "            user_score = float(repDF.loc[repDF['Users'] == u]['Score'].iloc[0])\n",
    "            infl = norm.cdf(user_score, avg_scores, std_scores)\n",
    "\n",
    "            repDF.loc[repDF['Users'] == u, 'Influence'] = infl * x\n",
    "            if (u == id):\n",
    "                influence = repDF.loc[repDF['Users'] == id, 'Influence']\n",
    "                if repDF.loc[repDF['Users'] == id]['Questions'].iloc[0] < 30:\n",
    "                    influence = .8\n",
    "\n",
    "    return influence, repDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}