Алгоритм восстановления по Чеботареву.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.optimize import nnls\n",
    "from scipy.linalg   import lstsq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Псевдорешение (неоднородной) системы линейных уравнений\n",
    "def solve_approximate(a,b,m,is_positive,round_to=2):\n",
    "        # Найти псевдообратную матрицу a_pinv\n",
    "        # Найти псевдорешение x=a_pinv*b\n",
    "        if is_positive:\n",
    "            x, err = nnls(a,b)\n",
    "        else:\n",
    "            x, err, rnk, s  = lstsq(a, b)\n",
    "        # Итоговый рейтинг (чем больше значение, тем выше ранг, лучше объект)\n",
    "        #погрешность решения системы\n",
    "        #if isinstance(x[0],np.ndarray):\n",
    "        #    x=np.squeeze(np.asarray(x)) #x=x.squeeze()\n",
    "        #else:\n",
    "        #    x=np.array(x)\n",
    "        #y=np.round(a.dot(x)-b, 14)[0]\n",
    "        # при совместной системе все y=0\n",
    "        # сумма квадратов yi\n",
    "        #err=0.0\n",
    "        #for i in range(0,len(y)):\n",
    "        #    err += y[i]*y[i]\n",
    "        #err=np.sum(y ** 2)\n",
    "        rez={}\n",
    "        rez['x']=np.round(x[0:m], round_to)\n",
    "        rez['err']=err\n",
    "        return rez"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# матрица парных сравнений из вектора (чем больше значение, тем лучше)\n",
    "def getT(vect,IsSortRevers=False):\n",
    "    if IsSortRevers:\n",
    "        vect = -1*np.array(vect)\n",
    "    m = len(vect)\n",
    "    t=np.zeros((m, m))\n",
    "    for i in range(0,m-1):\n",
    "        for j in range(i+1,m):\n",
    "            tt=0;\n",
    "            if pd.isna(vect[i]):\n",
    "                tt=0\n",
    "            elif vect[i]>vect[j]:\n",
    "                tt=1\n",
    "            elif vect[i]<vect[j]:\n",
    "                tt=-1\n",
    "            t[i][j] = tt\n",
    "            t[j][i] = -tt\n",
    "    return t\n",
    "# getT([ 15, 16,18,19],1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# нормированная матрица N\n",
    "def getNnor(Matrix):\n",
    "    m = Matrix['m']\n",
    "    Nnor=np.zeros((m, m))\n",
    "    for i in range(m):\n",
    "        for j in range(m):\n",
    "            if Matrix['Np'][i][j]>0:\n",
    "                Nnor[i][j] = 1.0*Matrix['Nm'][i][j]/Matrix['Np'][i][j] \n",
    "    return Nnor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# сумарные матрицы   df (столбец - вектор)\n",
    "def getMatrix(df,IsSortRevers=False):\n",
    "    n = len(df.columns)\n",
    "    m = len(df[df.columns[0]])\n",
    "    Matrix={}\n",
    "    Matrix['n']=n\n",
    "    Matrix['m']=m\n",
    "    Matrix['N']=np.zeros((m, m)) #2.4\n",
    "    Matrix['N0']=np.zeros((m, m))#2.5\n",
    "    Matrix['Nm']=np.zeros((m, m))#2.6\n",
    "    Matrix['Ns']=np.zeros((m, m))#2.7\n",
    "    Matrix['Np']=np.zeros((m, m))#2.8\n",
    "    for k in range(0,n):\n",
    "        x = df[df.columns[k]]\n",
    "        if IsSortRevers:\n",
    "            x = -1*np.array(x)\n",
    "        #print(x)\n",
    "        #print(getT(x))\n",
    "        for i in range(0,m-1): \n",
    "            for j in range(i+1,m):                   \n",
    "                if pd.isna(x[i])==False and pd.isna(x[j])==False :\n",
    "                    #print(i,j)\n",
    "                    Matrix['Np'][i][j] += 1\n",
    "                    Matrix['Np'][j][i] += 1\n",
    "                    if x[i]>x[j]:\n",
    "                        Matrix['N'][i][j] += 1\n",
    "                    elif x[i]<x[j]:  \n",
    "                        Matrix['N'][j][i] += 1\n",
    "                    else:\n",
    "                            Matrix['N0'][i][j] += 1\n",
    "                            Matrix['N0'][j][i] += 1\n",
    "                Matrix['Nm'][i][j] = Matrix['N'][i][j] - Matrix['N'][j][i]\n",
    "                Matrix['Nm'][j][i] = -Matrix['Nm'][i][j]\n",
    "                Matrix['Ns'][i][j] = Matrix['N'][i][j] + 0.5*Matrix['N0'][i][j]\n",
    "                Matrix['Ns'][j][i] = Matrix['N'][j][i] + 0.5*Matrix['N0'][j][i]\n",
    "    return Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Чеботарёв\n",
    "def method_rows_sum_extension(Matrix): #Matrix 'Nm','Np'\n",
    "    n=Matrix['n']\n",
    "    m=Matrix['m']\n",
    "    x_max = n*(m-1)\n",
    "    e=1/(2*x_max)\n",
    "\n",
    "    # строчные суммы\n",
    "    b=np.zeros(m)\n",
    "    for i in range(0,m): \n",
    "        for j in range(0,m): \n",
    "            b[i] +=  Matrix['Nm'][i][j]\n",
    "    a=-1*Matrix['Np']+n\n",
    "    for i in range(0,m): \n",
    "        a[i][i]=0\n",
    "        for k in range(0,m): \n",
    "            if k!=i:\n",
    "                a[i][i]+=-n+ Matrix['Np'][i][k]\n",
    "    #ax=b\n",
    "    a=e*a+np.matrix(np.eye(m, dtype=int))\n",
    "    # сум x =0\n",
    "    b=np.append(b, 0)\n",
    "    a=np.append(a,np.ones((1, m)), axis = 0)\n",
    "    # -x_max<=x<=x_max\n",
    "    e0=np.zeros((m, m))\n",
    "    e1=np.matrix(np.eye(m, dtype=int))\n",
    "    e1_=-1*np.matrix(np.eye(m, dtype=int))\n",
    "\n",
    "    b=np.append(b,-x_max*np.ones((1, m)))\n",
    "    a=np.concatenate((a,np.zeros((len(a), m))),axis=1)\n",
    "    ee=np.concatenate((e1,e1_),axis=1)\n",
    "    a=np.append(a,ee, axis = 0)\n",
    "    b=np.append(b,x_max*np.ones((1, m)))\n",
    "    a=np.concatenate((a,np.zeros((len(a), m))),axis=1)\n",
    "    ee=np.concatenate((e1,e0,e1),axis=1)\n",
    "    a=np.append(a,ee, axis = 0)\n",
    "    a=np.array(a)\n",
    "    # Привели к виду ax=b  \n",
    "    return solve_approximate(a,b,m,is_positive=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Востановление пропусков в одном векторе\n",
    "def method_rang_complit_one(x,x_,m,Nnor):\n",
    "        Nprop = 0\n",
    "        for i in range(0,m): \n",
    "            if pd.isna(x[i])==True:\n",
    "                Nprop += 1\n",
    "        if Nprop == 0:\n",
    "            rez={}\n",
    "            rez['x']=x\n",
    "            rez['err']=0\n",
    "            return rez\n",
    "        b=np.zeros(m)   \n",
    "        a=np.matrix(np.eye(m, dtype=int))\n",
    "        for i in range(0,m): \n",
    "            if pd.isna(x[i])==False:\n",
    "                b[i] = x[i]\n",
    "            else:\n",
    "                b[i] = x_[i]                  \n",
    "        kProp = 0\n",
    "        for i in range(0,m): \n",
    "            if pd.isna(x[i])==True:\n",
    "                kProp += 1\n",
    "                a0=np.zeros((m-1, m))\n",
    "                a1=np.zeros((m-1, m-1))\n",
    "                for j in range(0,m-1):\n",
    "                    a0[j][i]=1\n",
    "                    i1=0\n",
    "                for j in range(0,m): \n",
    "                    if i!=j:\n",
    "                        if pd.isna(x[j])==False:\n",
    "                            b=np.append(b,x[j])\n",
    "                        else:\n",
    "                            b=np.append(b,x_[j])  \n",
    "                        a1[i1][i1]=-Nnor[i][j]\n",
    "                        i1 += 1\n",
    "\n",
    "                e1 = np.zeros((m+(kProp-1)*(m-1), m-1))\n",
    "                e1 = np.concatenate((a,e1),axis=1)\n",
    "                e2 = np.zeros(( m-1,(kProp-1)*(m-1)))\n",
    "                e2 = np.concatenate((a0,e2),axis=1)\n",
    "                e2 = np.concatenate((e2,a1),axis=1)\n",
    "                a=np.append(e1,e2, axis = 0)\n",
    "                #print(a)\n",
    "        # Привели к виду ax=b\n",
    "        #print(a)\n",
    "        #print(b)\n",
    "        #print(m)\n",
    "        return solve_approximate(a,b,m,is_positive=True)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Востановление пропусков   (не возвращаю rez['err'])\n",
    "def method_rang_complit(df,x_,Matrix):\n",
    "    n=Matrix['n']\n",
    "    m=Matrix['m']\n",
    "    # веса условий\n",
    "    #Nnor=getNnor(Matrix)\n",
    "    #print(Nnor)\n",
    "    Nnor=(1/n)*Matrix['Nm']\n",
    "    #print(Nnor)\n",
    "    #print(t_)\n",
    "    #df2 = df.copy(deep=True)\n",
    "    df2 = pd.DataFrame(columns=np.array(df.columns))\n",
    "    data={}\n",
    "    for k in range(0,n):\n",
    "        x = df[df.columns[k]]\n",
    "        #print(x)\n",
    "        rez=method_rang_complit_one(x,x_,m,Nnor) \n",
    "        data[df.columns[k]] =rez['x']\n",
    "        #df2 = df2.append({df.columns[k]: pd.Series(rez['x'])}, ignore_index=True)\n",
    "    return pd.DataFrame(data, np.array(df.index))"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}