obebs_func.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.optimize import linear_sum_assignment\n",
    "import random\n",
    "\n",
    "###############################################################################################################################\n",
    "# Optimally balanced entropy based sampling ###################################################################################\n",
    "###############################################################################################################################\n",
    "        \n",
    "def OBE(X_train, Y_train, predY, cnum):\n",
    "    if len(Y_train) < 1:\n",
    "        return 0\n",
    "    H = 0\n",
    "    for i in range(cnum):\n",
    "        if i == predY:\n",
    "            Ni = X_train[Y_train == i,:].shape[0] + 1\n",
    "        else:\n",
    "            Ni = X_train[Y_train == i,:].shape[0]\n",
    "        if Ni == 0:\n",
    "            tmp = 0\n",
    "        else:\n",
    "            tmp = ((Ni/X_train.shape[0]) * np.log(Ni/X_train.shape[0]))\n",
    "        H = H + tmp\n",
    "    return -H\n",
    "\n",
    "def OBEBS(X_train, Y_train, X_test, Y_test, probs, labels, labels_train, cnum,tt=0):\n",
    "    rownum = probs.shape[0]\n",
    "    maxH = -np.Infinity\n",
    "    maxIdx = 0\n",
    "    for i in range(rownum):\n",
    "        H = 0\n",
    "        for j in range(cnum):\n",
    "            H = H + (OBE(X_train, Y_train, j, cnum) * probs[i,j])\n",
    "        if (H > maxH):\n",
    "            maxH = H\n",
    "            maxIdx = i\n",
    "    if len(X_train) > 0:\n",
    "        X_train = np.insert(X_train, X_train.shape[0], X_test[maxIdx,:], axis=0)\n",
    "        Y_train = np.insert(Y_train, len(Y_train), Y_test[maxIdx])\n",
    "        labels_train = np.insert(labels_train, len(labels_train), labels[maxIdx])\n",
    "    else:\n",
    "        X_train = np.array([X_test[maxIdx,:]])\n",
    "        Y_train = np.array([Y_test[maxIdx]])\n",
    "        labels_train = np.array([labels[maxIdx]])\n",
    "    X_test = np.delete(X_test, maxIdx, axis=0)\n",
    "    Y_test = np.delete(Y_test, maxIdx)\n",
    "    labels = np.delete(labels, maxIdx)\n",
    "    return X_train, Y_train, X_test, Y_test, labels, labels_train, maxIdx, maxH\n",
    "\n",
    "def get_costMX(Y_pool, labels, cnum):\n",
    "    costMX = np.zeros((cnum,cnum))\n",
    "    for i in range(len(Y_pool)):\n",
    "        costMX[labels[i], Y_pool[i]] += 1\n",
    "    return costMX\n",
    "\n",
    "###############################################################################################################################\n",
    "# Hungarian algorithm for best assignment\n",
    "###############################################################################################################################\n",
    "\n",
    "def hun_algo(costMX):\n",
    "    ri, ci = linear_sum_assignment(-costMX)\n",
    "    A = np.zeros((len(ri),len(ri)))\n",
    "    for i,ind in enumerate(ci):\n",
    "        A[i,ind] = 1\n",
    "    return A\n",
    "\n",
    "###############################################################################################################################\n",
    "# LBE = (SUM(Diff(t)) - (k-1)*T ) / (k*T)   t=1 to T*k\n",
    "###############################################################################################################################\n",
    "\n",
    "def Diff_t_(cnum, X_train, Y_train):\n",
    "    buckets=np.zeros(cnum)\n",
    "    for i in range(cnum):\n",
    "        buckets[i] = X_train[Y_train == i,:].shape[0]\n",
    "    return np.max(buckets)-np.min(buckets)\n",
    "\n",
    "###############################################################################################################################\n",
    "# REL\n",
    "###############################################################################################################################\n",
    "\n",
    "def calculate_entropy(X_train, Y_train, cnum):\n",
    "    if len(Y_train) < 1:\n",
    "        return 0\n",
    "    H = 0\n",
    "    for i in range(cnum):\n",
    "        Ni = X_train[Y_train == i,:].shape[0]\n",
    "        if Ni == 0:\n",
    "            tmp = 0\n",
    "        else:\n",
    "            tmp = ((Ni/X_train.shape[0]) * np.log(Ni/X_train.shape[0]))\n",
    "        H = H + tmp\n",
    "    return -H\n",
    "\n",
    "def calculate_optimal_entropy(X_train, Y_train, cnum):\n",
    "    if len(Y_train) < 1:\n",
    "        return 0\n",
    "    sample_num = X_train.shape[0]\n",
    "    full_num = sample_num // cnum\n",
    "    remainder_num = sample_num % cnum\n",
    "    H = 0\n",
    "    for i in range(cnum):\n",
    "        if i < remainder_num:\n",
    "            Ni = full_num+1\n",
    "        else:\n",
    "            Ni = full_num\n",
    "        if Ni == 0:\n",
    "            tmp = 0\n",
    "        else:\n",
    "            tmp = ((Ni/X_train.shape[0]) * np.log(Ni/X_train.shape[0]))\n",
    "        H = H + tmp\n",
    "    return -H\n",
    "\n",
    "###############################################################################################################################\n",
    "# Adaptive assignment algo.\n",
    "###############################################################################################################################\n",
    "\n",
    "def adaptive_assignment(cnum, labels, labels_train, X_pool, X_train, Y_train, Q, costMX, MID):\n",
    "    strong_belongness = list()\n",
    "    for iii in range(costMX.shape[0]):\n",
    "        strong_belongness.append(np.argmax(costMX[iii,:]))\n",
    "    max_ratio = -np.Inf\n",
    "    chosen_group = 0\n",
    "    fn1 = 0\n",
    "    fn2 = 0\n",
    "    fn1i = 0\n",
    "    fn2i = 0\n",
    "    for iii in range(cnum):\n",
    "        n1 = 0\n",
    "        n2 = 0\n",
    "        n1i = 0\n",
    "        n2i = 0\n",
    "        for jjj in range(cnum):\n",
    "            temp1 = np.zeros(len(Y_train))\n",
    "            temp1[Y_train == jjj] = 2\n",
    "            temp2 = np.ones(len(Y_train))\n",
    "            temp2[labels_train == iii] = 2\n",
    "            temp3 = X_train[temp1 == temp2,:].shape[0]\n",
    "            if temp3 > n1:\n",
    "                if n1 != 0:\n",
    "                    n2 = n1\n",
    "                    n2i = n1i\n",
    "                n1 = temp3\n",
    "                n1i = jjj\n",
    "            elif temp3 > n2:\n",
    "                n2 = temp3\n",
    "                n2i = jjj\n",
    "        if n1 != 0:\n",
    "            if n2/n1 > max_ratio:\n",
    "                max_ratio = n2/n1\n",
    "                chosen_group = iii\n",
    "                fn1 = n1\n",
    "                fn2 = n2\n",
    "                fn1i = n1i\n",
    "                fn2i = n2i\n",
    "    if (fn2 != 0) and (MID is not None):\n",
    "        ## Divide\n",
    "        temp1 = np.zeros(len(Y_train))\n",
    "        temp1[Y_train == fn1i] = 2\n",
    "        temp2 = np.ones(len(Y_train))\n",
    "        temp2[labels_train == chosen_group] = 2\n",
    "        temp3 = np.zeros(len(Y_train))\n",
    "        temp3[Y_train == fn2i] = 2\n",
    "        X_train_svm = np.zeros((2,X_train.shape[1]))\n",
    "        Y_train_svm = np.zeros(2)\n",
    "        X_train_svm1 = np.array(X_train[temp1 == temp2,:])\n",
    "        X_train_svm2 = np.array(X_train[temp2 == temp3,:])\n",
    "        X_train_svm[0,:] = X_train_svm1[0,:]\n",
    "        X_train_svm[1,:] = X_train_svm2[0,:]\n",
    "        Y_train_svm[0] = chosen_group\n",
    "        Y_train_svm[1] = MID\n",
    "        clf = SVC(gamma='auto', probability=True)\n",
    "        clf.fit(X_train_svm, Y_train_svm)\n",
    "        labels_train[temp1 == temp2] = chosen_group\n",
    "        labels_train[temp2 == temp3] = MID\n",
    "        if X_train[labels_train == chosen_group,:].shape[0] > (fn1+fn2):\n",
    "            temp4 = np.zeros(len(Y_train))\n",
    "            temp4[Y_train != fn1i] = 2\n",
    "            temp5 = np.ones(len(Y_train))\n",
    "            temp5[Y_train != fn2i] = 2\n",
    "            temp6 = np.zeros(len(Y_train))\n",
    "            temp6[temp4==temp5] = 2\n",
    "            svm_predictions = clf.predict(X_train[temp6==temp2])\n",
    "            svm_idx = np.where(temp6 == temp2)[0]\n",
    "            for iii,jjj in enumerate(svm_idx):\n",
    "                labels_train[jjj] = svm_predictions[iii]\n",
    "        svm_predictions = clf.predict(X_pool[labels==chosen_group])\n",
    "        svm_probabilities = clf.predict_proba(X_pool)\n",
    "        svm_idx = np.where(labels==chosen_group)[0]\n",
    "        for iii,jjj in enumerate(svm_idx):\n",
    "            labels[jjj] = svm_predictions[iii]\n",
    "        ### Update Q\n",
    "        Q_temp = Q.copy()\n",
    "        for iii in range(Q.shape[0]):\n",
    "            for jjj in range(cnum):\n",
    "                if jjj == chosen_group:\n",
    "                    Q[iii,jjj] = Q_temp[iii,chosen_group]*svm_probabilities[iii,1]\n",
    "                elif jjj == MID:\n",
    "                    Q[iii,jjj] = Q_temp[iii,chosen_group]*svm_probabilities[iii,0]\n",
    "                else:\n",
    "                    Q[iii,jjj] = Q_temp[iii,jjj]\n",
    "        for iii in range(Q.shape[0]):\n",
    "            Q[iii,:] = (Q[iii,:] - Q[iii,:].min()) / (Q[iii,:] - Q[iii,:].min()).sum()\n",
    "        MID = None\n",
    "    elif (fn2 != 0) and (MID is None):\n",
    "        ## Divide\n",
    "        temp1 = np.zeros(len(Y_train))\n",
    "        temp1[Y_train == fn1i] = 2\n",
    "        temp2 = np.ones(len(Y_train))\n",
    "        temp2[labels_train == chosen_group] = 2\n",
    "        temp3 = np.zeros(len(Y_train))\n",
    "        temp3[Y_train == fn2i] = 2\n",
    "        X_train_svm = np.zeros((2,X_train.shape[1]))\n",
    "        Y_train_svm = np.zeros(2)\n",
    "        X_train_svm1 = np.array(X_train[temp1 == temp2,:])\n",
    "        X_train_svm2 = np.array(X_train[temp2 == temp3,:])\n",
    "        X_train_svm[0,:] = X_train_svm1[0,:]\n",
    "        X_train_svm[1,:] = X_train_svm2[0,:]\n",
    "        Y_train_svm[0] = chosen_group\n",
    "        Y_train_svm[1] = cnum\n",
    "        clf = SVC(gamma='auto', probability=True)\n",
    "        clf.fit(X_train_svm, Y_train_svm)\n",
    "        labels_train[temp1 == temp2] = chosen_group\n",
    "        labels_train[temp2 == temp3] = cnum\n",
    "        if X_train[labels_train == chosen_group,:].shape[0] > (fn1+fn2):\n",
    "            temp4 = np.zeros(len(Y_train))\n",
    "            temp4[Y_train != fn1i] = 2\n",
    "            temp5 = np.ones(len(Y_train))\n",
    "            temp5[Y_train != fn2i] = 2\n",
    "            temp6 = np.zeros(len(Y_train))\n",
    "            temp6[temp4==temp5] = 2\n",
    "            svm_predictions = clf.predict(X_train[temp6==temp2])\n",
    "            svm_idx = np.where(temp6 == temp2)[0]\n",
    "            for iii,jjj in enumerate(svm_idx):\n",
    "                labels_train[jjj] = svm_predictions[iii]\n",
    "        if len(X_pool[labels==chosen_group]) > 0:\n",
    "            svm_predictions = clf.predict(X_pool[labels==chosen_group])\n",
    "            svm_probabilities = clf.predict_proba(X_pool)\n",
    "            svm_idx = np.where(labels==chosen_group)[0]\n",
    "            for iii,jjj in enumerate(svm_idx):\n",
    "                labels[jjj] = svm_predictions[iii]\n",
    "            ### Update Q\n",
    "            Q_temp = np.zeros((Q.shape[0],cnum+1))\n",
    "            for iii in range(Q.shape[0]):\n",
    "                for jjj in range(cnum+1):\n",
    "                    if jjj == chosen_group:\n",
    "                        Q_temp[iii,jjj] = Q[iii,chosen_group]*svm_probabilities[iii,1]\n",
    "                    elif jjj == cnum:\n",
    "                        Q_temp[iii,jjj] = Q[iii,chosen_group]*svm_probabilities[iii,0]\n",
    "                    else:\n",
    "                        Q_temp[iii,jjj] = Q[iii,jjj]\n",
    "            ## Merge \n",
    "            strong_belongness[chosen_group] = fn1i\n",
    "            strong_belongness.append(fn2i)\n",
    "            max_elements = 0\n",
    "            gti1 = 0\n",
    "            gti2 = 0\n",
    "            for iii in range(len(strong_belongness)-1):\n",
    "                for jjj in range(iii+1,len(strong_belongness)):\n",
    "                    if strong_belongness[iii] == strong_belongness[jjj]:\n",
    "                        if len(Y_train[Y_train == strong_belongness[iii]]) > max_elements:\n",
    "                            max_elements = len(Y_train[Y_train == strong_belongness[iii]])\n",
    "                            gti1 = iii\n",
    "                            gti2 = jjj\n",
    "            labels_train[labels_train == gti2] = gti1\n",
    "            labels[labels == gti2] = gti1\n",
    "            if gti2 != cnum:\n",
    "                labels_train[labels_train == cnum] = gti2\n",
    "                labels[labels == cnum] = gti2\n",
    "            ### Update Q\n",
    "            for iii in range(Q.shape[0]):\n",
    "                for jjj in range(cnum+1):\n",
    "                    if jjj == gti1: \n",
    "                        Q[iii,gti1] = Q_temp[iii,gti1] + Q_temp[iii,gti2]\n",
    "                    elif (jjj == gti2) and (gti2 != cnum):\n",
    "                        Q[iii,gti2] = Q_temp[iii,cnum]\n",
    "                    elif jjj != cnum:\n",
    "                        Q[iii,jjj] = Q_temp[iii,jjj]\n",
    "            for iii in range(Q.shape[0]):\n",
    "                Q[iii,:] = (Q[iii,:] - Q[iii,:].min()) / (Q[iii,:] - Q[iii,:].min()).sum()\n",
    "        else:\n",
    "            ## Simple merge \n",
    "            print(strong_belongness)\n",
    "            for iii in range(len(strong_belongness)):\n",
    "                if strong_belongness[iii] == fn2i:\n",
    "                    print(iii)\n",
    "                    labels_train[labels_train == cnum] = iii\n",
    "                    break\n",
    "    elif (fn2 == 0) and (MID is None):\n",
    "        ## Merge \n",
    "        max_elements = 0\n",
    "        gti1 = 0\n",
    "        gti2 = 0\n",
    "        for iii in range(len(strong_belongness)-1):\n",
    "            for jjj in range(iii+1,len(strong_belongness)):\n",
    "                if strong_belongness[iii] == strong_belongness[jjj]:\n",
    "                    if len(Y_train[Y_train == strong_belongness[iii]]) > max_elements:\n",
    "                        max_elements = len(Y_train[Y_train == strong_belongness[iii]])\n",
    "                        gti1 = iii\n",
    "                        gti2 = jjj\n",
    "        labels_train[labels_train == gti2] = gti1\n",
    "        labels[labels == gti2] = gti1\n",
    "        ### Update Q\n",
    "        Q_temp = Q.copy()\n",
    "        for iii in range(Q.shape[0]):\n",
    "            for jjj in range(cnum):\n",
    "                if jjj == gti1: \n",
    "                    Q[iii,gti1] = Q_temp[iii,gti1] + Q_temp[iii,gti2]\n",
    "                elif jjj == gti2:\n",
    "                    Q[iii,gti2] = 0\n",
    "                else:\n",
    "                    Q[iii,jjj] = Q_temp[iii,jjj]\n",
    "        MID = gti2\n",
    "    elif (fn2 == 0) and (MID is not None):\n",
    "        return labels, labels_train, Q, MID\n",
    "    return labels, labels_train, Q, MID"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}