unconstrained_gamma_VAE.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "576da0af",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Patch\n",
    "from numpy import pi, e\n",
    "from numpy.linalg import inv, det\n",
    "from numpy.linalg import norm as LA_norm\n",
    "from numpy.random import random\n",
    "from scipy.stats import norm\n",
    "from sklearn.datasets import make_spd_matrix\n",
    "from termcolor import colored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "00ae4c9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_matrix(m, n):\n",
    "    return np.random.rand(m, n)\n",
    "\n",
    "def initial_inputs(flag, is_diagonal):\n",
    "    if flag == 0:\n",
    "        # Create initial encoder inputs (B, Sigma_W)\n",
    "        B = create_matrix(m, n)\n",
    "        Sigma_W = make_spd_matrix(m)\n",
    "        return np.concatenate(([flag], B.reshape((m*n)), Sigma_W.reshape((m*m))))\n",
    "    else:\n",
    "        # Create initial decoder inputs (A, Sigma_Z)\n",
    "        A = create_matrix(n, m)\n",
    "        \n",
    "        if is_diagonal == 0:\n",
    "            Sigma_Z = make_spd_matrix(n)\n",
    "        else:\n",
    "            Sigma_Z = np.diag(random(n))\n",
    "            \n",
    "        return np.concatenate(([flag], A.reshape((n*m)), Sigma_Z.reshape((n*n))))\n",
    "\n",
    "def matrix_B(A, Sigma_Z):\n",
    "    B = gamma * inv(np.identity(m) + gamma * A.T @ inv(Sigma_Z) @ A) @ A.T @ inv(Sigma_Z)\n",
    "    return B\n",
    "\n",
    "def covariance_matrix_W(A, Sigma_Z):\n",
    "    Sigma_W = inv(np.identity(m) + gamma * A.T @ inv(Sigma_Z) @ A)\n",
    "    return Sigma_W\n",
    "\n",
    "def matrix_A(B, Sigma_W):\n",
    "    A = inv(inv(Sigma_Y) + B.T @ inv(Sigma_W) @ B) @ B.T @ inv(Sigma_W)\n",
    "    return A\n",
    "\n",
    "def covariance_matrix_Z(B, Sigma_W, is_diagonal):\n",
    "    Sigma_Z = inv(inv(Sigma_Y) + B.T @ inv(Sigma_W) @ B)\n",
    "    diagonalized_Sigma_Z = np.diag(Sigma_Z.diagonal())\n",
    "    \n",
    "    if is_diagonal == 0:\n",
    "        return Sigma_Z\n",
    "    else:\n",
    "        return diagonalized_Sigma_Z\n",
    "\n",
    "def encoder_mi(B, Sigma_W):\n",
    "    return 0.5 * np.log(det(B @ Sigma_Y @ B.T + Sigma_W) / det(Sigma_W))\n",
    "\n",
    "def decoder_mi(A, Sigma_Z):\n",
    "    return 0.5 * np.log(det(A @ A.T + Sigma_Z) / det(Sigma_Z))\n",
    "\n",
    "def reconstruction_error(recon, orig):\n",
    "    norm_diff = LA_norm(orig - recon, 2)\n",
    "    orig_norm = LA_norm(orig, 2)\n",
    "    recon_err = norm_diff / orig_norm\n",
    "    return recon_err\n",
    "    \n",
    "def objective_function(A, B, Sigma_Z, Sigma_W):\n",
    "    Sigma_X = B @ Sigma_Y @ B.T + Sigma_W\n",
    "    \n",
    "    regularizer = 0.5 * (np.trace(Sigma_X) - np.log(det(Sigma_W)) - m)\n",
    "    reconstruction = 0.5 * (np.trace(Sigma_X) + \\\n",
    "                            np.trace(A.T @ inv(Sigma_Z) @ Sigma_Y @ B.T) + \\\n",
    "                            np.trace(inv(Sigma_Z) @ A @ B @ Sigma_Y) - \\\n",
    "                            np.trace(inv(Sigma_Z) @ Sigma_Y) - \\\n",
    "                            np.trace((np.identity(m) + A.T @ inv(Sigma_Z) @ A) @ Sigma_X) - \\\n",
    "                            n * np.log(2 * pi) - np.log(det(Sigma_Z)))\n",
    "    \n",
    "    return regularizer - gamma * reconstruction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1c51e99c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_cost_function(cf_arr):\n",
    "    \"\"\"\n",
    "    Plot values of objective function against iterations t\n",
    "    \"\"\"\n",
    "    plt.plot(range(1, len(cf_arr) + 1), cf_arr)\n",
    "    plt.xlabel('t')\n",
    "    plt.ylabel('Cost Function', fontsize=10)\n",
    "    plt.show()\n",
    "\n",
    "def plot_encoder_mi(en_mi_arr):\n",
    "    \"\"\"\n",
    "    Plot mutual information of encoder against iterations t\n",
    "    \"\"\"\n",
    "    plt.plot(range(1, len(en_mi_arr) + 1), en_mi_arr)\n",
    "    plt.xlabel('t')\n",
    "    plt.ylabel('Mutual Information of Encoder', fontsize=10)\n",
    "    plt.show()\n",
    "\n",
    "def plot_decoder_mi(de_mi_arr):\n",
    "    \"\"\"\n",
    "    Plot mutual information of decoder against iterations t\n",
    "    \"\"\"\n",
    "    plt.plot(range(1, len(de_mi_arr) + 1), de_mi_arr)\n",
    "    plt.xlabel('t')\n",
    "    plt.ylabel('Mutual Information of Decoder', fontsize=10)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a60074ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_optimal_solution(sol, m):\n",
    "    A_arr = sol[:n*m] \n",
    "    B_arr = sol[n*m:2*n*m]\n",
    "    Sigma_Z_arr = sol[2*n*m:2*n*m+n*n]\n",
    "    Sigma_Z = Sigma_Z_arr.reshape((n, n))\n",
    "    Sigma_W_arr = sol[2*n*m+n*n:2*n*m+n*n+m*m]\n",
    "    Sigma_W = Sigma_W_arr.reshape((m, m))\n",
    "    cost_function = sol[2*n*m+n*n+m*m:2*n*m+n*n+m*m+1][0]\n",
    "    en_mi = sol[2*n*m+n*n+m*m+1:2*n*m+n*n+m*m+2][0]\n",
    "    de_mi = sol[2*n*m+n*n+m*m+2:2*n*m+n*n+m*m+3][0]\n",
    "    recon_err = sol[-1]\n",
    "    len_cf_mi_arr = sol[2*n*m+n*n+m*m+3:2*n*m+n*n+m*m+6]\n",
    "    Sigma_X = sol[2*n*m+n*n+m*m+6:2*n*m+n*n+2*m*m+6].reshape((m, m))\n",
    "    Sigma_Y_hat = sol[2*n*m+n*n+2*m*m+6:2*n*m+2*n*n+2*m*m+6].reshape((n, n))\n",
    "    \n",
    "    print(colored('Optimal solution:', attrs=['bold']))\n",
    "    \n",
    "    if m > 1:\n",
    "        print('Matrix A:\\n{}'.format(np.round(A_arr.reshape((n, m)), 4)))\n",
    "        print('\\nMatrix B:\\n{}'.format(np.round(B_arr.reshape((m, n)), 4)))\n",
    "        print('\\nCovariance matrix of Z:\\n{}'.format(np.round(Sigma_Z, 4)))\n",
    "        print('\\nCovariance matrix of W:\\n{}'.format(np.round(Sigma_W, 4)))\n",
    "        print('\\nMinimum value of the cost function:\\n{}'.format(round(cost_function, 4)))\n",
    "        print('\\nMutual information of the encoder:\\n{}'.format(round(en_mi, 4)))\n",
    "        print('\\nMutual information of the decoder:\\n{}'.format(round(de_mi, 4)))\n",
    "        print('\\nValue of Sigma_X:\\n{}'.format(np.round(Sigma_X, 4)))\n",
    "        print('\\nValue of Sigma_Y_hat:\\n{}'.format(np.round(Sigma_Y_hat, 4)))\n",
    "        print('\\nReconstruction error:\\n{}'.format(round(recon_err, 4)))\n",
    "    else:\n",
    "        print('Vector a:\\n{}'.format(np.round(A_arr.reshape((n, m)), 4)))\n",
    "        print('\\nVector b:\\n{}'.format(np.round(B_arr.reshape((m, n)), 4)[0]))\n",
    "        print('\\nCovariance matrix of Z:\\n{}'.format(np.round(Sigma_Z, 4)))\n",
    "        print('\\nVariance of W:\\n{}'.format(np.round(Sigma_W, 4)[0][0]))\n",
    "        print('\\nMinimum value of the cost function:\\n{}'.format(round(cost_function, 4)))\n",
    "        print('\\nMutual information of the encoder:\\n{}'.format(round(en_mi, 4)))\n",
    "        print('\\nMutual information of the decoder:\\n{}'.format(round(de_mi, 4)))\n",
    "        print('\\nValue of Sigma_X:\\n{}'.format(np.round(Sigma_X, 4)))\n",
    "        print('\\nValue of Sigma_Y_hat:\\n{}'.format(np.round(Sigma_Y_hat, 4)))        \n",
    "        print('\\nReconstruction error:\\n{}'.format(round(recon_err, 4)))\n",
    "        \n",
    "    return len_cf_mi_arr\n",
    "\n",
    "def print_comprehensive_results(gamma, flag, m, n, is_diagonal):\n",
    "    if flag == 0:\n",
    "        # Generate random initial encoder inputs (B, Sigma_W)\n",
    "        B, Sigma_W = initial_inputs(flag, is_diagonal)[1:1+m*n].reshape((m, n)), initial_inputs(flag, is_diagonal)[1+m*n:1+m*n+m*m].reshape((m, m))\n",
    "    else:\n",
    "        # Generate random initial decoder inputs (A, Sigma_Z)\n",
    "        A, Sigma_Z = initial_inputs(flag, is_diagonal)[1:1+n*m].reshape((n, m)), initial_inputs(flag, is_diagonal)[1+n*m:1+n*m+n*n].reshape((n, n))\n",
    "    \n",
    "    # Print given inputs\n",
    "    if m > 1 and flag == 0:\n",
    "        print(colored('Given encoder X:', attrs=['bold']))\n",
    "        print('Initial matrix B:')\n",
    "        print(np.round(B.reshape((m, n)), 4))\n",
    "        print('\\nInitial covariance matrix of W:')\n",
    "        print(np.round(Sigma_W, 4))\n",
    "    elif m == 1 and flag == 0:\n",
    "        print(colored('Given encoder X:', attrs=['bold']))\n",
    "        print('Initial vector b:')\n",
    "        print(np.round(B.reshape((m, n)), 4)[0])\n",
    "        print('\\nInitial variance of W:')\n",
    "        print(np.round(Sigma_W, 4)[0][0])\n",
    "    elif m > 1 and flag == 1:\n",
    "        print(colored('Given decoder Y_hat:', attrs=['bold']))\n",
    "        print('Initial matrix A:')\n",
    "        print(np.round(A.reshape((n, m)), 4))\n",
    "        print('\\nInitial covariance matrix of Z:')\n",
    "        print(np.round(Sigma_Z, 4))\n",
    "    else:\n",
    "        print(colored('Given decoder Y_hat:', attrs=['bold']))\n",
    "        print('Initial vector a:')\n",
    "        print(np.round(A.reshape((n, m)), 4))\n",
    "        print('\\nInitial covariance matrix of Z:')\n",
    "        print(np.round(Sigma_Z, 4))      \n",
    "    \n",
    "    # Print results\n",
    "    if flag == 0:\n",
    "        # Compute optimal solution given encoder inputs\n",
    "        opt_sol = rate_distortion(initial_inputs(flag, is_diagonal), is_diagonal)\n",
    "    \n",
    "        # Extract length of arrays for cost function and mutual information of encoder and decoder\n",
    "        len_all_arrs = print_optimal_solution(opt_sol, m).astype(int)\n",
    "        len_cf_arr, len_en_mi_arr = len_all_arrs[:2]\n",
    "        len_cf_en_mi_arr = len_cf_arr + len_en_mi_arr\n",
    "        \n",
    "        # Plot values of cost function and mutual information against iterations\n",
    "        cf_arr = opt_sol[2*n*m+2*n*n+2*m*m+6 : 2*n*m+2*n*n+2*m*m+6+len_cf_arr]\n",
    "        plot_cost_function(cf_arr)\n",
    "    \n",
    "        en_mi_arr = opt_sol[2*n*m+2*n*n+2*m*m+6+len_cf_arr : 2*n*m+2*n*n+2*m*m+6+len_cf_en_mi_arr]\n",
    "        plot_encoder_mi(en_mi_arr)\n",
    "    \n",
    "        de_mi_arr = opt_sol[2*n*m+2*n*n+2*m*m+6+len_cf_en_mi_arr:]\n",
    "        plot_decoder_mi(de_mi_arr) \n",
    "    else:\n",
    "        opt_sol = rate_distortion(initial_inputs(flag, is_diagonal), is_diagonal)\n",
    "        \n",
    "        len_all_arrs = print_optimal_solution(opt_sol, m).astype(int)\n",
    "        len_cf_arr, len_en_mi_arr = len_all_arrs[:2]\n",
    "        len_cf_en_mi_arr = len_cf_arr + len_en_mi_arr\n",
    "        \n",
    "        cf_arr = opt_sol[2*n*m+2*n*n+2*m*m+6 : 2*n*m+2*n*n+2*m*m+6+len_cf_arr]\n",
    "        plot_cost_function(cf_arr)\n",
    "    \n",
    "        en_mi_arr = opt_sol[2*n*m+2*n*n+2*m*m+6+len_cf_arr : 2*n*m+2*n*n+2*m*m+6+len_cf_en_mi_arr]\n",
    "        plot_encoder_mi(en_mi_arr)\n",
    "    \n",
    "        de_mi_arr = opt_sol[2*n*m+2*n*n+2*m*m+6+len_cf_en_mi_arr:]\n",
    "        plot_decoder_mi(de_mi_arr) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f2fbe240",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\n",
    "*****************************************************************\n",
    "**                          ALGORITHM                          **\n",
    "*****************************************************************\n",
    "   \n",
    "Inputs:\n",
    "- MAX_ITERS: Maximum number of iterations\n",
    "- n, m: Dimensions of the matrix\n",
    "- TOL_ERR: Tolerable error\n",
    "- Sigma_Y: A random nxn positive definite matrix\n",
    "\n",
    "Algorithm:\n",
    "1. Initialize flag\n",
    "    a. If we start with the encoder, set flag = 0.\n",
    "    b. Otherwise, set flag = 1.\n",
    "    \n",
    "2. Generate initial inputs for the iteration step\n",
    "    a. If flag = 0, then do:\n",
    "        i. create random initial encoder inputs, including \n",
    "            - a random mxn matrix B\n",
    "            - a random mxm positive definite covariance matrix Sigma_W\n",
    "        ii. set flag = 1.\n",
    "    b. If flag = 1, then do:\n",
    "        i. create random initial decoder inputs, including \n",
    "            - a random nxm matrix A\n",
    "            - a random nxn positive definite covariance matrix Sigma_Z\n",
    "        ii. set flag = 0.\n",
    "        \n",
    "3. Set iteration counter i = 0. \n",
    "\n",
    "4. Iterative step\n",
    "    a. If flag = 0, given the decoder inputs (A, Sigma_Z) at iteration i,\n",
    "        i. compute the corresponding encoder inputs at iteration i+1:\n",
    "            B = matrix_B(A, Sigma_Z)\n",
    "            Sigma_W = covariance_matrix_W(A, Sigma_Z)\n",
    "        ii. set flag = 1.\n",
    "        iii. compute the resulting gamma-VAE cost function and mutual information of the encoder.\n",
    "        iv. check if the cost function is NaN:\n",
    "            - if it is, conclude that the algorithm fails to converge and skip to step 7.\n",
    "        v. check for convergence after the second iteration:\n",
    "            - if converges, conclude that the algorithm converges and skip to step 7.\n",
    "            - unless, check if the maximum number of iterations has been reached:\n",
    "                - if it is, conclude that the algorithm failed to converge and skip to step 7.\n",
    "                - otherwise, move to step 5.\n",
    "    b. If flag = 1, given the encoder inputs (B, Sigma_W) at iteration i,\n",
    "        i. compute the corresponding decoder inputs at iteration i:\n",
    "            A = matrix_A(B, Sigma_W)\n",
    "            Sigma_Z = covariance_matrix_Z(B, Sigma_W, is_diagonal)\n",
    "        ii. set flag = 0.\n",
    "        iii. compute the resulting gamma-VAE cost function, mutual information of the decoder, and reconstruction error.\n",
    "        iv. check if the cost function is NaN:\n",
    "            - if it is, conclude that the algorithm fails to converge and skip to step 7.\n",
    "        v. check for convergence after the second iteration:\n",
    "            - if converges, conclude that the algorithm converges and skip to step 7.\n",
    "            - unless, check if the maximum number of iterations has been reached:\n",
    "                - if it is, conclude that the algorithm failed to converge and skip to step 7.\n",
    "                - otherwise, move to step 5.\n",
    "            \n",
    "5. Increment iteration counter i <- i + 1.\n",
    "\n",
    "6. If the iteration counter i < MAX_ITERS, then move back to step 4.\n",
    "    Otherwise, move to step 7.\n",
    "    \n",
    "7. Compute the values of Sigma_X and Sigma_Y_hat.\n",
    "        \n",
    "8. Display results\n",
    "    a. display the optimal solution (A, B, Sigma_Z, Sigma_W).\n",
    "    b. display the corresponding minimum value of gamma-VAE cost function.\n",
    "    c. display the resulting mutual information of both encoder and decoder.\n",
    "    d. display the values of Sigma_X and Sigma_Y_hat.\n",
    "    e. display the value of reconstruction error.\n",
    "    f. move to step 9.\n",
    "    \n",
    "9. Stop.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "def rate_distortion(inputs, is_diagonal):\n",
    "    flag = inputs[0]\n",
    "    if flag == 0:\n",
    "        B = inputs[1:1+m*n].reshape((m, n))\n",
    "        Sigma_W = inputs[1+m*n:1+m*n+m*m].reshape((m, m))\n",
    "        flag = 1\n",
    "        # Array of current encoder inputs (B_t, Sigma_W_t)\n",
    "        current_encoder_inputs = np.concatenate((B.reshape((m*n)), Sigma_W.reshape((m*m))))\n",
    "    else:\n",
    "        A = inputs[1:1+n*m].reshape((n, m))\n",
    "        Sigma_Z = inputs[1+n*m:1+n*m+n*n].reshape((n, n))\n",
    "        flag = 0\n",
    "        # Array of current decoder inputs (A_t, Sigma_Z_t)\n",
    "        current_decoder_inputs = np.concatenate((A.reshape((n*m)), Sigma_Z.reshape((n*n))))\n",
    "    \n",
    "    # Cost function and mutual information arrays\n",
    "    cf_arr = []\n",
    "    en_mi_arr = []\n",
    "    de_mi_arr = [] \n",
    "    \n",
    "    # Iteration step\n",
    "    try:\n",
    "        for i in range(0, MAX_ITERS):\n",
    "            if  flag == 0:\n",
    "                B = matrix_B(A, Sigma_Z)\n",
    "                Sigma_W = covariance_matrix_W(A, Sigma_Z)\n",
    "                flag = 1\n",
    "                \n",
    "                # Check if the value of the cost function is not a number\n",
    "                current_obj = objective_function(A, B, Sigma_Z, Sigma_W)\n",
    "                if np.isnan(current_obj):\n",
    "                    print(colored('\\nThe algorithm fails to converge after {} iterations due to NaN values.\\n'.format(i+1), 'red', attrs=['bold']))\n",
    "                    break\n",
    "                    \n",
    "                cf_arr = np.concatenate((cf_arr, [current_obj]))\n",
    "                current_en_mi = encoder_mi(B, Sigma_W)\n",
    "                en_mi_arr = np.concatenate((en_mi_arr, [current_en_mi]))\n",
    "                \n",
    "                # For the first iteration, update the current encoder inputs and value of the cost function\n",
    "                if i == 0:\n",
    "                    current_encoder_inputs = np.concatenate((B.reshape((m*n)), Sigma_W.reshape((m*m))))\n",
    "                    previous_obj = current_obj\n",
    "                # From the second iteration,\n",
    "                # 1. Compute the Frobenius norm of the difference between\n",
    "                #    i. B and itself in the previous iteration\n",
    "                #    ii. Sigma_W and itself in the previous iteration\n",
    "                # 2. Compute the difference between the cost function and itself in the previous iteration\n",
    "                # 3. Update the current encoder inputs and value of the cost function\n",
    "                else:\n",
    "                    B_diff = B - current_encoder_inputs[:m*n].reshape((m, n))\n",
    "                    B_norm_diff = LA_norm(B_diff, 'fro')\n",
    "                    Sigma_W_diff = Sigma_W - current_encoder_inputs[m*n:m*n+m*m].reshape((m, m))\n",
    "                    Sigma_W_norm_diff = LA_norm(Sigma_W_diff, 'fro')\n",
    "                    obj_diff = previous_obj - current_obj\n",
    "                    previous_obj = current_obj\n",
    "                    current_encoder_inputs = np.concatenate((B.reshape((m*n)), Sigma_W.reshape((m*m))))\n",
    "                    # Check for convergence\n",
    "                    if B_norm_diff <= TOL_ERR and Sigma_W_norm_diff <= TOL_ERR and round(obj_diff, 8) == 0:\n",
    "                        print(colored('\\nThe algorithm converges after {} iterations.\\n'.format(i+1), 'blue', attrs=['bold']))\n",
    "                        break\n",
    "                    elif i == MAX_ITERS - 1:\n",
    "                        print(colored('\\nThe algorithm reaches the maximum number of iterations without convergence.\\n', 'red', attrs=['bold']))\n",
    "            else:\n",
    "                A = matrix_A(B, Sigma_W)\n",
    "                Sigma_Z = covariance_matrix_Z(B, Sigma_W, is_diagonal)\n",
    "                flag = 0\n",
    "                \n",
    "                current_obj = objective_function(A, B, Sigma_Z, Sigma_W)\n",
    "                if np.isnan(current_obj):\n",
    "                    print(colored('\\nThe algorithm fails to converge after {} iterations due to NaN values.\\n'.format(i+1), 'red', attrs=['bold']))\n",
    "                    break\n",
    "                    \n",
    "                cf_arr = np.concatenate((cf_arr, [current_obj]))\n",
    "                current_de_mi = decoder_mi(A, Sigma_Z)\n",
    "                de_mi_arr = np.concatenate((de_mi_arr, [current_de_mi]))\n",
    "                \n",
    "                Sigma_Y_hat = A @ A.T + Sigma_Z\n",
    "                recon_err = reconstruction_error(Sigma_Y_hat, Sigma_Y)\n",
    "                \n",
    "                # For the first iteration, update the current decoder inputs and value of the cost function\n",
    "                if i == 0:\n",
    "                    current_decoder_inputs = np.concatenate((A.reshape((n*m)), Sigma_Z.reshape((n*n))))\n",
    "                    previous_obj = current_obj\n",
    "                # From the second iteration,\n",
    "                # 1. Compute the Frobenius norm of the difference between\n",
    "                #    i. A and itself in the previous iteration\n",
    "                #    ii. Sigma_Z and itself in the previous iteration\n",
    "                # 2. Compute the difference between the cost function and itself in the previous iteration\n",
    "                # 3. Update the current dencoder inputs and value of the cost function                \n",
    "                else:\n",
    "                    A_diff = A - current_decoder_inputs[:n*m].reshape((n, m))\n",
    "                    A_norm_diff = LA_norm(A_diff, 'fro')\n",
    "                    Sigma_Z_diff = Sigma_Z - current_decoder_inputs[n*m:n*m+n*n].reshape((n, n))\n",
    "                    Sigma_Z_norm_diff = LA_norm(Sigma_Z_diff, 'fro')\n",
    "                    obj_diff = previous_obj - current_obj\n",
    "                    previous_obj = current_obj\n",
    "                    current_decoder_inputs = np.concatenate((A.reshape((n*m)), Sigma_Z.reshape((n*n))))\n",
    "                    # Check for convergence\n",
    "                    if A_norm_diff <= TOL_ERR and Sigma_Z_norm_diff <= TOL_ERR and round(obj_diff, 8) == 0:\n",
    "                        print(colored('\\nThe algorithm converges after {} iterations.\\n'.format(i+1), 'blue', attrs=['bold']))\n",
    "                        break\n",
    "                    elif i == MAX_ITERS - 1:\n",
    "                        print(colored('\\nThe algorithm reaches the maximum number of iterations without convergence.\\n', 'red', attrs=['bold']))\n",
    "        \n",
    "        # Compute Sigma_X and Sigma_Y_hat  \n",
    "        Sigma_X = B @ Sigma_Y @ B.T + Sigma_W\n",
    "        Sigma_Y_hat = A @ A.T + Sigma_Z\n",
    "        \n",
    "        sol = np.concatenate((A.reshape((n*m)), B.reshape((m*n)),\n",
    "                              Sigma_Z.reshape((n*n)), Sigma_W.reshape((m*m)),\n",
    "                              [current_obj], [current_en_mi], [current_de_mi],\n",
    "                              [len(cf_arr)], [len(en_mi_arr)], [len(de_mi_arr)],\n",
    "                              Sigma_X.reshape((m*m)), Sigma_Y_hat.reshape((n*n)),\n",
    "                              cf_arr, en_mi_arr, de_mi_arr, [recon_err]))\n",
    "        return sol\n",
    "    except Exception as e:\n",
    "        print(colored('\\nThe algorithm fails to converge after {} iterations due to {}.\\n'.format(i+1, e), 'red', attrs=['bold']))\n",
    "         \n",
    "        Sigma_X = B @ Sigma_Y @ B.T + Sigma_W\n",
    "        Sigma_Y_hat = A @ A.T + Sigma_Z\n",
    "        \n",
    "        sol = np.concatenate((A.reshape((n*m)), B.reshape((m*n)),\n",
    "                              Sigma_Z.reshape((n*n)), Sigma_W.reshape((m*m)),\n",
    "                              [current_obj], [current_en_mi], [current_de_mi], \n",
    "                              [len(cf_arr)], [len(en_mi_arr)], [len(de_mi_arr)],\n",
    "                              Sigma_X.reshape((m*m)), Sigma_Y_hat.reshape((n*n)),\n",
    "                              cf_arr, en_mi_arr, de_mi_arr, [recon_err]))\n",
    "        return sol"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d9e815f",
   "metadata": {},
   "source": [
    "## I. Optimal solutions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eff45dfc",
   "metadata": {},
   "source": [
    "### 1. Inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7cc2f26c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[34mCovariance matrix of Y:\u001b[0m\n",
      "[[1.   0.18 0.12]\n",
      " [0.18 1.   0.06]\n",
      " [0.12 0.06 1.  ]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Given:\n",
    "1. Maximum number of iterations: MAX_ITERS = 10,000\n",
    "2. Dimensions of the matrix: n = 3 and m = 2\n",
    "3. Tolerable error: TOL_ERR = 1e-8\n",
    "4. A nxn positive definite matrix Sigma_Y\n",
    "\"\"\"\n",
    "\n",
    "MAX_ITERS = 10000\n",
    "n, m = 3, 2\n",
    "TOL_ERR = 1e-8\n",
    "\n",
    "Sigma_Y = np.array([[1, 0.18, 0.12],\n",
    "                   [0.18, 1, 0.06],\n",
    "                   [0.12, 0.06, 1]])\n",
    "\n",
    "print(colored('Covariance matrix of Y:', 'blue', attrs=['bold']))\n",
    "print(np.round(Sigma_Y, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c8c9a10",
   "metadata": {},
   "source": [
    "### 2. Numerical results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83772d29",
   "metadata": {},
   "source": [
    "#### Case 1: gamma < 1 -- choose gamma = 0.98"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "729ff204",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31ma. Arbitrary Sigma_Z\n",
      "\u001b[0m\n",
      "\u001b[1mGiven encoder X:\u001b[0m\n",
      "Initial matrix B:\n",
      "[[0.6211 0.4213 0.6618]\n",
      " [0.0913 0.1311 0.0964]]\n",
      "\n",
      "Initial covariance matrix of W:\n",
      "[[ 2.4696 -0.3628]\n",
      " [-0.3628  0.6022]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1498 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]]\n",
      "\n",
      "Matrix B:\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[1.   0.18 0.12]\n",
      " [0.18 1.   0.06]\n",
      " [0.12 0.06 1.  ]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 1. -0.]\n",
      " [-0.  1.]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "4.1477\n",
      "\n",
      "Mutual information of the encoder:\n",
      "0.0\n",
      "\n",
      "Mutual information of the decoder:\n",
      "0.0\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[ 1. -0.]\n",
      " [-0.  1.]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[1.   0.18 0.12]\n",
      " [0.18 1.   0.06]\n",
      " [0.12 0.06 1.  ]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven decoder Y_hat:\u001b[0m\n",
      "Initial matrix A:\n",
      "[[0.6774 0.6646]\n",
      " [0.1673 0.451 ]\n",
      " [0.4128 0.2937]]\n",
      "\n",
      "Initial covariance matrix of Z:\n",
      "[[ 2.5322  0.7089 -1.3224]\n",
      " [ 0.7089  0.9246 -0.3362]\n",
      " [-1.3224 -0.3362  0.8986]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1455 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]]\n",
      "\n",
      "Matrix B:\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[1.   0.18 0.12]\n",
      " [0.18 1.   0.06]\n",
      " [0.12 0.06 1.  ]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 1. -0.]\n",
      " [-0.  1.]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "4.1477\n",
      "\n",
      "Mutual information of the encoder:\n",
      "0.0\n",
      "\n",
      "Mutual information of the decoder:\n",
      "0.0\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[ 1. -0.]\n",
      " [-0.  1.]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[1.   0.18 0.12]\n",
      " [0.18 1.   0.06]\n",
      " [0.12 0.06 1.  ]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31mb. Diagonalized Sigma_Z\n",
      "\u001b[0m\n",
      "\u001b[1mGiven encoder X:\u001b[0m\n",
      "Initial matrix B:\n",
      "[[0.4815 0.2557 0.16  ]\n",
      " [0.7554 0.0526 0.5054]]\n",
      "\n",
      "Initial covariance matrix of W:\n",
      "[[ 2.1963 -0.4423]\n",
      " [-0.4423  0.3971]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 4105 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[0.0259 0.4801]\n",
      " [0.0183 0.3402]\n",
      " [0.0117 0.2167]]\n",
      "\n",
      "Matrix B:\n",
      "[[0.0224 0.0138 0.0082]\n",
      " [0.4158 0.2563 0.1514]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[0.7689 0.     0.    ]\n",
      " [0.     0.8839 0.    ]\n",
      " [0.     0.     0.9529]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 0.9991 -0.0172]\n",
      " [-0.0172  0.6804]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "4.152\n",
      "\n",
      "Mutual information of the encoder:\n",
      "0.1932\n",
      "\n",
      "Mutual information of the decoder:\n",
      "0.1965\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[1. 0.]\n",
      " [0. 1.]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[1.     0.1638 0.1043]\n",
      " [0.1638 1.     0.0739]\n",
      " [0.1043 0.0739 1.    ]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.0245\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven decoder Y_hat:\u001b[0m\n",
      "Initial matrix A:\n",
      "[[0.094  0.1725]\n",
      " [0.9105 0.7884]\n",
      " [0.8471 0.8211]]\n",
      "\n",
      "Initial covariance matrix of Z:\n",
      "[[0.8371 0.     0.    ]\n",
      " [0.     0.0126 0.    ]\n",
      " [0.     0.     0.9841]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 4426 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[0.4462 0.1789]\n",
      " [0.3162 0.1268]\n",
      " [0.2014 0.0807]]\n",
      "\n",
      "Matrix B:\n",
      "[[0.3865 0.2382 0.1407]\n",
      " [0.1549 0.0955 0.0564]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[0.7689 0.     0.    ]\n",
      " [0.     0.8839 0.    ]\n",
      " [0.     0.     0.9529]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 0.7238 -0.1107]\n",
      " [-0.1107  0.9556]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "4.152\n",
      "\n",
      "Mutual information of the encoder:\n",
      "0.1932\n",
      "\n",
      "Mutual information of the decoder:\n",
      "0.1965\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[1. 0.]\n",
      " [0. 1.]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[1.     0.1638 0.1043]\n",
      " [0.1638 1.     0.0739]\n",
      " [0.1043 0.0739 1.    ]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.0245\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gamma = 0.98\n",
    "\n",
    "for is_Sigma_Z_diagonal in (0, 1):\n",
    "    if is_Sigma_Z_diagonal == 0:\n",
    "        print(colored('a. Arbitrary Sigma_Z\\n', 'red', attrs=['bold']))\n",
    "    else: \n",
    "        print(colored('b. Diagonalized Sigma_Z\\n', 'red', attrs=['bold']))  \n",
    "    for flag in (0, 1):\n",
    "        print_comprehensive_results(gamma, flag, m, n, is_Sigma_Z_diagonal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d432718e",
   "metadata": {},
   "source": [
    "#### Case 2: gamma = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6565e242",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31ma. Arbitrary Sigma_Z\n",
      "\u001b[0m\n",
      "\u001b[1mGiven encoder X:\u001b[0m\n",
      "Initial matrix B:\n",
      "[[0.2003 0.5233 0.6432]\n",
      " [0.3387 0.3928 0.9353]]\n",
      "\n",
      "Initial covariance matrix of W:\n",
      "[[ 2.2064 -0.3799]\n",
      " [-0.3799  0.3501]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 14 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[ 0.1137  0.1372]\n",
      " [ 0.3528  0.1174]\n",
      " [ 0.3178 -0.1509]]\n",
      "\n",
      "Matrix B:\n",
      "[[ 0.0185  0.3317  0.2957]\n",
      " [ 0.1396  0.1027 -0.1738]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[ 0.9682  0.1238  0.1046]\n",
      " [ 0.1238  0.8618 -0.0344]\n",
      " [ 0.1046 -0.0344  0.8762]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[0.7869 0.0031]\n",
      " [0.0031 0.9426]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "4.2323\n",
      "\n",
      "Mutual information of the encoder:\n",
      "0.1494\n",
      "\n",
      "Mutual information of the decoder:\n",
      "0.1494\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[ 1. -0.]\n",
      " [-0.  1.]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[1.   0.18 0.12]\n",
      " [0.18 1.   0.06]\n",
      " [0.12 0.06 1.  ]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven decoder Y_hat:\u001b[0m\n",
      "Initial matrix A:\n",
      "[[0.1213 0.196 ]\n",
      " [0.7603 0.8096]\n",
      " [0.6128 0.6431]]\n",
      "\n",
      "Initial covariance matrix of Z:\n",
      "[[ 2.4202  1.387  -0.2773]\n",
      " [ 1.387   1.8642 -0.0577]\n",
      " [-0.2773 -0.0577  0.3332]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 33 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[ 0.2753 -0.1125]\n",
      " [ 0.1798  0.619 ]\n",
      " [ 0.722  -0.0284]]\n",
      "\n",
      "Matrix B:\n",
      "[[ 0.1726  0.107   0.6948]\n",
      " [-0.2267  0.6623 -0.041 ]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[ 0.9116  0.2001 -0.0819]\n",
      " [ 0.2001  0.5845 -0.0522]\n",
      " [-0.0819 -0.0522  0.478 ]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 0.4316 -0.027 ]\n",
      " [-0.027   0.5634]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "4.2323\n",
      "\n",
      "Mutual information of the encoder:\n",
      "0.7085\n",
      "\n",
      "Mutual information of the decoder:\n",
      "0.7085\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[ 1. -0.]\n",
      " [-0.  1.]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[1.   0.18 0.12]\n",
      " [0.18 1.   0.06]\n",
      " [0.12 0.06 1.  ]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31mb. Diagonalized Sigma_Z\n",
      "\u001b[0m\n",
      "\u001b[1mGiven encoder X:\u001b[0m\n",
      "Initial matrix B:\n",
      "[[0.897  0.6367 0.5311]\n",
      " [0.6525 0.6446 0.7896]]\n",
      "\n",
      "Initial covariance matrix of W:\n",
      "[[ 1.7149 -0.9195]\n",
      " [-0.9195  0.9267]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 687 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[0.0012 0.6816]\n",
      " [0.0759 0.2639]\n",
      " [0.1795 0.1757]]\n",
      "\n",
      "Matrix B:\n",
      "[[-0.0331  0.0711  0.1792]\n",
      " [ 0.6452  0.1424  0.0898]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[0.5354 0.     0.    ]\n",
      " [0.     0.9246 0.    ]\n",
      " [0.     0.     0.9369]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 0.9625 -0.0277]\n",
      " [-0.0277  0.5068]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "4.2323\n",
      "\n",
      "Mutual information of the encoder:\n",
      "0.3597\n",
      "\n",
      "Mutual information of the decoder:\n",
      "0.3597\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[1. 0.]\n",
      " [0. 1.]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[1.   0.18 0.12]\n",
      " [0.18 1.   0.06]\n",
      " [0.12 0.06 1.  ]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmIklEQVR4nO3de5RcZZnv8e+vqi9J5w4JtySQBIMORMTQRPCgclAg6kgckWNwzgizZg7DJYLHwRHGWYyAjuIoM+qgmEEQZTQiDsdGAqjIRVEwHeSWQCCEAAkRmpALJOTS6ef8sXd1KtXV3TtJV1Vffp+1avXeb+3Lk72afngv+30VEZiZmZXK1ToAMzPrn5wgzMysLCcIMzMrywnCzMzKcoIwM7Oy6modQF8ZP358TJkypdZhmJkNKIsXL34lIiaU+27QJIgpU6bQ2tpa6zDMzAYUSc91911Fm5gkzZa0TNJySReX+f4sSW2SHk4/f5uWHyXp95KWSHpU0scqGaeZmXVVsRqEpDxwNXASsApYJKklIpaWHPrjiJhXUrYZ+EREPC3pIGCxpDsjYn2l4jUzs11VsgYxC1geESsiYhuwAJiT5cSIeCoink63XwReBsq2kZmZWWVUMkFMBF4o2l+VlpU6LW1GulnS5NIvJc0CGoBnynx3tqRWSa1tbW19FbeZmVH7Ya63AlMi4kjgl8ANxV9KOhD4AfDXEdFRenJEzI+I5ohonjDBFQwzs75UyQSxGiiuEUxKyzpFxNqI2JruXgscXfhO0mjgNuBzEfFABeM0M7MyKpkgFgHTJU2V1ADMBVqKD0hrCAWnAk+k5Q3ALcD3I+LmCsZoZmbdqFiCiIh2YB5wJ8kf/psiYomkyyWdmh52QTqU9RHgAuCstPx/Ae8GzioaAntUJeLctLWdq36xjD8+v64SlzczG7Aq+qJcRCwEFpaUXVq0fQlwSZnzbgRurGRsBVu27+Abv17OviMbefvB46pxSzOzAaHWndQ1l88JgB0dXjjJzKzYkE8QuTRBdHhlPTOzXQz5BJGXaxBmZuU4QRSamFyDMDPbxZBPELm0BtHhGoSZ2S6GfILY2Uld40DMzPqZIZ8g0vzgJiYzsxJDPkFIIic3MZmZlRryCQKSZibXIMzMduUEQdJR7RqEmdmunCBIaxBOEGZmu3CCIHlZzk1MZma7coIgmW7DTUxmZrtygsCd1GZm5ThBkHRS+0U5M7NdOUEA+ZzfgzAzK+UEgTupzczKqWiCkDRb0jJJyyVdXOb7syS1FS0r+rdF350p6en0c2Yl43QntZlZVxVbclRSHrgaOAlYBSyS1BIRS0sO/XFEzCs5dx/gn4FmIIDF6bkVWTg6nxPtThBmZruoZA1iFrA8IlZExDZgATAn47mnAL+MiFfTpPBLYHaF4vQoJjOzMiqZICYCLxTtr0rLSp0m6VFJN0uavDvnSjpbUquk1ra2tj0ONO+pNszMuqh1J/WtwJSIOJKklnDD7pwcEfMjojkimidMmLDHQXiqDTOzriqZIFYDk4v2J6VlnSJibURsTXevBY7Oem5fykl0uInJzGwXlUwQi4DpkqZKagDmAi3FB0g6sGj3VOCJdPtO4GRJ4ySNA05OyyrCNQgzs656HMWUjkT6fkT85e5eOCLaJc0j+cOeB66LiCWSLgdaI6IFuEDSqUA78CpwVnruq5KuIEkyAJdHxKu7G0NWuZzY4fxgZraLHhNEROyQdIikhnQk0m6JiIXAwpKyS4u2LwEu6ebc64DrdveeeyLvFeXMzLrI8h7ECuB+SS3ApkJhRFxVsaiqzE1MZmZdZUkQz6SfHDCqsuHURs5TbZiZddFrgoiIywAkNUXE5sqHVH35nNjW7ulczcyK9TqKSdJxkpYCT6b7b5P0rYpHVkV+k9rMrKssw1z/nWTqi7UAEfEI8O4KxlR1Ob9JbWbWRab3ICLihZKiHRWIpWZcgzAz6ypLJ/ULkt4JhKR64EJ2vtA2KHhFOTOzrrLUIM4BzieZLG81cFS6P2h4RTkzs66yjGJ6BdjtN6kHEjcxmZl11W2CkPRNksV6yoqICyoSUQ24k9rMrKuemphagcXAMGAm8HT6OQpoqHhkVeQahJlZV93WICLiBgBJ5wLHR0R7un8N8JvqhFcdeXmqDTOzUlk6qccBo4v2R6Zlg0Yu5yYmM7NSWYa5fhn4o6S7AZG8JPf5SgZVbXnPxWRm1kWWUUzXS7odeAdJp/VnI+JPFY+sinI5vwdhZlYqSw0CYBbwrnQ7SNaSHjTyObzkqJlZiSyT9X2Z5O3ppennAkn/kuXikmZLWiZpuaSLezjuNEkhqTndr5d0g6THJD0hqeyiQn3FndRmZl1lqUF8ADgqIjoAJN0A/BH4x55OSpcrvRo4CVgFLJLUEhFLS44bRZKAHiwqPh1ojIi3SmoClkr6UUSszPbP2j3upDYz6yrTZH3A2KLtMRnPmQUsj4gV6XKlC4A5ZY67ArgS2FJUFsAISXXAcGAbsDHjfXebO6nNzLrKkiC+RDKK6Xtp7WEx8MUM500EimeBXZWWdZI0E5gcEbeVnHszyfKma4Dnga9GxKulN5B0tqRWSa1tbW0ZQirPS46amXWVZRTTjyTdAxyTFvXJKCZJOeAq4KwyX88imVL8IJJ3Ln4j6VcRsaIktvnAfIDm5uY9/gufy8md1GZmJbJ0Uv8FsDkiWiKiBdgi6cMZrr0amFy0PyktKxgFzADukbQSOBZoSTuqPw7cERHbI+Jl4H6gOcM994g7qc3MusrSxPTPEbGhsBMR64F/znDeImC6pKmSGoC5QEvRdTZExPiImBIRU4AHgFMjopWkWelEAEkjSJLHk9n+SbsvqUFAuBZhZtYpS4Iod0yWpql2YB5wJ8kCQzdFxBJJl0s6tZfTrwZGSlpCkmiuj4hHM8S6R/ISAK5EmJntlGWYa6ukq0j+aEOyWNDiLBePiIXAwpKyS7s59oSi7ddJhrpWRT5NgTs6gnxO1bqtmVm/lqUG8UmSYaY/Tj9bGWQryuVyhRqEqxBmZgVZmoo2Ad2+BT0YFJqY3FFtZrZTrwlC0mHARcCU4uMj4sTKhVVdhWYlvyxnZrZTlj6InwDXANeSvJsw6OQKndSuQZiZdcqSINoj4tsVj6SGOmsQThBmZp2ydFLfKuk8SQdK2qfwqXhkVZRzE5OZWRdZahBnpj8/U1QWwLS+D6c2Ot+D8KJBZmadsoximlqNQGqp8B5EuzOEmVmnbpuYJP1D0fbpJd9lWjBooMi5BmFm1kVPfRBzi7ZLV3SbXYFYasbDXM3MuuopQaib7XL7A5pHMZmZddVTgohutsvtD2h5T7VhZtZFT53Ub5O0kaS2MDzdJt0fVvHIqshTbZiZddVtgoiIfDUDqaWcm5jMzLrI8qLcoLdzPQgnCDOzAicI3EltZlZOT+9BNO7txSXNlrRM0nJJ3U4ZLuk0SZGuR10oO1LS7yUtkfSYpIr1e3g9CDOzrnqqQfweQNIP9uTCkvIkq9C9HzgcOEPS4WWOGwVcCDxYVFYH3AicExFHACcA2/ckjix2dlJX6g5mZgNPT6OYGiR9HHinpI+UfhkR/93LtWcByyNiBYCkBcAcYGnJcVcAV7LrXE8nA49GxCPpvdb2cq+9kitactTMzBI91SDOAd4FjAU+VPL58wzXngi8ULS/Ki3rJGkmMDkibis59zAgJN0p6aHiaT9Kzj9bUquk1ra2tgwhledOajOzrnoa5vpb4LeSWiPiu319Y0k54CrgrG7iOh44BtgM3CVpcUTcVRLjfGA+QHNz8x7/dXcntZlZV1mm+/6BpAuAd6f79wLXRERvfQKrgclF+5PSsoJRwAzgHiX/B38A0CLpVJLaxn0R8QqApIXATGCXBNFXvB6EmVlXWYa5fgs4Ov35LZI/1FlWmFsETJc0VVIDyeR/LYUvI2JDRIyPiCkRMQV4ADg1IlqBO4G3SmpKO6zfQ9e+iz6T95KjZmZdZKlBHBMRbyva/7WkR3o7KSLaJc0j+WOfB66LiCWSLgdaI6Klh3PXSbqKJMkEsLBMP0WfKTQxtTtBmJl1ypIgdkg6NCKeAZA0DdiR5eIRsRBYWFJ2aTfHnlCyfyPJUNeKa6hLKlLbPc7VzKxTlgTxGeBuSStIJuo7BPjrikZVZQ3pknLb2p0gzMwKsiw5epek6cCb06JlEbG1smFVV6EG4QRhZrZTlhoEaUJ4tMKx1ExngnATk5lZJ0/Wx84EsXW7E4SZWYETBNDoGoSZWReZmpgkTSTpnO48PiLuq1RQ1VbopN7qPggzs069JghJVwIfI3lRrTC8NYBBkyAk0ZDPuZPazKxIlhrEh4E3D7aRS6Ua6pwgzMyKZemDWAHUVzqQWmuoy7FtR6b3/8zMhoQsNYjNwMOS7gI6axERcUHFoqqBhnzOo5jMzIpkSRAtFE2yN1g11uc8isnMrEiWN6lvSGdjPSwtWpZhqu8Bx53UZma7yjKK6QTgBmAlyVxMkyWdOZiGuYI7qc3MSmVpYvoacHJELAOQdBjwI5I1IgaNpJPaCcLMrCDLKKb6QnIAiIinGISjmhryOb8oZ2ZWJEsNolXStexcm+EvgdbKhVQbDXU5Nm5pr3UYZmb9RpYaxLkkb1FfkH6WpmW9kjRb0jJJyyVd3MNxp0kKSc0l5QdLel3SRVnutzca6/LugzAzK5JlFNNW4Kr0k5mkPHA1cBKwClgkqSUilpYcNwq4EHiwzGWuAm7fnfvuqca6HNva/aKcmVlBtzUISTelPx+T9GjpJ8O1ZwHLI2JFRGwDFgBzyhx3BXAlsKXk/h8GngWWZPun7B13UpuZ7aqnGsSF6c8/38NrTwReKNpfBbyj+ABJM4HJEXGbpM8UlY8EPktS+6h48xL4PQgzs1Ld1iAiYk26eV5EPFf8Ac7b2xtLypE0If19ma8/D/xbRLzeyzXOltQqqbWtrW2v4vF7EGZmu8rSSX1SmbL3ZzhvNTC5aH9SWlYwCpgB3CNpJXAs0JJ2VL8D+Epa/ingHyXNK71BRMyPiOaIaJ4wYUKGkLrXUOdhrmZmxbptYpJ0LklNYVpJn8Mo4P4M114ETJc0lSQxzAU+XvgyIjYA44vudw9wUUS0Au8qKv888HpE/EeGe+6xRtcgzMx20VMfxA9JRhB9CSgeovpaRLza24Ujoj39v/47gTxwXUQskXQ50BoR/WoCwIa6HO0dQUdHkMup1uGYmdVctwki/T/8DcAZAJL2A4YBIyWNjIjne7t4RCwEFpaUXdrNsSd0U/753u7TFxqK1qUelstX45ZmZv1ar30Qkj4k6WmSIaf3kkzaV5V3E6rJ61Kbme0qSyf1F0g6kJ+KiKnAe4EHKhpVDTTWFRKEX5YzM4NsCWJ7RKwFcpJyEXE30NzbSQNNZxOTaxBmZkC2yfrWpy+u3Qf8l6SXgU2VDav6GuuSfgcnCDOzRJYaxBzgDeD/AncAzwAfqmRQtVDcSW1mZtkm69sEIGk0cGvFI6qRQh/Elu1OEGZmkG3J0b8DLiOZTK+DZNnRAKZVNrTqampIHsXmbV4TwswMsvVBXATMiIhXKh1MLY1sTB7Fpq0exWRmBtn6IJ4BNlc6kFprakw6qV2DMDNLZKlBXAL8TtKDwNZCYURcULGoamBEg2sQZmbFsiSI7wC/Bh4j6YMYlEakNYhNW12DMDODbAmiPiI+XfFIaqzQSb3JTUxmZkC2Pojb04V5DpS0T+FT8ciqLJ8Tw+pzbN7mJiYzM8hWgzgj/XlJUdmgG+YKyUim193EZGYG9JIg0mVBL46IH1cpnppqaqhjsxOEmRnQSxNTRHQAn6lSLDXX1JBnk5uYzMyAbH0Qv5J0kaTJg7kPApImJo9iMjNLZEkQHwPOJ5nNdXH6ac1ycUmzJS2TtFzSxT0cd5qkkNSc7p8kabGkx9KfJ2a5395qaqxzDcLMLJVlsr6pe3JhSXngauAkYBWwSFJLRCwtOW4UcCHwYFHxK8CHIuJFSTNI1rWeuCdx7I6RjXnWrH+j0rcxMxsQsiw5Wi/pAkk3p595kuozXHsWsDwiVkTENmABydThpa4AriSZDBCAiPhjRLyY7i4BhktqzHDPvdLU4CYmM7OCLE1M3waOBr6Vfo5Oy3ozEXihaH8VJbUASTOByRFxWw/XOQ14KCK2ln6Rvp/RKqm1ra0tQ0g9G+FOajOzTlnegzgmIt5WtP9rSY/s7Y3TIbRXAWf1cMwRJLWLk8t9HxHzgfkAzc3NsbcxjWis82R9ZmapLDWIHZIOLexImgZk+d/s1cDkov1JaVnBKGAGcI+klcCxQEtRR/Uk4BbgExHxTIb77bURjXVs3xFedtTMjGw1iM8Ad0taQbJY0CHAX2c4bxEwXdJUksQwF/h44cuI2ACML+xLuge4KCJaJY0FbiN5Se/+bP+UvdfUkEzY9/rWdvapa6jWbc3M+qVuaxCSTk83VwDTgQuATwJvjoi7e7twRLQD80hGID0B3BQRSyRdLunUXk6fB7wJuFTSw+lnv97/OXtnzPCk733DG9srfSszs36vpxrEJcBPgJ9GxEzg0d29eEQsBBaWlF3azbEnFG1/AfjC7t5vb40bkdQa1m3exlRGVPv2Zmb9Sk8JYq2kXwBTJbWUfhkRvdUCBpxxTWmC2LStxpGYmdVeTwnig8BM4AfA16oTTm3tU0gQm93EZGbWbYJIX257QNI7I2LvXzIYAMaOSPogXIMwM8s2immcpC8CU4qPj4iqzI9UTaMa66jLiXWbnSDMzLIkiJ8A1wDXku39hwFLEmObGpwgzMzIliDaIyLL1BqDwrimetZtch+EmVmWN6lvlXTeYF+TumBcUwOvugZhZpapBnFm+rN4ZblBuSY1wLgR9Tz7yqZah2FmVnMVWw9ioBrX1MDiTetrHYaZWc11myAkfaSnEyPiv/s+nNrbZ0QD6zdvo6MjyOVU63DMzGqmpxrEh3r4LoBBmSAOGDOM9o7glde3st/oYbUOx8ysZnp6US7LjK2DzoFjhgOwZsMWJwgzG9KyjGIaUg4ckySFNRu8NrWZDW1OECUOGpvUIF5cv6WXI83MBjcniBLjmupprMu5BmFmQ55HMZWQxEFjh/PiBtcgzGxoq+goJkmzga8DeeDaiPhyN8edBtwMHBMRrWnZJcDfkMz/dEFE3Nnb/frKgWOGsWa9axBmNrRVbBSTpDxwNXASsApYJKklIpaWHDcKuBB4sKjscJI1rI8ADgJ+JemwiKjKZIETxw7n3qeGxAznZmbdytQHIemDkv5B0qWFT4bTZgHLI2JFurbEAmBOmeOuAK4Eitt05gALImJrRDwLLE+vVxXTJozk5de2snGLJ+0zs6Gr1wQh6RrgY8AnAQGnA4dkuPZE4IWi/VVpWfG1ZwKTI+K23T03Pf9sSa2SWtva+u7/+A+dkKxH/czLr/fZNc3MBposNYh3RsQngHURcRlwHHDY3t5YUg64Cvj7Pb1GRMyPiOaIaJ4wYcLehtTpTfuNBGC5E4SZDWFZZnMt9NZulnQQsBY4MMN5q4HJRfuT0rKCUcAM4B5JAAcALZJOzXBuRR28TxMN+RzL25wgzGzoylKD+LmkscC/Ag8BK4EfZThvETBd0lRJDSSdzi2FLyNiQ0SMj4gpETEFeAA4NR3F1ALMldQoaSowHfhD9n/W3qnL55gyvslNTGY2pGWZ7vuKdPOnkn4ODIuIDRnOa5c0D7iTZJjrdRGxRNLlQGtEtPRw7hJJNwFLgXbg/GqNYCp4ywGjWbTy1Wre0sysX+k1QUj6RJkyIuL7vZ0bEQuBhSVlZUdARcQJJftfBL7Y2z0q5ajJY2l55EVe2riF/T1pn5kNQVn6II4p2h4GvJekqanXBDGQvW3yWAAefmE9pxxxQG2DMTOrgSxNTJ8s3k/7IxZUKqD+4oiDRlOXkxOEmQ1ZezJZ3yZg0C9DOqw+zxEHjWbRs+6HMLOhKUsfxK0kcy9BklAOB35SyaD6i//xpvHMv28Fr29tZ2RjltY4M7PBI8tfva8WbbcDz0XEqgrF068c/6bxfOueZ/jDs2s58S371zocM7OqytLE9IGIuDf93B8RqyRdWfHI+oGZh4xjWH2Oe5d54j4zG3qyJIiTypS9v68D6Y+G1ed51/QJ/GLpS0RE7yeYmQ0i3SYISedKegx4i6RHiz7PAo9WL8TaOuWIA1izYQuPrur13UAzs0Glpz6IHwK3A18CLi4qfy0ihszQnvf92X7U58XPHn6x890IM7OhoNsaRDpX0krgsySjmAqfkZIOrk54tTe2qYH3/dn+3PLHVWxtr+psH2ZmNZWlD+I24Ofpz7uAFSQ1iyHjY8dMZt3m7fxq6cu1DsXMrGp6TRAR8daIODL9OZ1kZbffVz60/uNd0ydw0Jhh3NT6Qu8Hm5kNErv9JnVEPAS8owKx9Fv5nPjo0ZO47+k2Vq3bXOtwzMyqIsuSo58u+lwk6YfAi1WIrV+ZO+tg8hLf/e2ztQ7FzKwqstQgRhV9Gkn6IuZUMqj+6KCxw5lz1EQW/OEFXt20rdbhmJlVXJbZXC+rRiADwbknTOOnD63ie/c/y6dPfnOtwzEzq6huE4Skbld8A4iIU3u7uKTZwNdJVpS7NiK+XPL9OcD5wA7gdeDsiFgqqR64FpiZxvj9iPhSb/ertDftN4qTD9+f7/1uJX9z/DTGNNXXOiQzs4rpqYnpOGAS8BuSCfu+VvLpkaQ8cDXJtByHA2dIOrzksB+mo6OOAr4CXJWWnw40RsRbgaOBv5M0JeO/qaI+9b7DeG1rO9+6Z3mtQzEzq6ieEsQBwD8CM0hqAScBrxQm7stw7VnA8ohYERHbSBYZ2qXvIiI2Fu2OYOe04gGMkFQHDAe2AcXH1szhB43mI2+fxPW/W+kRTWY2qPX0JvWOiLgjIs4EjgWWA/dImpfx2hOB4hcHVqVlu5B0vqRnSGoQF6TFN5MsTLQGeB74arnpPSSdLalVUmtbW/VmXL3olMMQcOUdy6p2TzOzautxFJOkRkkfAW4k6Sv4BnBLXwYQEVdHxKEkU3r8U1o8i6Rf4iCS1ev+XtK0MufOj4jmiGieMGFCX4bVowPHDOec9xzKrY+8yH1PeSpwMxuceprN9fskb0zPBC6LiGMi4oqIWJ3x2quByUX7k9Ky7iwAPpxufxy4IyK2R8TLwP1Ac8b7VsW5JxzKtPEj+Nz/e4w3tnmOJjMbfHqqQfxvYDpwIfA7SRvTz2uSsvQHLAKmS5oqqQGYC+wyMkrS9KLdDwJPp9vPAyemx4wgaeJ6Mss/qFqG1ef5l4+8lRdefYOv/sJNTWY2+HQ7zDUidnsajpLz29P+ijtJhrleFxFLJF0OtEZECzBP0vuA7cA64Mz09KuB6yUtAQRcHxH9bg2KY6ftyyeOO4Tv/vZZ3nPYBN59WPWauczMKk2DZaW05ubmaG1trfp9t2zfwan/8Vte3bSdOz71LsaPbKx6DGZme0rS4ogo24S/V7UES5qavnHG23lty3bOu/EhtrV31DokM7M+4QTRB95ywGi+8tEj+cPKV/n8rUu8frWZDQq9zsVk2cw5aiJPrHmNa+59hsnjmjj3hENrHZKZ2V5xguhD/3DKm3lx/RtceceTjGuqZ+6sIbMyq5kNQk4QfSiXE189/W2sf2M7l9zyGDsi+Mt3HFLrsMzM9oj7IPpYQ12O+X91NP/zzfvxuVse5zv3PlPrkMzM9ogTRAUMq8/znb86mj8/8kC+dPuTfOHnS2nf4dFNZjawuImpQurzOb4+9+3sO6KBa3/7LE/8aSPfPGMm+4xoqHVoZmaZuAZRQfmcuGzODP71o0eyaOU6PvTN3/LgirW1DsvMLBMniCo4vXkyN59zHPmcmPufD3DZrUs8wZ+Z9XtOEFVy5KSx3PGpd/GJYw/h+vtXcvK/38vtj63xS3Vm1m85QVRRU0Mdl82ZwY/+z7E01ddx7n89xMe+8wCLn+uyFpKZWc05QdTAcYfuy20XHM8X/2IGz7S9zmnf/j0f+87vufepNtcozKzf8GyuNbZ5Wzs/fPB5/vM3K3hp41amjR/BGbMO5rSjJ3nEk5lVXE+zuTpB9BNb23fw80fW8MM/PM/i59ZRlxPHHbovs2ccwClHHOBpxM2sIpwgBpgn/7SRnz38Irc/toaVazeTE7x14hiOO3Q87zx0X5qnjKOpwa+wmNneq1mCkDQb+DrJinLXRsSXS74/Bzgf2AG8DpwdEUvT744EvgOMBjqAYyJiS3f3GkwJoiAiePJPr3Hnkj9x//JX+OPz62nvCPI5MX2/kRxx0BhmTBzNjIljeNOEkYxzk5SZ7aaaJAhJeeAp4CRgFcka1WcUEkB6zOiI2JhunwqcFxGzJdUBDwF/FRGPSNoXWB8R3b48MBgTRKlNW9tpfW4di559lSUvbuCx1Rt55fWtnd+PGV7PlPEjmLpvEwfv08R+o4ex/+hh7D+6kf1HD2PfEQ3U5T0uwcx26ilBVLKdYhawPCJWpEEsAOYAnQmikBxSI4BCtjoZeDQiHkmP8+vHwIjGOt5z2ATeU7T29csbt/D4ixtY0baJZ1/ZxMq1m1i0ch0/e+RFSnO/BKMa6xjTVM+Y4bt+RjTUMaw+z/CGfPKzPs/whhzD65P9YfV56vM56vMinxP1+Rx1OVGXy1GXV/JJt+tzOfI5UZcTEkiq8pMys75QyQQxEXihaH8V8I7SgySdD3waaABOTIsPA0LSncAEYEFEfKWCsQ5Y+40exomjh3HiW3Ytb9/RwdpN23hp4xZe2riVlzZu4eXXtrJh8zY2vLG98/OnDVvY8EY7b2xrZ/P2HV2SSl+RICchkp8IcgKh5KfSZEIybXrhuEKC2WW/7PWzJaFyh5WWqcwdyp6XMY6yke3F9cxK/dmBo/nmGW/v8+vWvKczIq4Grpb0ceCfgDNJ4joeOAbYDNyVVoPuKj5X0tnA2QAHH+zFeYrV5XNp89KwzOdEBNt2dLBlWwdvbN+RfLYlP7ds38H2HR207wjaO4L2jqLtHR27/izajkiqhRHJdkcEQfKTwn5AR0CQHh/Rud8RdJYVzu8Sd9l/S5myckdGj7udz2XP77nn1ytfaNbV5HHDK3LdSiaI1cDkov1JaVl3FgDfTrdXAfdFxCsAkhYCM4FdEkREzAfmQ9IH0TdhD12SaKzL01iXZwz1tQ7HzGqskj2Wi4DpkqZKagDmAi3FB0iaXrT7QeDpdPtO4K2SmtIO6/dQ1HdhZmaVV7EaRES0S5pH8sc+D1wXEUskXQ60RkQLME/S+4DtwDqS5iUiYp2kq0iSTAALI+K2SsVqZmZd+UU5M7MhrKdhrh4Ub2ZmZTlBmJlZWU4QZmZWlhOEmZmV5QRhZmZlDZpRTJLagOf28PTxwCt9GE6lDbR4YeDFPNDihYEX80CLFwZezFniPSQiJpT7YtAkiL0hqbW7YV790UCLFwZezAMtXhh4MQ+0eGHgxby38bqJyczMynKCMDOzspwgEvNrHcBuGmjxwsCLeaDFCwMv5oEWLwy8mPcqXvdBmJlZWa5BmJlZWU4QZmZW1pBOEJJmS1omabmki2sdT3ckrZT0mKSHJbWmZftI+qWkp9Of42oY33WSXpb0eFFZ2fiU+Eb6zB+VNLMfxfx5SavT5/ywpA8UfXdJGvMySafUIN7Jku6WtFTSEkkXpuX99jn3EHO/fM6Shkn6g6RH0ngvS8unSnowjevH6fo2SGpM95en30+pZry9xPw9Sc8WPeOj0vLd+71IlnIceh+SNSqeAaaRrIf9CHB4rePqJtaVwPiSsq8AF6fbFwNX1jC+d5Os+Pd4b/EBHwBuJ1mC+VjgwX4U8+eBi8oce3j6+9EITE1/b/JVjvdAYGa6PQp4Ko2r3z7nHmLul885fVYj0+164MH02d0EzE3LrwHOTbfPA65Jt+cCP67BM+4u5u8BHy1z/G79XgzlGsQsYHlErIiIbSRLns6pcUy7Yw5wQ7p9A/DhWgUSEfcBr5YUdxffHOD7kXgAGCvpwKoEWqSbmLszB1gQEVsj4llgOcnvT9VExJqIeCjdfg14AphIP37OPcTcnZo+5/RZvZ7u1qefAE4Ebk7LS59x4dnfDLxXkqoTbaKHmLuzW78XQzlBTAReKNpfRc+/vLUUwC8kLZZ0dlq2f0SsSbf/BOxfm9C61V18/f25z0ur3tcVNdv1q5jTpoy3k/zf4oB4ziUxQz99zpLykh4GXgZ+SVKLWR8R7WVi6ow3/X4DsG8144WuMUdE4Rl/MX3G/yapsTTmVI/PeCgniIHk+IiYCbwfOF/Su4u/jKTu2G/HK/f3+Ip8GzgUOApYA3ytptGUIWkk8FPgUxGxsfi7/vqcy8Tcb59zROyIiKOASSS1l7fUNqLelcYsaQZwCUnsxwD7AJ/dk2sP5QSxGphctD8pLet3ImJ1+vNl4BaSX9yXClXD9OfLtYuwrO7i67fPPSJeSv9j6wD+k53NG/0iZkn1JH9o/ysi/jst7tfPuVzM/f05A0TEeuBu4DiSZpi6MjF1xpt+PwZYW91IdyqKeXbavBcRsRW4nj18xkM5QSwCpqcjFBpIOplaahxTF5JGSBpV2AZOBh4nifXM9LAzgZ/VJsJudRdfC/CJdDTFscCGoiaSmippi/0LkucMScxz01ErU4HpwB+qHJuA7wJPRMRVRV/12+fcXcz99TlLmiBpbLo9HDiJpN/kbuCj6WGlz7jw7D8K/DqtxVVNNzE/WfQ/DSLpMyl+xtl/L6rd696fPiQ9+k+RtDN+rtbxdBPjNJKRHY8ASwpxkrR13gU8DfwK2KeGMf6IpKlgO0mb5t90Fx/J6Imr02f+GNDcj2L+QRrTo+l/SAcWHf+5NOZlwPtrEO/xJM1HjwIPp58P9Ofn3EPM/fI5A0cCf0zjehy4NC2fRpKolgM/ARrT8mHp/vL0+2k1eMbdxfzr9Bk/DtzIzpFOu/V74ak2zMysrKHcxGRmZj1wgjAzs7KcIMzMrCwnCDMzK8sJwszMynKCMKsgSWMlnVfrOMz2hBOEWWWNJZn102zAcYIwq6wvA4emc/L/a62DMdsdflHOrILSWUx/HhEzah2L2e5yDcLMzMpygjAzs7KcIMwq6zWS5TbNBhwnCLMKioi1wP2SHncntQ007qQ2M7OyXIMwM7OynCDMzKwsJwgzMyvLCcLMzMpygjAzs7KcIMzMrCwnCDMzK+v/AxUoxVob58f4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven decoder Y_hat:\u001b[0m\n",
      "Initial matrix A:\n",
      "[[0.973  0.5282]\n",
      " [0.4331 0.6074]\n",
      " [0.3019 0.6063]]\n",
      "\n",
      "Initial covariance matrix of Z:\n",
      "[[0.5253 0.     0.    ]\n",
      " [0.     0.5426 0.    ]\n",
      " [0.     0.     0.2908]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 91 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[0.0894 0.6184]\n",
      " [0.0493 0.284 ]\n",
      " [0.5958 0.1079]]\n",
      "\n",
      "Matrix B:\n",
      "[[0.0163 0.0107 0.5932]\n",
      " [0.5832 0.1773 0.0273]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[0.6096 0.     0.    ]\n",
      " [0.     0.9169 0.    ]\n",
      " [0.     0.     0.6334]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 0.6446 -0.0771]\n",
      " [-0.0771  0.5861]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "4.2323\n",
      "\n",
      "Mutual information of the encoder:\n",
      "0.4947\n",
      "\n",
      "Mutual information of the decoder:\n",
      "0.4947\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[ 1. -0.]\n",
      " [-0.  1.]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[1.   0.18 0.12]\n",
      " [0.18 1.   0.06]\n",
      " [0.12 0.06 1.  ]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gamma = 1\n",
    "\n",
    "for is_Sigma_Z_diagonal in (0, 1):\n",
    "    if is_Sigma_Z_diagonal == 0:\n",
    "        print(colored('a. Arbitrary Sigma_Z\\n', 'red', attrs=['bold']))\n",
    "    else: \n",
    "        print(colored('b. Diagonalized Sigma_Z\\n', 'red', attrs=['bold']))  \n",
    "    for flag in (0, 1):\n",
    "        print_comprehensive_results(gamma, flag, m, n, is_Sigma_Z_diagonal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4eca045",
   "metadata": {},
   "source": [
    "#### Case 3: gamma > 1 -- choose gamma = 1.02"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "15e55fd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31ma. Arbitrary Sigma_Z\n",
      "\u001b[0m\n",
      "\u001b[1mGiven encoder X:\u001b[0m\n",
      "Initial matrix B:\n",
      "[[0.6478 0.1299 0.0341]\n",
      " [0.752  0.9967 0.3028]]\n",
      "\n",
      "Initial covariance matrix of W:\n",
      "[[2.3624 0.8628]\n",
      " [0.8628 1.3503]]\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 3667 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[ 0.0134 -1.9537]\n",
      " [ 0.2718  2.3634]\n",
      " [ 0.2009  0.8163]]\n",
      "\n",
      "Matrix B:\n",
      "[[-0.5106 -1.3895  1.6202]\n",
      " [ 3.4959  3.8611 -0.3946]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[-1.0331  0.9888  0.5224]\n",
      " [ 0.9888 -0.9463 -0.5   ]\n",
      " [ 0.5224 -0.5    -0.2642]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 0. -0.]\n",
      " [-0.  0.]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "nan\n",
      "\n",
      "Mutual information of the encoder:\n",
      "36.2986\n",
      "\n",
      "Mutual information of the decoder:\n",
      "34.0688\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[ 4.6032 -7.9063]\n",
      " [-7.9063 31.6311]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[ 2.7842 -3.6251 -1.0698]\n",
      " [-3.6251  4.7132  1.4839]\n",
      " [-1.0698  1.4839  0.4426]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.916\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mhvu1\\AppData\\Local\\Temp\\ipykernel_22488\\938477731.py:63: RuntimeWarning: invalid value encountered in log\n",
      "  n * np.log(2 * pi) - np.log(det(Sigma_Z)))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven decoder Y_hat:\u001b[0m\n",
      "Initial matrix A:\n",
      "[[0.8626 0.6093]\n",
      " [0.1742 0.9393]\n",
      " [0.0536 0.8031]]\n",
      "\n",
      "Initial covariance matrix of Z:\n",
      "[[ 2.7288  1.2388 -0.6072]\n",
      " [ 1.2388  1.3633 -0.6092]\n",
      " [-0.6072 -0.6092  0.973 ]]\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 3862 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[ -17.6809   26.4601]\n",
      " [-141.5379 -107.5214]\n",
      " [ -16.8229   11.3015]]\n",
      "\n",
      "Matrix B:\n",
      "[[-14.8989  -0.0476   9.702 ]\n",
      " [ -5.569   -0.0305   3.8112]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[-0.0032 -0.0756 -0.0052]\n",
      " [-0.0756 -1.8127 -0.125 ]\n",
      " [-0.0052 -0.125  -0.0086]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[0. 0.]\n",
      " [0. 0.]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "nan\n",
      "\n",
      "Mutual information of the encoder:\n",
      "39.4027\n",
      "\n",
      "Mutual information of the decoder:\n",
      "38.3848\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[281.6172 106.7541]\n",
      " [106.7541  40.4939]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[ 1012.7491  -342.5759   596.4788]\n",
      " [ -342.5759 31592.0117  1165.8005]\n",
      " [  596.4788  1165.8005   410.7258]]\n",
      "\n",
      "Reconstruction error:\n",
      "1553.1746\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31mb. Diagonalized Sigma_Z\n",
      "\u001b[0m\n",
      "\u001b[1mGiven encoder X:\u001b[0m\n",
      "Initial matrix B:\n",
      "[[0.6542 0.4738 0.118 ]\n",
      " [0.3758 0.818  0.2222]]\n",
      "\n",
      "Initial covariance matrix of W:\n",
      "[[ 2.4147 -0.5789]\n",
      " [-0.5789  0.7837]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 6953 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[ 0.207   0.0327]\n",
      " [ 0.9205 -0.378 ]\n",
      " [ 0.4326  0.8961]]\n",
      "\n",
      "Matrix B:\n",
      "[[ 0.      0.9067  0.3825]\n",
      " [-0.     -0.4377  0.9313]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[0.9556 0.     0.    ]\n",
      " [0.     0.     0.    ]\n",
      " [0.     0.     0.    ]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 0. -0.]\n",
      " [-0.  0.]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "-143552238122433.16\n",
      "\n",
      "Mutual information of the encoder:\n",
      "67.7313\n",
      "\n",
      "Mutual information of the decoder:\n",
      "67.7214\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[1.0099 0.    ]\n",
      " [0.     1.0099]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[0.9996 0.1782 0.1188]\n",
      " [0.1782 0.9902 0.0594]\n",
      " [0.1188 0.0594 0.9902]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.0087\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven decoder Y_hat:\u001b[0m\n",
      "Initial matrix A:\n",
      "[[0.2906 0.3332]\n",
      " [0.1601 0.5118]\n",
      " [0.4428 0.4074]]\n",
      "\n",
      "Initial covariance matrix of Z:\n",
      "[[0.3437 0.     0.    ]\n",
      " [0.     0.4115 0.    ]\n",
      " [0.     0.     0.909 ]]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 6824 iterations.\n",
      "\u001b[0m\n",
      "\u001b[1mOptimal solution:\u001b[0m\n",
      "Matrix A:\n",
      "[[ 0.5192  0.8489]\n",
      " [ 0.1263  0.1327]\n",
      " [ 0.9051 -0.4136]]\n",
      "\n",
      "Matrix B:\n",
      "[[ 0.4207  0.      0.8636]\n",
      " [ 0.9207  0.     -0.5282]]\n",
      "\n",
      "Covariance matrix of Z:\n",
      "[[0.     0.     0.    ]\n",
      " [0.     0.9661 0.    ]\n",
      " [0.     0.     0.    ]]\n",
      "\n",
      "Covariance matrix of W:\n",
      "[[ 0. -0.]\n",
      " [-0.  0.]]\n",
      "\n",
      "Minimum value of the cost function:\n",
      "-143552238122433.12\n",
      "\n",
      "Mutual information of the encoder:\n",
      "68.52\n",
      "\n",
      "Mutual information of the decoder:\n",
      "68.5101\n",
      "\n",
      "Value of Sigma_X:\n",
      "[[ 1.0099 -0.    ]\n",
      " [-0.      1.01  ]]\n",
      "\n",
      "Value of Sigma_Y_hat:\n",
      "[[0.9902 0.1782 0.1188]\n",
      " [0.1782 0.9997 0.0594]\n",
      " [0.1188 0.0594 0.9901]]\n",
      "\n",
      "Reconstruction error:\n",
      "0.009\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gamma = 1.02\n",
    "\n",
    "for is_Sigma_Z_diagonal in (0, 1):\n",
    "    if is_Sigma_Z_diagonal == 0:\n",
    "        print(colored('a. Arbitrary Sigma_Z\\n', 'red', attrs=['bold']))\n",
    "    else: \n",
    "        print(colored('b. Diagonalized Sigma_Z\\n', 'red', attrs=['bold']))\n",
    "    for flag in (0, 1):\n",
    "        print_comprehensive_results(gamma, flag, m, n, is_Sigma_Z_diagonal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bedb24cb",
   "metadata": {},
   "source": [
    "## II. Mutual information and reconstruction error across gammas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bc25bde2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_mutual_info_recon_err(sol, is_varied):\n",
    "    en_mi, de_mi = sol[2*n*m+n*n+m*m+1:2*n*m+n*n+m*m+3]\n",
    "    recon_err = round(sol[-1], 4)\n",
    "    mi_arr = np.round(np.array([en_mi, de_mi]), 4)\n",
    "    \n",
    "    if is_varied == 1:\n",
    "        print('Mutual information of encoder and decoder = {}'.format(mi_arr))\n",
    "        print('Reconstruction error = {}'.format(recon_err))\n",
    "    else:\n",
    "        print('Mutual information of encoder and decoder = {}'.format(mi_arr))\n",
    "\n",
    "    return np.concatenate((mi_arr,  [recon_err]))\n",
    "    \n",
    "def print_mutual_info_recon_err(flag, is_diagonal, is_varied):\n",
    "    if flag == 0:\n",
    "        # Generate random initial encoder inputs (B, Sigma_W)\n",
    "        B, Sigma_W = initial_inputs(flag, is_diagonal)[1:1+m*n].reshape((m, n)), initial_inputs(flag, is_diagonal)[1+m*n:1+m*n+m*m].reshape((m, m))\n",
    "    else:\n",
    "        # Generate random initial decoder inputs (A, Sigma_Z)\n",
    "        A, Sigma_Z = initial_inputs(flag, is_diagonal)[1:1+n*m].reshape((n, m)), initial_inputs(flag, is_diagonal)[1+n*m:1+n*m+n*n].reshape((n, n))\n",
    "    \n",
    "    # Print results\n",
    "    opt_sol = rate_distortion(initial_inputs(flag, is_diagonal), is_diagonal)\n",
    "    mi_recon_err_arr = get_mutual_info_recon_err(opt_sol, is_varied)\n",
    "    \n",
    "    return mi_recon_err_arr\n",
    "\n",
    "def plot_mutual_info_gamma(x, y1, z1, y2, z2):\n",
    "    # Create figure with two subplots\n",
    "    fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(12, 4))\n",
    "\n",
    "    # Left subplot: mutual information given arbitrary Sigma_Z\n",
    "    ax1.scatter(x, y1, color='black', marker='^', s=20, label='Encoder')\n",
    "    ax1.scatter(x, z1, color='red', marker='o', s=10, label='Decoder')\n",
    "    ax1.set_xlabel('gamma', fontsize=10)\n",
    "    ax1.set_ylabel('Mutual Information', fontsize=10)\n",
    "    ax1.legend()\n",
    "\n",
    "    # Right subplot: mutual information given diagonalized Sigma_Z\n",
    "    ax2.scatter(x, y2, color='black', marker='^', s=20, label='Encoder')\n",
    "    ax2.scatter(x, z2, color='red', marker='o', s=10, label='Decoder')\n",
    "    ax2.set_xlabel('gamma', fontsize=10)\n",
    "    ax2.set_ylabel('Mutual Information', fontsize=10)\n",
    "    ax2.legend()\n",
    "\n",
    "    # Adjust layout and display plot\n",
    "    fig.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
    "    fig.subplots_adjust(wspace=0.3)\n",
    "    plt.show()\n",
    "    \n",
    "def plot_recon_error_gamma(x, y1, y2):\n",
    "    # Create figure with two subplots\n",
    "    fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(12, 4))\n",
    "\n",
    "    # Left subplot: reconstruction error given arbitrary Sigma_Z\n",
    "    ax1.scatter(x, y1, color='red', marker='o', s=10)\n",
    "    ax1.set_xlabel('gamma', fontsize=10)\n",
    "    ax1.set_ylabel('Reconstruction Error', fontsize=10)\n",
    "\n",
    "    # Right subplot: reconstruction error given diagonalized Sigma_Z\n",
    "    ax2.scatter(x, y2, color='red', marker='o', s=10)\n",
    "    ax2.set_xlabel('gamma', fontsize=10)\n",
    "    ax2.set_ylabel('Reconstruction Error', fontsize=10)\n",
    "\n",
    "    # Adjust layout and display plot\n",
    "    fig.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
    "    fig.subplots_adjust(wspace=0.4)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e34226a",
   "metadata": {},
   "source": [
    "### 1. Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "10ecf24e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[34mAn array of gamma:\u001b[0m\n",
      "[0.9  0.91 0.92 0.93 0.94 0.95 0.96 0.97 0.98 0.99 1.   1.01 1.02 1.03\n",
      " 1.04 1.05 1.06 1.07 1.08 1.09 1.1 ]\n"
     ]
    }
   ],
   "source": [
    "# Create an array of gamma = [0.9, 1.1] with step size 0.01\n",
    "gamma_arr = np.arange(0.9, 1.1, 0.01).round(2)\n",
    "\n",
    "print(colored('An array of gamma:', 'blue', attrs=['bold']))\n",
    "print(gamma_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d061903f",
   "metadata": {},
   "source": [
    "### 2. Numerical results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "066aae3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31ma. Arbitrary Sigma_Z\u001b[0m\n",
      "\n",
      "gamma = 0.9:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 302 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 309 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 0.91:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 360 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 389 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 0.92:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 398 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 409 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 0.93:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 440 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 457 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 0.94:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 524 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 489 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 0.95:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 630 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 609 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 0.96:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 774 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 877 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 0.97:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1026 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 963 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 0.98:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1536 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1553 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 0.99:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 2776 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 3001 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0. 0.]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 1.0:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 30 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4281 0.4281]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 33 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6113 0.6113]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 1.01:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 7417 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [37.1171 35.4907]\n",
      "Reconstruction error = 1.7801\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mhvu1\\AppData\\Local\\Temp\\ipykernel_22488\\938477731.py:63: RuntimeWarning: invalid value encountered in log\n",
      "  n * np.log(2 * pi) - np.log(det(Sigma_Z)))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 6546 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [35.0656 31.6254]\n",
      "Reconstruction error = 0.8597\n",
      "\n",
      "gamma = 1.02:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 3585 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [36.1711 34.8649]\n",
      "Reconstruction error = 4.1142\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 3720 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [36.1303 38.2598]\n",
      "Reconstruction error = 960.8082\n",
      "\n",
      "gamma = 1.03:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 2335 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [35.5435 34.6263]\n",
      "Reconstruction error = 0.9104\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 2654 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [38.966  37.9699]\n",
      "Reconstruction error = 4.55\n",
      "\n",
      "gamma = 1.04:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 1891 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [36.0139 34.6303]\n",
      "Reconstruction error = 3.0791\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 1906 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [38.2903 37.8005]\n",
      "Reconstruction error = 3.4311\n",
      "\n",
      "gamma = 1.05:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 1551 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [37.7933 37.6486]\n",
      "Reconstruction error = 1.7233\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 1434 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [36.6    34.3828]\n",
      "Reconstruction error = 1.384\n",
      "\n",
      "gamma = 1.06:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 1331 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [38.4725 38.9633]\n",
      "Reconstruction error = 47.9355\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 1310 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [38.3731 37.2059]\n",
      "Reconstruction error = 23.9695\n",
      "\n",
      "gamma = 1.07:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 1113 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [36.7266 37.2238]\n",
      "Reconstruction error = 6.8767\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 1112 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [39.6076 38.1703]\n",
      "Reconstruction error = 10.8108\n",
      "\n",
      "gamma = 1.08:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 1001 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [37.0927 39.9378]\n",
      "Reconstruction error = 669.3564\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 974 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [38.4032 37.7194]\n",
      "Reconstruction error = 155.8723\n",
      "\n",
      "gamma = 1.09:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 863 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [36.8911 33.954 ]\n",
      "Reconstruction error = 0.887\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 902 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [37.9666 39.6531]\n",
      "Reconstruction error = 21.1555\n",
      "\n",
      "gamma = 1.1:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 765 iterations due to NaN values.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [36.4517 38.201 ]\n",
      "Reconstruction error = 169.108\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm fails to converge after 794 iterations due to Singular matrix.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [36.3367 35.9382]\n",
      "Reconstruction error = 6.5646\n",
      "\u001b[1m\u001b[31m\n",
      "b. Diagonalized Sigma_Z\u001b[0m\n",
      "\n",
      "gamma = 0.9:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 262 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1042 0.1146]\n",
      "Reconstruction error = 0.081\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 297 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1042 0.1146]\n",
      "Reconstruction error = 0.081\n",
      "\n",
      "gamma = 0.91:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 319 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1145 0.1245]\n",
      "Reconstruction error = 0.0716\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 338 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1145 0.1245]\n",
      "Reconstruction error = 0.0716\n",
      "\n",
      "gamma = 0.92:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 363 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1247 0.1343]\n",
      "Reconstruction error = 0.0648\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 394 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1247 0.1343]\n",
      "Reconstruction error = 0.0648\n",
      "\n",
      "gamma = 0.93:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 445 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.135  0.1439]\n",
      "Reconstruction error = 0.0583\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 468 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.135  0.1439]\n",
      "Reconstruction error = 0.0583\n",
      "\n",
      "gamma = 0.94:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 511 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1455 0.1535]\n",
      "Reconstruction error = 0.0517\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 628 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1455 0.1535]\n",
      "Reconstruction error = 0.0517\n",
      "\n",
      "gamma = 0.95:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 657 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1561 0.1631]\n",
      "Reconstruction error = 0.0453\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 846 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1561 0.1631]\n",
      "Reconstruction error = 0.0453\n",
      "\n",
      "gamma = 0.96:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 941 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1672 0.1731]\n",
      "Reconstruction error = 0.0387\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 978 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1672 0.1731]\n",
      "Reconstruction error = 0.0387\n",
      "\n",
      "gamma = 0.97:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1331 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1792 0.1839]\n",
      "Reconstruction error = 0.0319\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1760 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1792 0.1839]\n",
      "Reconstruction error = 0.0319\n",
      "\n",
      "gamma = 0.98:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 4465 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1932 0.1965]\n",
      "Reconstruction error = 0.0245\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 3226 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1932 0.1965]\n",
      "Reconstruction error = 0.0245\n",
      "\n",
      "gamma = 0.99:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 5319 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2159 0.2177]\n",
      "Reconstruction error = 0.0138\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 5634 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2159 0.2177]\n",
      "Reconstruction error = 0.0138\n",
      "\n",
      "gamma = 1.0:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 327 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.254 0.254]\n",
      "Reconstruction error = 0.0\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 586 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4072 0.4072]\n",
      "Reconstruction error = 0.0\n",
      "\n",
      "gamma = 1.01:\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm reaches the maximum number of iterations without convergence.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [49.2102 49.1953]\n",
      "Reconstruction error = 0.0046\n",
      "\u001b[1m\u001b[31m\n",
      "The algorithm reaches the maximum number of iterations without convergence.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [49.9399 49.9349]\n",
      "Reconstruction error = 0.0047\n",
      "\n",
      "gamma = 1.02:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 6941 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [67.833  67.8231]\n",
      "Reconstruction error = 0.0091\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 6866 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [67.8329 67.823 ]\n",
      "Reconstruction error = 0.0094\n",
      "\n",
      "gamma = 1.03:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 4664 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [68.4522 68.4079]\n",
      "Reconstruction error = 0.013\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 4569 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [68.2053 68.1614]\n",
      "Reconstruction error = 0.0132\n",
      "\n",
      "gamma = 1.04:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 3552 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [69.0169 68.9581]\n",
      "Reconstruction error = 0.0171\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 3616 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [69.147  69.1274]\n",
      "Reconstruction error = 0.0172\n",
      "\n",
      "gamma = 1.05:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 2940 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [69.9219 69.8488]\n",
      "Reconstruction error = 0.023\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 2839 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [69.5075 69.4343]\n",
      "Reconstruction error = 0.0221\n",
      "\n",
      "gamma = 1.06:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 2421 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [69.619  69.5899]\n",
      "Reconstruction error = 0.0263\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 2361 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [68.8078 68.7204]\n",
      "Reconstruction error = 0.0264\n",
      "\n",
      "gamma = 1.07:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 2100 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [69.5277 69.4262]\n",
      "Reconstruction error = 0.0318\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 2090 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [70.0602 70.0264]\n",
      "Reconstruction error = 0.0305\n",
      "\n",
      "gamma = 1.08:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1857 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [69.9666 69.9282]\n",
      "Reconstruction error = 0.036\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1836 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [70.3016 70.2632]\n",
      "Reconstruction error = 0.0346\n",
      "\n",
      "gamma = 1.09:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1674 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [70.1865 70.0573]\n",
      "Reconstruction error = 0.0402\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1595 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [70.9715 70.8444]\n",
      "Reconstruction error = 0.0357\n",
      "\n",
      "gamma = 1.1:\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1543 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [72.414  72.3665]\n",
      "Reconstruction error = 0.0425\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1388 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [68.0302 67.9818]\n",
      "Reconstruction error = 0.0436\n"
     ]
    }
   ],
   "source": [
    "# Compute mutual information and reconstruction error given X and Y_hat across gammas   \n",
    "# Initiate arrays given arbitrary Sigma_Z\n",
    "en_mi_arr_X_1, de_mi_arr_X_1 = [], []\n",
    "en_mi_arr_Y_1, de_mi_arr_Y_1 = [], []\n",
    "recon_err_X_1, recon_err_Y_1 = [], []\n",
    "\n",
    "# Initiate arrays given diagonalized Sigma_Z\n",
    "en_mi_arr_X_2, de_mi_arr_X_2 = [], []\n",
    "en_mi_arr_Y_2, de_mi_arr_Y_2 = [], []\n",
    "recon_err_X_2, recon_err_Y_2 = [], []\n",
    "\n",
    "is_gamma_varied = 1\n",
    "\n",
    "for is_Sigma_Z_diagonal in (0, 1):\n",
    "    if is_Sigma_Z_diagonal == 0:\n",
    "        print(colored('a. Arbitrary Sigma_Z', 'red', attrs=['bold']))\n",
    "    else: \n",
    "        print(colored('\\nb. Diagonalized Sigma_Z', 'red', attrs=['bold']))\n",
    "        \n",
    "    for i, gamma in enumerate(gamma_arr):\n",
    "        print(f\"\\ngamma = {gamma}:\")\n",
    "        for flag, mi_recon_arr in enumerate([print_mutual_info_recon_err(0, is_Sigma_Z_diagonal, is_gamma_varied),\n",
    "                                             print_mutual_info_recon_err(1, is_Sigma_Z_diagonal, is_gamma_varied)]):\n",
    "            en_mi, de_mi, recon_err = mi_recon_arr\n",
    "\n",
    "            if is_Sigma_Z_diagonal == 0:\n",
    "                # Arbitrary Sigma_Z\n",
    "                if flag == 0:\n",
    "                    en_mi_arr_X_1 = np.concatenate((en_mi_arr_X_1, [en_mi]))\n",
    "                    de_mi_arr_X_1 = np.concatenate((de_mi_arr_X_1, [de_mi]))\n",
    "                    recon_err_X_1 = np.concatenate((recon_err_X_1, [recon_err]))\n",
    "                else:\n",
    "                    en_mi_arr_Y_1 = np.concatenate((en_mi_arr_Y_1, [en_mi]))\n",
    "                    de_mi_arr_Y_1 = np.concatenate((de_mi_arr_Y_1, [de_mi]))\n",
    "                    recon_err_Y_1 = np.concatenate((recon_err_Y_1, [recon_err]))\n",
    "            else:\n",
    "                # Diagonalized Sigma_Z\n",
    "                if flag == 0:\n",
    "                    en_mi_arr_X_2 = np.concatenate((en_mi_arr_X_2, [en_mi]))\n",
    "                    de_mi_arr_X_2 = np.concatenate((de_mi_arr_X_2, [de_mi]))\n",
    "                    recon_err_X_2 = np.concatenate((recon_err_X_2, [recon_err]))\n",
    "                else:\n",
    "                    en_mi_arr_Y_2 = np.concatenate((en_mi_arr_Y_2, [en_mi]))\n",
    "                    de_mi_arr_Y_2 = np.concatenate((de_mi_arr_Y_2, [de_mi]))  \n",
    "                    recon_err_Y_2 = np.concatenate((recon_err_Y_2, [recon_err]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fbd844e",
   "metadata": {},
   "source": [
    "### 3. Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "783008dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven encoder X:\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven decoder Y_hat:\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(colored('Given encoder X:', attrs=['bold']))\n",
    "plot_mutual_info_gamma(gamma_arr, en_mi_arr_X_1, de_mi_arr_X_1, en_mi_arr_X_2, de_mi_arr_X_2)    \n",
    "\n",
    "print(colored('Given decoder Y_hat:', attrs=['bold']))\n",
    "plot_mutual_info_gamma(gamma_arr, en_mi_arr_Y_1, de_mi_arr_Y_1, en_mi_arr_Y_2, de_mi_arr_Y_2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d15c3fbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven encoder X:\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven decoder Y_hat:\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(colored('Given encoder X:', attrs=['bold']))\n",
    "plot_recon_error_gamma(gamma_arr, recon_err_X_1, recon_err_X_2)    \n",
    "\n",
    "print(colored('Given decoder Y_hat:', attrs=['bold']))\n",
    "plot_recon_error_gamma(gamma_arr, recon_err_Y_1, recon_err_Y_2) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee30c8eb",
   "metadata": {},
   "source": [
    "## III. Mutual information given gamma = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "88b4b489",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutual_info_boxplot(x, y1, y2, ax):\n",
    "    # Compute mean, median, and std of data\n",
    "    mean_y1, median_y1, std_y1 = np.mean(y1), np.median(y1), np.std(y1)\n",
    "    mean_y2, median_y2, std_y2 = np.mean(y2), np.median(y2), np.std(y2)\n",
    "\n",
    "    # Create the boxplot\n",
    "    bp1 = ax.boxplot(y1, positions=[1], widths=0.6, showfliers=True, patch_artist=True,\n",
    "                     boxprops=dict(facecolor='C0', color='C0'), medianprops=dict(color='red'))\n",
    "    bp2 = ax.boxplot(y2, positions=[2], widths=0.6, showfliers=True, patch_artist=True,\n",
    "                     boxprops=dict(facecolor='C1', color='C1'), medianprops=dict(color='red'))\n",
    "    ax.set_xticklabels(x, fontsize=10)\n",
    "    ax.set_ylabel('Mutual Information', fontsize=10)\n",
    "\n",
    "    # Add outlier points\n",
    "    for element in ['fliers']:\n",
    "        plt.setp(bp1[element], marker='o', markersize=5, markeredgecolor='C0', alpha=0.5)\n",
    "        plt.setp(bp2[element], marker='o', markersize=5, markeredgecolor='C1', alpha=0.5)\n",
    "\n",
    "    # Add legend\n",
    "    bp1_mean_median_std = f\"Mean: {mean_y1:.2f}\\nMedian: {median_y1:.2f}\\nStd: {std_y1:.2f}\"\n",
    "    bp2_mean_median_std = f\"Mean: {mean_y2:.2f}\\nMedian: {median_y2:.2f}\\nStd: {std_y2:.2f}\"\n",
    "    legend_elements = [Patch(facecolor='C0', edgecolor='C0', label=bp1_mean_median_std),\n",
    "                       Patch(facecolor='C1', edgecolor='C1', label=bp2_mean_median_std)]\n",
    "    ax.legend(handles=legend_elements)\n",
    "    \n",
    "def plot_mutual_info(y1, z1, y2, z2):\n",
    "    fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(12, 4))\n",
    "\n",
    "    # Plot boxplots side by side\n",
    "    mutual_info_boxplot(['Encoder', 'Decoder'], y1, z1, ax1)\n",
    "    mutual_info_boxplot(['Encoder', 'Decoder'], y2, z2, ax2)\n",
    "\n",
    "    # Adjust layout and display plot\n",
    "    fig.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
    "    fig.subplots_adjust(wspace=0.4)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e6c397e",
   "metadata": {},
   "source": [
    "### 1. Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4dfdc5f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[34mAn array of gamma:\u001b[0m\n",
      "[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "# Create an array of gamma of 100 values of 1\n",
    "gamma_arr = [1] * 100\n",
    "\n",
    "print(colored('An array of gamma:', 'blue', attrs=['bold']))\n",
    "print(gamma_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4df9fe78",
   "metadata": {},
   "source": [
    "### 2. Numerical results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "915ea095",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31ma. Arbitrary Sigma_Z\u001b[0m\n",
      "\u001b[1m\n",
      "Iteration = 1:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 48 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6066 0.6066]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 47 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6184 0.6184]\n",
      "\u001b[1m\n",
      "Iteration = 2:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 64 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.755 0.755]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 22 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3188 0.3188]\n",
      "\u001b[1m\n",
      "Iteration = 3:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 26 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3318 0.3318]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 33 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4675 0.4675]\n",
      "\u001b[1m\n",
      "Iteration = 4:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 24 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3613 0.3613]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 39 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5403 0.5403]\n",
      "\u001b[1m\n",
      "Iteration = 5:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 12 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.111 0.111]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 313 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.5624 1.5624]\n",
      "\u001b[1m\n",
      "Iteration = 6:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 80 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8775 0.8775]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 45 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6391 0.6391]\n",
      "\u001b[1m\n",
      "Iteration = 7:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 21 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2653 0.2653]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 73 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8233 0.8233]\n",
      "\u001b[1m\n",
      "Iteration = 8:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 116 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.0228 1.0228]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 63 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9362 0.9362]\n",
      "\u001b[1m\n",
      "Iteration = 9:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 54 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6461 0.6461]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 31 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4954 0.4954]\n",
      "\u001b[1m\n",
      "Iteration = 10:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 49 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6045 0.6045]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 40 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6333 0.6333]\n",
      "\u001b[1m\n",
      "Iteration = 11:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 28 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3598 0.3598]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 43 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5698 0.5698]\n",
      "\u001b[1m\n",
      "Iteration = 12:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 116 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.0559 1.0559]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 90 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.027 1.027]\n",
      "\u001b[1m\n",
      "Iteration = 13:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 20 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3691 0.3691]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 24 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3139 0.3139]\n",
      "\u001b[1m\n",
      "Iteration = 14:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 28 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3798 0.3798]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 161 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.6115 1.6115]\n",
      "\u001b[1m\n",
      "Iteration = 15:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 31 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3906 0.3906]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 59 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7724 0.7724]\n",
      "\u001b[1m\n",
      "Iteration = 16:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 150 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1934 1.1934]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 25 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.33 0.33]\n",
      "\u001b[1m\n",
      "Iteration = 17:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 37 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4938 0.4938]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 20 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2893 0.2893]\n",
      "\u001b[1m\n",
      "Iteration = 18:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 26 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3429 0.3429]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 29 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4391 0.4391]\n",
      "\u001b[1m\n",
      "Iteration = 19:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 52 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.624 0.624]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 26 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4664 0.4664]\n",
      "\u001b[1m\n",
      "Iteration = 20:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 13 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1108 0.1108]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 45 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9413 0.9413]\n",
      "\u001b[1m\n",
      "Iteration = 21:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 32 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4345 0.4345]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 65 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8128 0.8128]\n",
      "\u001b[1m\n",
      "Iteration = 22:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 34 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4397 0.4397]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 41 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8475 0.8475]\n",
      "\u001b[1m\n",
      "Iteration = 23:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 72 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8037 0.8037]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 71 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8682 0.8682]\n",
      "\u001b[1m\n",
      "Iteration = 24:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 29 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3826 0.3826]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 45 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5679 0.5679]\n",
      "\u001b[1m\n",
      "Iteration = 25:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 84 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8818 0.8818]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 24 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4663 0.4663]\n",
      "\u001b[1m\n",
      "Iteration = 26:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 34 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4941 0.4941]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 77 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8321 0.8321]\n",
      "\u001b[1m\n",
      "Iteration = 27:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 23 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3565 0.3565]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 45 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5779 0.5779]\n",
      "\u001b[1m\n",
      "Iteration = 28:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 32 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4188 0.4188]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 159 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.2145 1.2145]\n",
      "\u001b[1m\n",
      "Iteration = 29:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 29 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.371 0.371]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 44 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.609 0.609]\n",
      "\u001b[1m\n",
      "Iteration = 30:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 31 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4455 0.4455]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 52 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7507 0.7507]\n",
      "\u001b[1m\n",
      "Iteration = 31:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 57 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7936 0.7936]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 47 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6974 0.6974]\n",
      "\u001b[1m\n",
      "Iteration = 32:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 27 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4623 0.4623]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 26 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3673 0.3673]\n",
      "\u001b[1m\n",
      "Iteration = 33:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 46 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5998 0.5998]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 35 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5311 0.5311]\n",
      "\u001b[1m\n",
      "Iteration = 34:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 26 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3546 0.3546]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 73 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8539 0.8539]\n",
      "\u001b[1m\n",
      "Iteration = 35:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 45 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6009 0.6009]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 41 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7635 0.7635]\n",
      "\u001b[1m\n",
      "Iteration = 36:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 34 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4479 0.4479]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 100 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9641 0.9641]\n",
      "\u001b[1m\n",
      "Iteration = 37:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 13 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1002 0.1002]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 121 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.2472 1.2472]\n",
      "\u001b[1m\n",
      "Iteration = 38:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 53 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.628 0.628]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 40 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.504 0.504]\n",
      "\u001b[1m\n",
      "Iteration = 39:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 21 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2621 0.2621]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 14 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1776 0.1776]\n",
      "\u001b[1m\n",
      "Iteration = 40:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 33 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4599 0.4599]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 49 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6287 0.6287]\n",
      "\u001b[1m\n",
      "Iteration = 41:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 38 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5828 0.5828]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 50 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6778 0.6778]\n",
      "\u001b[1m\n",
      "Iteration = 42:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 72 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7875 0.7875]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 51 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7243 0.7243]\n",
      "\u001b[1m\n",
      "Iteration = 43:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 106 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.0275 1.0275]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 42 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5681 0.5681]\n",
      "\u001b[1m\n",
      "Iteration = 44:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 16 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1808 0.1808]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 37 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6923 0.6923]\n",
      "\u001b[1m\n",
      "Iteration = 45:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 14 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1638 0.1638]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 75 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9207 0.9207]\n",
      "\u001b[1m\n",
      "Iteration = 46:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 50 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5983 0.5983]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 18 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2266 0.2266]\n",
      "\u001b[1m\n",
      "Iteration = 47:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 23 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3182 0.3182]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 37 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5233 0.5233]\n",
      "\u001b[1m\n",
      "Iteration = 48:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 29 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3688 0.3688]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 43 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5897 0.5897]\n",
      "\u001b[1m\n",
      "Iteration = 49:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 33 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4425 0.4425]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 32 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4759 0.4759]\n",
      "\u001b[1m\n",
      "Iteration = 50:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 29 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3895 0.3895]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 20 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3741 0.3741]\n",
      "\u001b[1m\n",
      "Iteration = 51:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 33 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4551 0.4551]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 36 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5142 0.5142]\n",
      "\u001b[1m\n",
      "Iteration = 52:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 32 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4765 0.4765]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 33 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.776 0.776]\n",
      "\u001b[1m\n",
      "Iteration = 53:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 36 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5445 0.5445]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 42 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6913 0.6913]\n",
      "\u001b[1m\n",
      "Iteration = 54:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 42 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5419 0.5419]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 49 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7803 0.7803]\n",
      "\u001b[1m\n",
      "Iteration = 55:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 44 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6128 0.6128]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 39 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4923 0.4923]\n",
      "\u001b[1m\n",
      "Iteration = 56:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 36 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5237 0.5237]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 60 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8114 0.8114]\n",
      "\u001b[1m\n",
      "Iteration = 57:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 41 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5089 0.5089]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 203 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.4387 1.4387]\n",
      "\u001b[1m\n",
      "Iteration = 58:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 84 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8659 0.8659]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 45 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6206 0.6206]\n",
      "\u001b[1m\n",
      "Iteration = 59:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 40 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5715 0.5715]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 97 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9907 0.9907]\n",
      "\u001b[1m\n",
      "Iteration = 60:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 37 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4729 0.4729]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 33 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4822 0.4822]\n",
      "\u001b[1m\n",
      "Iteration = 61:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 34 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4411 0.4411]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 130 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1946 1.1946]\n",
      "\u001b[1m\n",
      "Iteration = 62:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 54 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6272 0.6272]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 35 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4863 0.4863]\n",
      "\u001b[1m\n",
      "Iteration = 63:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 32 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4184 0.4184]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 47 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5737 0.5737]\n",
      "\u001b[1m\n",
      "Iteration = 64:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 56 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6522 0.6522]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 50 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7118 0.7118]\n",
      "\u001b[1m\n",
      "Iteration = 65:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 144 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1258 1.1258]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 32 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5115 0.5115]\n",
      "\u001b[1m\n",
      "Iteration = 66:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 55 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7247 0.7247]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 445 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.726 1.726]\n",
      "\u001b[1m\n",
      "Iteration = 67:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 56 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7599 0.7599]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 62 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8933 0.8933]\n",
      "\u001b[1m\n",
      "Iteration = 68:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 38 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4999 0.4999]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 235 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.561 1.561]\n",
      "\u001b[1m\n",
      "Iteration = 69:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 30 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4048 0.4048]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 39 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4875 0.4875]\n",
      "\u001b[1m\n",
      "Iteration = 70:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 18 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2504 0.2504]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 36 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4865 0.4865]\n",
      "\u001b[1m\n",
      "Iteration = 71:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 68 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7554 0.7554]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 51 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7299 0.7299]\n",
      "\u001b[1m\n",
      "Iteration = 72:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 46 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5823 0.5823]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 24 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4332 0.4332]\n",
      "\u001b[1m\n",
      "Iteration = 73:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 39 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.499 0.499]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 36 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7161 0.7161]\n",
      "\u001b[1m\n",
      "Iteration = 74:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 41 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.527 0.527]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 45 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7969 0.7969]\n",
      "\u001b[1m\n",
      "Iteration = 75:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 14 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.1884 0.1884]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 96 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.0237 1.0237]\n",
      "\u001b[1m\n",
      "Iteration = 76:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 28 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4066 0.4066]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 26 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3596 0.3596]\n",
      "\u001b[1m\n",
      "Iteration = 77:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 36 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4978 0.4978]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 35 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4972 0.4972]\n",
      "\u001b[1m\n",
      "Iteration = 78:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 34 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4787 0.4787]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 71 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7914 0.7914]\n",
      "\u001b[1m\n",
      "Iteration = 79:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 42 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.539 0.539]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 41 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6355 0.6355]\n",
      "\u001b[1m\n",
      "Iteration = 80:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 50 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6095 0.6095]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 54 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8127 0.8127]\n",
      "\u001b[1m\n",
      "Iteration = 81:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 22 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2791 0.2791]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 47 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9701 0.9701]\n",
      "\u001b[1m\n",
      "Iteration = 82:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 30 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3812 0.3812]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 47 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5934 0.5934]\n",
      "\u001b[1m\n",
      "Iteration = 83:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 48 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6414 0.6414]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 193 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.2718 1.2718]\n",
      "\u001b[1m\n",
      "Iteration = 84:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 14 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2395 0.2395]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 65 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.061 1.061]\n",
      "\u001b[1m\n",
      "Iteration = 85:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 40 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5324 0.5324]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 57 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6849 0.6849]\n",
      "\u001b[1m\n",
      "Iteration = 86:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 48 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5827 0.5827]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 69 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9254 0.9254]\n",
      "\u001b[1m\n",
      "Iteration = 87:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 62 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7169 0.7169]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 117 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.2131 1.2131]\n",
      "\u001b[1m\n",
      "Iteration = 88:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 124 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1162 1.1162]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 29 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3828 0.3828]\n",
      "\u001b[1m\n",
      "Iteration = 89:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 31 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5701 0.5701]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 81 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9069 0.9069]\n",
      "\u001b[1m\n",
      "Iteration = 90:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 20 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3585 0.3585]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 33 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4883 0.4883]\n",
      "\u001b[1m\n",
      "Iteration = 91:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 20 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2507 0.2507]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 58 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8186 0.8186]\n",
      "\u001b[1m\n",
      "Iteration = 92:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 40 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.521 0.521]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 30 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6145 0.6145]\n",
      "\u001b[1m\n",
      "Iteration = 93:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 66 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7531 0.7531]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 27 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3727 0.3727]\n",
      "\u001b[1m\n",
      "Iteration = 94:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 218 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.328 1.328]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 194 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.4371 1.4371]\n",
      "\u001b[1m\n",
      "Iteration = 95:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 40 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5112 0.5112]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 100 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.2314 1.2314]\n",
      "\u001b[1m\n",
      "Iteration = 96:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 29 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4122 0.4122]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 42 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7247 0.7247]\n",
      "\u001b[1m\n",
      "Iteration = 97:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 11 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.0821 0.0821]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 68 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8365 0.8365]\n",
      "\u001b[1m\n",
      "Iteration = 98:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 62 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7205 0.7205]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 29 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4134 0.4134]\n",
      "\u001b[1m\n",
      "Iteration = 99:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 18 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2035 0.2035]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 35 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6371 0.6371]\n",
      "\u001b[1m\n",
      "Iteration = 100:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 31 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.414 0.414]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 111 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.0513 1.0513]\n",
      "\u001b[1m\u001b[31m\n",
      "b. Diagonalized Sigma_Z\u001b[0m\n",
      "\u001b[1m\n",
      "Iteration = 1:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 289 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2682 0.2682]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 81 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6392 0.6392]\n",
      "\u001b[1m\n",
      "Iteration = 2:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 174 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3373 0.3373]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 89 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6294 0.6294]\n",
      "\u001b[1m\n",
      "Iteration = 3:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1259 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2577 0.2577]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 233 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.5422 1.5422]\n",
      "\u001b[1m\n",
      "Iteration = 4:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 200 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4086 0.4086]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 111 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.2743 1.2743]\n",
      "\u001b[1m\n",
      "Iteration = 5:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 201 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2942 0.2942]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 124 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5854 0.5854]\n",
      "\u001b[1m\n",
      "Iteration = 6:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 937 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3623 0.3623]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 53 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9019 0.9019]\n",
      "\u001b[1m\n",
      "Iteration = 7:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 250 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3138 0.3138]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 63 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.055 1.055]\n",
      "\u001b[1m\n",
      "Iteration = 8:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 671 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2481 0.2481]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 210 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3298 0.3298]\n",
      "\u001b[1m\n",
      "Iteration = 9:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 399 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2496 0.2496]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 97 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5625 0.5625]\n",
      "\u001b[1m\n",
      "Iteration = 10:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 204 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3239 0.3239]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 65 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8663 0.8663]\n",
      "\u001b[1m\n",
      "Iteration = 11:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 110 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3616 0.3616]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1819 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [2.6607 2.6607]\n",
      "\u001b[1m\n",
      "Iteration = 12:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 243 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2581 0.2581]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 90 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8478 0.8478]\n",
      "\u001b[1m\n",
      "Iteration = 13:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 203 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3015 0.3015]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 304 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5378 0.5378]\n",
      "\u001b[1m\n",
      "Iteration = 14:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 130 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5485 0.5485]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 181 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7619 0.7619]\n",
      "\u001b[1m\n",
      "Iteration = 15:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 134 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3761 0.3761]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 871 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [2.3678 2.3678]\n",
      "\u001b[1m\n",
      "Iteration = 16:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 207 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.288 0.288]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 159 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7081 0.7081]\n",
      "\u001b[1m\n",
      "Iteration = 17:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 295 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.288 0.288]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1382 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2883 0.2883]\n",
      "\u001b[1m\n",
      "Iteration = 18:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 291 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2715 0.2715]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 59 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8212 0.8212]\n",
      "\u001b[1m\n",
      "Iteration = 19:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 241 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2688 0.2688]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 123 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3932 0.3932]\n",
      "\u001b[1m\n",
      "Iteration = 20:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 437 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3225 0.3225]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 131 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4313 0.4313]\n",
      "\u001b[1m\n",
      "Iteration = 21:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 180 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3122 0.3122]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 113 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.958 0.958]\n",
      "\u001b[1m\n",
      "Iteration = 22:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 230 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2822 0.2822]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 113 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.636 0.636]\n",
      "\u001b[1m\n",
      "Iteration = 23:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 295 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2606 0.2606]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 171 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.796 0.796]\n",
      "\u001b[1m\n",
      "Iteration = 24:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 195 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3099 0.3099]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 107 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4452 0.4452]\n",
      "\u001b[1m\n",
      "Iteration = 25:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 224 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2973 0.2973]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 178 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2882 0.2882]\n",
      "\u001b[1m\n",
      "Iteration = 26:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 162 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.301 0.301]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 117 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7 0.7]\n",
      "\u001b[1m\n",
      "Iteration = 27:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 218 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4993 0.4993]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 273 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.5464 1.5464]\n",
      "\u001b[1m\n",
      "Iteration = 28:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 122 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6886 0.6886]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 171 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5534 0.5534]\n",
      "\u001b[1m\n",
      "Iteration = 29:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 142 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.387 0.387]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 760 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3691 0.3691]\n",
      "\u001b[1m\n",
      "Iteration = 30:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 220 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5434 0.5434]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 135 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1716 1.1716]\n",
      "\u001b[1m\n",
      "Iteration = 31:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 281 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3283 0.3283]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 173 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.3975 1.3975]\n",
      "\u001b[1m\n",
      "Iteration = 32:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 170 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3118 0.3118]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 81 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1752 1.1752]\n",
      "\u001b[1m\n",
      "Iteration = 33:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1729 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2722 0.2722]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 79 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1136 1.1136]\n",
      "\u001b[1m\n",
      "Iteration = 34:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 315 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2566 0.2566]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 119 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5977 0.5977]\n",
      "\u001b[1m\n",
      "Iteration = 35:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 671 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3376 0.3376]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 297 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3065 0.3065]\n",
      "\u001b[1m\n",
      "Iteration = 36:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 222 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4572 0.4572]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 192 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1381 1.1381]\n",
      "\u001b[1m\n",
      "Iteration = 37:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 311 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2574 0.2574]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 355 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.71 1.71]\n",
      "\u001b[1m\n",
      "Iteration = 38:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 489 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2832 0.2832]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 95 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.0933 1.0933]\n",
      "\u001b[1m\n",
      "Iteration = 39:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 269 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2584 0.2584]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 77 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.0008 1.0008]\n",
      "\u001b[1m\n",
      "Iteration = 40:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 220 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.347 0.347]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 71 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7335 0.7335]\n",
      "\u001b[1m\n",
      "Iteration = 41:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 192 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.287 0.287]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 187 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.4222 1.4222]\n",
      "\u001b[1m\n",
      "Iteration = 42:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 325 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2528 0.2528]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 69 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.2949 1.2949]\n",
      "\u001b[1m\n",
      "Iteration = 43:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 949 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2538 0.2538]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 338 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2712 0.2712]\n",
      "\u001b[1m\n",
      "Iteration = 44:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 158 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3465 0.3465]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 181 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.507 1.507]\n",
      "\u001b[1m\n",
      "Iteration = 45:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 623 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.317 0.317]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 117 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6446 0.6446]\n",
      "\u001b[1m\n",
      "Iteration = 46:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 219 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2831 0.2831]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 219 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.2462 1.2462]\n",
      "\u001b[1m\n",
      "Iteration = 47:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 613 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2481 0.2481]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 153 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.345 1.345]\n",
      "\u001b[1m\n",
      "Iteration = 48:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 158 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3844 0.3844]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 105 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7843 0.7843]\n",
      "\u001b[1m\n",
      "Iteration = 49:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 313 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2717 0.2717]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 421 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1631 1.1631]\n",
      "\u001b[1m\n",
      "Iteration = 50:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 329 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2525 0.2525]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 340 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4456 0.4456]\n",
      "\u001b[1m\n",
      "Iteration = 51:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 371 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2554 0.2554]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 113 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9514 0.9514]\n",
      "\u001b[1m\n",
      "Iteration = 52:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 909 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2522 0.2522]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 124 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.477 0.477]\n",
      "\u001b[1m\n",
      "Iteration = 53:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 401 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6344 0.6344]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 66 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.0395 1.0395]\n",
      "\u001b[1m\n",
      "Iteration = 54:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 202 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3364 0.3364]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 93 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7147 0.7147]\n",
      "\u001b[1m\n",
      "Iteration = 55:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 255 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.374 0.374]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1001 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [2.6817 2.6817]\n",
      "\u001b[1m\n",
      "Iteration = 56:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 214 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3698 0.3698]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 355 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.8754 1.8754]\n",
      "\u001b[1m\n",
      "Iteration = 57:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 415 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2475 0.2475]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 181 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.8278 1.8278]\n",
      "\u001b[1m\n",
      "Iteration = 58:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 276 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2871 0.2871]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 182 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.4067 1.4067]\n",
      "\u001b[1m\n",
      "Iteration = 59:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 136 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5249 0.5249]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 261 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3674 0.3674]\n",
      "\u001b[1m\n",
      "Iteration = 60:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 253 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2782 0.2782]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 140 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1488 1.1488]\n",
      "\u001b[1m\n",
      "Iteration = 61:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 124 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5589 0.5589]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 91 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6226 0.6226]\n",
      "\u001b[1m\n",
      "Iteration = 62:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 271 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2617 0.2617]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 99 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7021 0.7021]\n",
      "\u001b[1m\n",
      "Iteration = 63:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 173 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2916 0.2916]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 147 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5934 0.5934]\n",
      "\u001b[1m\n",
      "Iteration = 64:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 527 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2608 0.2608]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 216 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.5795 1.5795]\n",
      "\u001b[1m\n",
      "Iteration = 65:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 441 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2548 0.2548]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 590 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4571 0.4571]\n",
      "\u001b[1m\n",
      "Iteration = 66:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 375 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.436 0.436]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 119 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4846 0.4846]\n",
      "\u001b[1m\n",
      "Iteration = 67:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 219 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3113 0.3113]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 67 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8281 0.8281]\n",
      "\u001b[1m\n",
      "Iteration = 68:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 535 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2499 0.2499]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 150 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.3611 1.3611]\n",
      "\u001b[1m\n",
      "Iteration = 69:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 181 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2923 0.2923]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 91 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5783 0.5783]\n",
      "\u001b[1m\n",
      "Iteration = 70:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 997 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2605 0.2605]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 97 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9046 0.9046]\n",
      "\u001b[1m\n",
      "Iteration = 71:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 176 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3071 0.3071]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 171 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.9454 0.9454]\n",
      "\u001b[1m\n",
      "Iteration = 72:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 174 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4151 0.4151]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 107 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.4145 1.4145]\n",
      "\u001b[1m\n",
      "Iteration = 73:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 505 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.519 0.519]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 470 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.696 0.696]\n",
      "\u001b[1m\n",
      "Iteration = 74:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 138 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.869 0.869]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 123 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3644 0.3644]\n",
      "\u001b[1m\n",
      "Iteration = 75:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1769 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2629 0.2629]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 83 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5353 0.5353]\n",
      "\u001b[1m\n",
      "Iteration = 76:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1033 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2539 0.2539]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 241 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4925 0.4925]\n",
      "\u001b[1m\n",
      "Iteration = 77:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 194 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.296 0.296]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 143 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4357 0.4357]\n",
      "\u001b[1m\n",
      "Iteration = 78:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 267 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2622 0.2622]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 84 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7189 0.7189]\n",
      "\u001b[1m\n",
      "Iteration = 79:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 202 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3855 0.3855]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 66 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7751 0.7751]\n",
      "\u001b[1m\n",
      "Iteration = 80:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 228 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2956 0.2956]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 305 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.7004 1.7004]\n",
      "\u001b[1m\n",
      "Iteration = 81:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 239 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2758 0.2758]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 65 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.1052 1.1052]\n",
      "\u001b[1m\n",
      "Iteration = 82:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 272 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2733 0.2733]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 97 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7667 0.7667]\n",
      "\u001b[1m\n",
      "Iteration = 83:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 703 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2731 0.2731]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 93 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6287 0.6287]\n",
      "\u001b[1m\n",
      "Iteration = 84:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 152 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3345 0.3345]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 227 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3848 0.3848]\n",
      "\u001b[1m\n",
      "Iteration = 85:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 124 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4364 0.4364]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 659 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [2.5507 2.5507]\n",
      "\u001b[1m\n",
      "Iteration = 86:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 673 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2606 0.2606]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 61 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.65 0.65]\n",
      "\u001b[1m\n",
      "Iteration = 87:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 1371 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.259 0.259]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 127 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4031 0.4031]\n",
      "\u001b[1m\n",
      "Iteration = 88:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 225 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3067 0.3067]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 69 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.612 0.612]\n",
      "\u001b[1m\n",
      "Iteration = 89:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 327 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2528 0.2528]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 685 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [2.3013 2.3013]\n",
      "\u001b[1m\n",
      "Iteration = 90:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 172 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.6761 0.6761]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 94 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8788 0.8788]\n",
      "\u001b[1m\n",
      "Iteration = 91:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 617 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2901 0.2901]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 115 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8447 0.8447]\n",
      "\u001b[1m\n",
      "Iteration = 92:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 175 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3242 0.3242]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 117 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5208 0.5208]\n",
      "\u001b[1m\n",
      "Iteration = 93:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 158 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8977 0.8977]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 123 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3675 0.3675]\n",
      "\u001b[1m\n",
      "Iteration = 94:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 785 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2508 0.2508]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 330 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2917 0.2917]\n",
      "\u001b[1m\n",
      "Iteration = 95:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 136 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.5865 0.5865]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 123 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7916 0.7916]\n",
      "\u001b[1m\n",
      "Iteration = 96:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 222 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.364 0.364]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 554 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.4566 0.4566]\n",
      "\u001b[1m\n",
      "Iteration = 97:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 154 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3123 0.3123]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 177 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7791 0.7791]\n",
      "\u001b[1m\n",
      "Iteration = 98:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 237 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.266 0.266]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 221 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.7047 0.7047]\n",
      "\u001b[1m\n",
      "Iteration = 99:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 605 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.2469 0.2469]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 133 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [1.0974 1.0974]\n",
      "\u001b[1m\n",
      "Iteration = 100:\u001b[0m\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 166 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.3255 0.3255]\n",
      "\u001b[1m\u001b[34m\n",
      "The algorithm converges after 93 iterations.\n",
      "\u001b[0m\n",
      "Mutual information of encoder and decoder = [0.8923 0.8923]\n"
     ]
    }
   ],
   "source": [
    "# Compute mutual information for encoder and decoder given X and Y_hat for 100 iterations with gamma set to 1\n",
    "en_mi_arr_X_1, de_mi_arr_X_1 = [], []\n",
    "en_mi_arr_Y_1, de_mi_arr_Y_1 = [], []\n",
    "\n",
    "en_mi_arr_X_2, de_mi_arr_X_2 = [], []\n",
    "en_mi_arr_Y_2, de_mi_arr_Y_2 = [], []\n",
    "\n",
    "is_gamma_varied = 0\n",
    "\n",
    "for is_Sigma_Z_diagonal in (0, 1):\n",
    "    if is_Sigma_Z_diagonal == 0:\n",
    "        print(colored('a. Arbitrary Sigma_Z', 'red', attrs=['bold']))\n",
    "    else: \n",
    "        print(colored('\\nb. Diagonalized Sigma_Z', 'red', attrs=['bold']))\n",
    "        \n",
    "    for i, gamma in enumerate(gamma_arr):\n",
    "        print(colored('\\nIteration = {}:'.format(i+1), attrs = ['bold']))\n",
    "        for flag, mi_arr in enumerate([print_mutual_info_recon_err(0, is_Sigma_Z_diagonal, is_gamma_varied),\n",
    "                                       print_mutual_info_recon_err(1, is_Sigma_Z_diagonal, is_gamma_varied)]):\n",
    "            en_mi, de_mi = mi_arr[:2]\n",
    "\n",
    "            if is_Sigma_Z_diagonal == 0:\n",
    "                # Arbitrary Sigma_Z\n",
    "                if flag == 0:\n",
    "                    en_mi_arr_X_1 = np.concatenate((en_mi_arr_X_1, [en_mi]))\n",
    "                    de_mi_arr_X_1 = np.concatenate((de_mi_arr_X_1, [de_mi]))\n",
    "                else:\n",
    "                    en_mi_arr_Y_1 = np.concatenate((en_mi_arr_Y_1, [en_mi]))\n",
    "                    de_mi_arr_Y_1 = np.concatenate((de_mi_arr_Y_1, [de_mi]))\n",
    "            else:\n",
    "                # Diagonalized Sigma_Z\n",
    "                if flag == 0:\n",
    "                    en_mi_arr_X_2 = np.concatenate((en_mi_arr_X_2, [en_mi]))\n",
    "                    de_mi_arr_X_2 = np.concatenate((de_mi_arr_X_2, [de_mi]))\n",
    "                else:\n",
    "                    en_mi_arr_Y_2 = np.concatenate((en_mi_arr_Y_2, [en_mi]))\n",
    "                    de_mi_arr_Y_2 = np.concatenate((de_mi_arr_Y_2, [de_mi]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "849454ae",
   "metadata": {},
   "source": [
    "### 3. Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "eb6da751",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven encoder X:\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mGiven decoder Y_hat:\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(colored('Given encoder X:', attrs=['bold']))\n",
    "plot_mutual_info(en_mi_arr_X_1, de_mi_arr_X_1, en_mi_arr_X_2, de_mi_arr_X_2)\n",
    "\n",
    "print(colored('Given decoder Y_hat:', attrs=['bold']))\n",
    "plot_mutual_info(en_mi_arr_Y_1, de_mi_arr_Y_1, en_mi_arr_Y_2, de_mi_arr_Y_2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}