SDL_simulation_J2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b2b59fc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from tqdm import trange\n",
    "import matplotlib.pyplot as plt\n",
    "from src.SDL_SVP import SDL_SVP\n",
    "from src.SDL_BCD import SDL_BCD\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "import matplotlib.gridspec as gridspec\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.decomposition import SparseCoder\n",
    "from sklearn.metrics import roc_curve\n",
    "from scipy.spatial import ConvexHull\n",
    "\n",
    "from sklearn.datasets import fetch_openml\n",
    "from PIL import Image, ImageOps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "36aea674",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return 1/(1+np.exp(-x))\n",
    "\n",
    "def generate_Y(H, Beta, n):\n",
    "    Y = np.zeros(n)\n",
    "    prob = sigmoid(H @ Beta - np.mean(H @ Beta))\n",
    "  \n",
    "    for i in range(n):\n",
    "        U = np.random.rand()\n",
    "        if U < prob[i]:\n",
    "            Y[i] = 1\n",
    "    print('proportion of 1s:', np.sum(Y)/n)\n",
    "    return Y    \n",
    "\n",
    "def list2onehot(y, list_classes):\n",
    "    \"\"\"\n",
    "    y = list of class lables of length n\n",
    "    output = n x k array, i th row = one-hot encoding of y[i] (e.g., [0,0,1,0,0])\n",
    "    \"\"\"\n",
    "    Y = np.zeros(shape = [len(y), len(list_classes)], dtype=int)\n",
    "    for i in np.arange(Y.shape[0]):\n",
    "        for j in np.arange(len(list_classes)):\n",
    "            if y[i] == list_classes[j]:\n",
    "                Y[i,j] = 1\n",
    "    return Y\n",
    "\n",
    "def sample_MNIST(X, y, list_digits = ['1', '2'], basis_size=None):\n",
    "    \n",
    "    # get subset of data from MNIST of given digits\n",
    "    # basis_size = [r1, r2]\n",
    "    \n",
    "    Y = list2onehot(y.tolist(), list_digits)\n",
    "\n",
    "    ## Sampling \n",
    "    idx = []\n",
    "    for j in range(len(list_digits)):\n",
    "      idx0 = [i for i in range(len(y)) if y[i] == list_digits[j]] \n",
    "      if basis_size is None:\n",
    "        idx = idx + idx0\n",
    "      if basis_size is not None:\n",
    "        idx = idx + list(np.random.choice(idx0, basis_size[j], replace = False))\n",
    "\n",
    "    X0 = X[idx,:]\n",
    "    y0 = Y[idx,:]\n",
    "\n",
    "    return X0, y0    \n",
    "\n",
    "def sim_data_gen_MNIST(r = [2, 2], n = 1000,\n",
    "                       digits_X = ['2', '7'],\n",
    "                       digits_Y = ['1', '4'],\n",
    "                       noise_std = 0,\n",
    "                       random_seed = 1):\n",
    "    \n",
    "    np.random.seed(random_seed)\n",
    "\n",
    "    # Load data\n",
    "    X, y = fetch_openml('mnist_784', version = 1, return_X_y = True) # pandas dataframe\n",
    "    X = X / 255.\n",
    "    X = np.asarray(X) \n",
    "\n",
    "    W_true, temp = sample_MNIST(X, y, list_digits = digits_X, basis_size = r)\n",
    "    W_true_Y, y0 = sample_MNIST(X, y, list_digits = digits_Y, basis_size = r)\n",
    "    p = W_true.shape[1] \n",
    "\n",
    "    Beta_true = (2*y0[:,0]-1) # 1 if Y = first digit, -1 if Y = second digit\n",
    "    print('Beta_true', Beta_true)\n",
    "\n",
    "    Sigma = ((noise_std)**2) * np.eye(p)\n",
    "    Noise = np.random.multivariate_normal(np.zeros(p),  Sigma, n)\n",
    "\n",
    "    H_true = np.random.rand(n, sum(r))\n",
    "    X = H_true @ W_true\n",
    "\n",
    "    Y = generate_Y(X @ W_true.T, Beta_true, n) # true labels\n",
    "    X += Noise # corrupt true signal\n",
    "\n",
    "    X_train, X_test, Y_train, Y_test, H_train, H_test = train_test_split(X, Y, H_true, test_size = 0.2)\n",
    "    \n",
    "    X, X_train, X_test = X.T, X_train.T, X_test.T\n",
    "    H_true, H_train, H_test = H_true.T, H_train.T, H_test.T\n",
    "    Y, Y_train, Y_test = Y[np.newaxis,:], Y_train[np.newaxis,:], Y_test[np.newaxis,:]\n",
    "    W_true, W_true_Y, Beta_true = W_true.T, W_true_Y.T, Beta_true[np.newaxis,:]\n",
    "\n",
    "    print('X_train.shape', X_train.shape)\n",
    "    print('Y_train.shape', Y_train.shape)\n",
    "    print('X_test.shape', X_test.shape)\n",
    "    print('Y_test.shape', Y_test.shape)\n",
    "\n",
    "    return X_train, X_test, Y_train, Y_test, W_true, W_true_Y, H_true, H_train, H_test, Beta_true\n",
    "\n",
    "def compute_accuracy_metrics(Y_test, P_pred, train_data=None, verbose=False):\n",
    "    # y_test = binary label\n",
    "    # P_pred = predicted probability for y_test\n",
    "    # train_data = [X_train, ]\n",
    "    # compuate various binary classification accuracy metrics\n",
    "    # Compute classification statistics\n",
    "\n",
    "    if train_data is not None:\n",
    "        Y_train, P_train = train_data\n",
    "        fpr, tpr, thresholds = metrics.roc_curve(Y_train, P_train, pos_label=None)\n",
    "        mythre = thresholds[np.argmax(tpr - fpr)]\n",
    "        myauc = round(metrics.auc(fpr, tpr), 4)\n",
    "        print('threshold from training set used:', mythre)\n",
    "    else:\n",
    "        fpr, tpr, thresholds = metrics.roc_curve(Y_test, P_pred, pos_label=None)\n",
    "        mythre = thresholds[np.argmax(tpr - fpr)]\n",
    "        myauc = round(metrics.auc(fpr, tpr), 4)\n",
    "\n",
    "    threshold = round(mythre, 4)\n",
    "\n",
    "    Y_pred = P_pred.copy()\n",
    "    Y_pred[Y_pred < threshold] = 0\n",
    "    Y_pred[Y_pred >= threshold] = 1\n",
    "\n",
    "    mcm = confusion_matrix(Y_test, Y_pred)\n",
    "    tn = mcm[0, 0]\n",
    "    tp = mcm[1, 1]\n",
    "    fn = mcm[1, 0]\n",
    "    fp = mcm[0, 1]\n",
    "\n",
    "    accuracy = round( (tp + tn) / (tp + tn + fp + fn), 4)\n",
    "    misclassification = round(1 - accuracy, 4)\n",
    "    sensitivity = round(tp / (tp + fn), 4)\n",
    "    specificity = round(tn / (tn + fp), 4)\n",
    "    precision = round(tp / (tp + fp), 4)\n",
    "    recall = round(tp / (tp + fn), 4)\n",
    "    fall_out = round(fp / (fp + tn), 4)\n",
    "    miss_rate = round(fn / (fn + tp), 4)\n",
    "    F_score = round(2 * precision * recall / ( precision + recall ), 4)\n",
    "\n",
    "    # Save results\n",
    "    results_dict = {}\n",
    "    #results_dict.update({'Y_test': Y_test})\n",
    "    #results_dict.update({'Y_pred': Y_pred})\n",
    "    results_dict.update({'AUC': myauc})\n",
    "    results_dict.update({'Opt_threshold': threshold})\n",
    "    results_dict.update({'Accuracy': accuracy})\n",
    "    results_dict.update({'Sensitivity': sensitivity})\n",
    "    results_dict.update({'Specificity': specificity})\n",
    "    results_dict.update({'Precision': precision})\n",
    "    #results_dict.update({'Fall_out': fall_out})\n",
    "    #results_dict.update({'Miss_rate': miss_rate})\n",
    "    results_dict.update({'F_score': F_score})\n",
    "\n",
    "    if verbose:\n",
    "        for key in [key for key in results_dict.keys() if key not in ['Y_test', 'Y_pred']]:\n",
    "            print('% s ===> %.3f' % (key, results_dict.get(key)))\n",
    "    return results_dict\n",
    "\n",
    "def coding(X, W, H0,\n",
    "          r=None,\n",
    "          a1=0, #L1 regularizer\n",
    "          a2=0, #L2 regularizer\n",
    "          sub_iter=[5],\n",
    "          stopping_grad_ratio=0.0001,\n",
    "          nonnegativity=True,\n",
    "          subsample_ratio=1):\n",
    "    \"\"\"\n",
    "    Find \\hat{H} = argmin_H ( || X - WH||_{F}^2 + a1*|H| + a2*|H|_{F}^{2} ) within radius r from H0\n",
    "    Use row-wise projected gradient descent\n",
    "    \"\"\"\n",
    "    if H0 is None:\n",
    "        H0 = np.random.rand(W.shape[1],X.shape[1])\n",
    "\n",
    "    H1 = H0.copy()\n",
    "    i = 0\n",
    "    dist = 1\n",
    "    idx = np.arange(X.shape[1])\n",
    "    if subsample_ratio>1:  # subsample columns of X and solve reduced problem (like in SGD)\n",
    "        idx = np.random.randint(X.shape[1], size=X.shape[1]//subsample_ratio)\n",
    "    A = W.T @ W ## Needed for gradient computation\n",
    "\n",
    "    grad = W.T @ (W @ H0 - X)\n",
    "    while (i < np.random.choice(sub_iter)):\n",
    "        step_size = (1 / (((i + 1) ** (1)) * (np.trace(A) + 1)))\n",
    "        H1 -= step_size * grad\n",
    "        if nonnegativity:\n",
    "            H1 = np.maximum(H1, 0)  # nonnegativity constraint\n",
    "        i = i + 1\n",
    "        # print('iteration %i, reconstruction error %f' % (i, np.linalg.norm(X-W@H1)**2))\n",
    "    return H1\n",
    "\n",
    "def ALS(X,\n",
    "        n_components = 10, # number of columns in the dictionary matrix W\n",
    "        n_iter=100,\n",
    "        a0 = 0, # L1 regularizer for H\n",
    "        a1 = 0, # L1 regularizer for W\n",
    "        a12 = 0, # L2 regularizer for W\n",
    "        H_nonnegativity=True,\n",
    "        W_nonnegativity=True,\n",
    "        compute_recons_error=False,\n",
    "        subsample_ratio = 10):\n",
    "\n",
    "        '''\n",
    "        Given data matrix X, use alternating least squares to find factors W,H so that\n",
    "                                || X - WH ||_{F}^2 + a0*|H|_{1} + a1*|W|_{1} + a12 * |W|_{F}^{2}\n",
    "        is minimized (at least locally)\n",
    "        '''\n",
    "\n",
    "        d, n = X.shape\n",
    "        r = n_components\n",
    "\n",
    "        #normalization = np.linalg.norm(X.reshape(-1,1),1)/np.product(X.shape) # avg entry of X\n",
    "        #print('!!! avg entry of X', normalization)\n",
    "        #X = X/normalization\n",
    "\n",
    "        # Initialize factors\n",
    "        W = np.random.rand(d,r)\n",
    "        H = np.random.rand(r,n)\n",
    "        # H = H * np.linalg.norm(X) / np.linalg.norm(H)\n",
    "        for i in trange(n_iter):\n",
    "            #H = coding_within_radius(X, W.copy(), H.copy(), a1=a0, nonnegativity=H_nonnegativity, subsample_ratio=subsample_ratio)\n",
    "            #W = coding_within_radius(X.T, H.copy().T, W.copy().T, a1=a1, a2=a12, nonnegativity=W_nonnegativity, subsample_ratio=subsample_ratio).T\n",
    "            H = coding(X, W.copy(), H.copy(), a1=a0, nonnegativity=H_nonnegativity, subsample_ratio=subsample_ratio)\n",
    "            W = coding(X.T, H.copy().T, W.copy().T, a1=a1, a2=a12, nonnegativity=W_nonnegativity, subsample_ratio=subsample_ratio).T\n",
    "            if compute_recons_error and (i % 10 == 0) :\n",
    "                print('iteration %i, reconstruction error %f' % (i, np.linalg.norm(X-W@H)**2))\n",
    "        return W, H\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "281b8224",
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_dictionary_list(W_list, grid_shape=None, fig_size=None, label_list=None, save_path=None, score_list=None):\n",
    "    \n",
    "    # Make plot\n",
    "    \n",
    "    # outer gridspec\n",
    "    if fig_size is None:\n",
    "        figsize = [10, 10]\n",
    "    else: \n",
    "        figsize = fig_size\n",
    "    \n",
    "    fig = plt.figure(figsize=figsize, constrained_layout=False)\n",
    "    outer_grid = gridspec.GridSpec(nrows=1, ncols=1, wspace=0.1, hspace=0.05)\n",
    "\n",
    "    # make nested gridspecs\n",
    "    \n",
    "    k = int(np.sqrt(W_list.shape[0]))\n",
    "    if grid_shape is None:\n",
    "        sub_rows = int(np.ceil(np.sqrt(W_list.shape[1])))\n",
    "        sub_cols = int(np.floor(np.sqrt(W_list.shape[1])))\n",
    "    else:\n",
    "        sub_rows, sub_cols = grid_shape[0], grid_shape[1]\n",
    "\n",
    "    idx = np.arange(W_list.shape[1])\n",
    "    if score_list is not None:\n",
    "        idx = np.argsort(score_list)\n",
    "        idx = np.flip(idx)    \n",
    "\n",
    "    inner_grid = outer_grid[0].subgridspec(sub_rows, sub_cols, wspace=0.05, hspace=0.05)\n",
    "\n",
    "    for j in range(sub_rows*sub_cols):\n",
    "        a = j // sub_cols \n",
    "        b = j % sub_cols #sub-lattice indices\n",
    "\n",
    "        ax = fig.add_subplot(inner_grid[a, b])\n",
    "        ax.imshow(W_list.T[idx[j]].reshape(k, k), cmap=\"viridis\", interpolation='nearest')\n",
    "        ax.set_xticks([])\n",
    "        if (b>0):\n",
    "            ax.set_yticks([])\n",
    "        if (a < sub_rows-1):\n",
    "            ax.set_xticks([])\n",
    "        if (score_list is not None):\n",
    "            ax.set_xlabel('%1.2f' % score_list[idx[j]], fontsize=13)  # get the largest first\n",
    "            ax.xaxis.set_label_coords(0.5, -0.07)\n",
    "           \n",
    "    # plt.suptitle('Dictionary learned from patches of size %d' % k, fontsize=16)\n",
    "    plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)\n",
    "    #if save_path is not None:\n",
    "    #    plt.savefig(save_nasave_pathme, bbox_inches='tight')\n",
    "    \n",
    "def display_dictionary_list2(W_list, grid_shape=None, fig_size=None, label_list=None, save_path=None, score_list=None):\n",
    "    \n",
    "    # Make plot\n",
    "    \n",
    "    # outer gridspec\n",
    "    nrows=1\n",
    "    ncols=len(W_list)\n",
    "    \n",
    "    if fig_size is None:\n",
    "        figsize = [10, 10]\n",
    "    else: \n",
    "        figsize = fig_size\n",
    "        \n",
    "    fig = plt.figure(figsize=fig_size, constrained_layout=False)\n",
    "    outer_grid = gridspec.GridSpec(nrows=nrows, ncols=ncols, wspace=0.1, hspace=0.05)\n",
    "\n",
    "    # make nested gridspecs\n",
    "    for i in range(1 * ncols):\n",
    "        k = int(np.sqrt(W_list[i].shape[0]))\n",
    "        if grid_shape is None:\n",
    "            sub_rows = int(np.ceil(np.sqrt(W_list[i].shape[1])))\n",
    "            sub_cols = int(np.floor(np.sqrt(W_list[i].shape[1])))\n",
    "        else:\n",
    "            sub_rows, sub_cols = grid_shape[0], grid_shape[1]\n",
    "            \n",
    "        idx = np.arange(W_list[i].shape[1])\n",
    "        if score_list is not None:\n",
    "            idx = np.argsort(score_list[i])\n",
    "            idx = np.flip(idx)    \n",
    "        \n",
    "        inner_grid = outer_grid[i].subgridspec(sub_rows, sub_cols, wspace=0.05, hspace=0.05)\n",
    "\n",
    "        for j in range(sub_rows*sub_cols):\n",
    "            a = j // sub_cols \n",
    "            b = j % sub_cols #sub-lattice indices\n",
    "\n",
    "            ax = fig.add_subplot(inner_grid[a, b])\n",
    "            ax.imshow(W_list[i].T[idx[j]].reshape(k, k), cmap=\"viridis\", interpolation='nearest')\n",
    "            ax.set_xticks([])\n",
    "            if (b>0):\n",
    "                ax.set_yticks([])\n",
    "            if (a < sub_rows-1):\n",
    "                ax.set_xticks([])\n",
    "            if (a == 0) and (b==2):\n",
    "                #ax.set_title(\"W_nonnegativity$=$ %s \\n H_nonnegativity$=$ %s\" \n",
    "                #             % (str(nonnegativity_list[i][0]), str(nonnegativity_list[i][1])), y=1.2, fontsize=14) \n",
    "                if label_list is not None:\n",
    "                    ax.set_title(label_list[i], y=1.2, fontsize=14)\n",
    "            if (score_list is not None) and (score_list[i] is not None):\n",
    "                ax.set_xlabel('%1.2f' % score_list[i][idx[j]], fontsize=13)  # get the largest first\n",
    "                ax.xaxis.set_label_coords(0.5, -0.07)\n",
    "           \n",
    "    # plt.suptitle('Dictionary learned from patches of size %d' % k, fontsize=16)\n",
    "    plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)\n",
    "    #if save_path is not None:\n",
    "    #    plt.savefig(save_nasave_pathme, bbox_inches='tight')\n",
    "       \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "763c6079",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beta_true [ 1 -1]\n",
      "proportion of 1s: 0.494\n",
      "X_train.shape (784, 800)\n",
      "Y_train.shape (1, 800)\n",
      "X_test.shape (784, 200)\n",
      "Y_test.shape (1, 200)\n"
     ]
    }
   ],
   "source": [
    "r0 = 1\n",
    "X_train, X_test, Y_train, Y_test, W_true, W_true_Y, H_true, H_train, H_test, Beta_true = sim_data_gen_MNIST(r = [r0, r0], n = 1000, digits_X = ['2', '5'], digits_Y = ['4', '7'], noise_std = 1, random_seed = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1a96f8bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_dictionary_list(W_true, grid_shape=[1,2], fig_size=[4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9e9c9f01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARMAAACJCAYAAAAPI9wpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAKdklEQVR4nO3dfZDVVR3H8c+X3QUUBFxNQB4kdDFNTJIHSUdN0pEeBKNMMoZIXcdMcIYaGMdSRh2QabQsR8VEqczUzETTUMnCJp8WcSJ5VAJdXMEHHEwEdtnTH95Jvr/f3b139559uHvfr3+433PP7/c7+tv53nO/99xzLYQgAChUt44eAICugWQCIAqSCYAoSCYAoiCZAIiCZAIgioKSiZmdbWbrzexVM5sba1AAio+1dp2JmZVJ2iDpTEm1kl6UNDWEsKapY7pbj9BTvVp1PXReu/Wh9oY9lmznfndNTd3v8gLOOVbSqyGETZJkZr+XNElSk8mkp3ppnE0o4JLojJ4Py7O2c7+7pqbudyFvcwZJemO/uDbT5phZtZnVmFlNvfYUcDkAnVmbF2BDCItCCKNDCKMr1KOtLweggxSSTLZKGrJfPDjTBqAEFZJMXpRUZWafNrPuks6XtDTOsAAUm1YXYEMIDWb2A0nLJJVJWhxCeCXayAAUlUI+zVEI4TFJj0UaC4AixgpYAFGQTABEQTIBEAXJBEAUBRVgEddHk8a6eNjcdak+/1l4jIsPfOj5Nh0TkC9mJgCiIJkAiIJkAiAKaiadyFnXrnDxjw5Zneoz44dlLn73oTYdEpA3ZiYAoiCZAIiCZAIgCmomRea5jcNdXKWVHTQSwGNmAiAKkgmAKEgmAKKgZlJkKmq7d/QQgKyYmQCIgmQCIAqSCYAoSCYAoqAA24F2nTvOxZcdfFOiR0X7DQZtrnzIYBe/d4qP3/7a7tQx609b7OKqBy/18czOszkWMxMAUZBMAERBMgEQBTUTSWWHVLr41dlHp/pc943fufiu877i4saX17T4ulvP8HHvbj1yHjPob3tbfB10jE0Lx7t4weR7XHxOrx0ublRj6hyNidf7tVN+6c8xc0whQ4yKmQmAKEgmAKIgmQCIgpqJpLNWbHLxQ/2W5Txm3o/NxYOn5L5O2TFVLr5tol9DkO09c1LFU2yG1B7K+vV18ZvTPuviiy99xMXVfTenztFNL7m4USHxvP8byvbanuxz+upvubi3/N9uR2JmAiAKkgmAKEgmAKLIWTMxs8WSvippewjhuExbpaT7JA2TtFnSeSGEHU2do7N5p9p//n9ZP//Zfe7KRevUH9rbxacdsKvZ/qesuiDVVqkNUccESWNHpprWTTvQxWu//nMXd0u8Dmevd/k+t7x/pIsfeOPzLv7ryPtynuOAG/pl6dM55DMzuVvS2Ym2uZKWhxCqJC3PxABKWM5kEkJYIem9RPMkSUsyj5dImhx3WACKTWtrJv1DCHWZx29J6h9pPACKVMEF2BBCkBIfoO/HzKrNrMbMauq1p9DLAeikWrtobZuZDQwh1JnZQEnbm+oYQlgkaZEk9bHKJpNOezp/5hMuPvnl8138zAn+S33Z1G/oE3VM2bxT2y/VVpnuhhZqmHCii6+/Y1Gqz5gefrFY8gt3V28f5eIHnjg5dY7hD/7XxeV1/jMKu8P3TxZ1JenPu/ziuR4bt7m4IXVEx2ntzGSppOmZx9MlPRxnOACKVc5kYmb3SnpW0tFmVmtmF0paIOlMM9so6UuZGEAJy/k2J4QwtYmnJkQeC4AiVhJf9AvjP+fi+37mFyQddsGWnOeYsfksFw//if/CXacoBiEvyRrJqB65NyVKLkpbOco/P1zP5rzuljlfcPGqkb9o9hqSdP38aS6urM19nY7CcnoAUZBMAERBMgEQRUnUTLaP6eXiF+f496oVVubi+pDOsa9/cLCLe9UX/r3GbOsK0Pa6ma9NZLsPIx6/xMXHXlOX6LE153UazvDrWX51if+7S258tHJPehyViztvjSSJv2YAUZBMAERBMgEQRUnUTHYf6leBJD/Pr08sErlqu3+vK0l9v++Pac13InYN6N7sONA+rvnyt128d8BBqT4jnq5xcWvu95aL9rk4uZ4luZZlxpLLU+cYqn+24sodg5kJgChIJgCiIJkAiIJkAiCKLleAffei8am2pdN/mmjpnuqzv8ryD1NtFXd95OMcO1UmF0ZJ0uzDF2fp2bT5X3wg1Xb/itEubkwssHtl60AXV13+euoc+95NbulbWvat3ejisrWFn7N8yOBU2/rTkr/Y2PwGS0PnFU+xNRtmJgCiIJkAiIJkAiCKoq+ZlA/wtYtvznoq1eeI8uZrJElXVK7Jq6052b481tJFauf2Tu/TPaX3X5o953FbL3Zx2Fvfomuidcp+m17W1qjmF0smN6HOZ4OlzoyZCYAoSCYAoiCZAIii6Gsme6sOd/EVlY920Ei8K7eNTrVd1/+Flp3jrXGptnVTEusZgn9fftS2dS5u3L27RddEfsqOHeHiK4fcm+qT3Pyo+o0zXDx8TnHXSJKYmQCIgmQCIAqSCYAoir5m0u2ZVS4+/q6ZqT63T73dxRf9qdrFR85+Lvq4yg45ONV264oqF1/W77Vmz5Gqj0hq2Jz+rg3a384b/bqSfH7I67nHR7q4mDY+ygczEwBRkEwAREEyARAFyQRAFEVfgE0adlV6IdD8q4538ZGKX3BNsp49U22nH7jexckCXVLtuekC7ICbKMB2hOTmR38f+QcXZ7uXyV8FHFHkmx/lwswEQBQkEwBR5EwmZjbEzJ42szVm9oqZzcq0V5rZk2a2MfNvemEFgJKRT82kQdLsEMJLZnaQpJVm9qSk70paHkJYYGZzJc2VNKfthlpcGra+mWr7zqrvuXjluLubPcfOo9Mb7gwoaFRorTVX+//zuTY+kqShD5fWxD/nf20IoS6E8FLm8QeS1koaJGmSpCWZbkskTW6jMQIoAi1KnWY2TNIoSc9L6h9CqMs89ZaU47cfAHRpeScTM+st6UFJV4QQdu7/XAghSIl53yfHVZtZjZnV1GtPQYMF0Hnltc7EzCr0cSK5J4Twx0zzNjMbGEKoM7OBktK7H0sKISyStEiS+lhl1oSD7Pqs73LLgIrGzqknuXjDxFtcnNz4aOz8WalzHPZI115XkpTPpzkm6U5Ja0MIN+731FJJ0zOPp0t6OP7wABSLfF76TpY0TdJqM3s503alpAWS7jezCyVtkXRem4wQQFHImUxCCP+QEnO6T0yIOxwAxYo35e2ocVVf35DYL/rmHZ9x8aC707+ovS/2oJDVsbP+7eLkOpLb3j/KxQN/7ftLpXevSmtVDYA2QzIBEAXJBEAUJBMAUVCAbUdDrvWLmM65dkyOI3a03WDwf5sWjk+1LRt6q4vrg3/dfXTGqf6Anaujj6vYMDMBEAXJBEAUJBMAUVAzQclJbg69YPI9qT71wS85O/Vf/tsifV6gRpLEzARAFCQTAFGQTABEQc0EJWfDDYe6+Jxe6fU8894+wcV9Jr7WlkPqEpiZAIiCZAIgCpIJgCiomaDk/OakO12c7Qe0lt18iosr9WybjqkrYGYCIAqSCYAoSCYAoiCZAIiCAixKztXDT8zZh4JryzEzARAFyQRAFCQTAFFYCKH9Lmb2tj7+XWJ0LUeEED6VbOR+d1nZ73d7JhMAXRdvcwBEQTIBEAXJBEAUJBMAUZBMAERBMgEQBckEQBQkEwBRkEwARPE/fNdPJ+mXq2wAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_dictionary_list(W_true_Y, grid_shape=[1,2], fig_size=[4,4])\n",
    "# first one - 1 / second picture - 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "820ea754",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "threshold from training set used: 0.9598646575906705\n",
      "AUC ===> 1.000\n",
      "Opt_threshold ===> 0.960\n",
      "Accuracy ===> 0.800\n",
      "Sensitivity ===> 0.678\n",
      "Specificity ===> 0.900\n",
      "Precision ===> 0.847\n",
      "F_score ===> 0.753\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'AUC': 1.0,\n",
       "  'Opt_threshold': 0.9599,\n",
       "  'Accuracy': 0.8,\n",
       "  'Sensitivity': 0.6778,\n",
       "  'Specificity': 0.9,\n",
       "  'Precision': 0.8472,\n",
       "  'F_score': 0.7531,\n",
       "  'method': 'LR',\n",
       "  'xi': None,\n",
       "  'Relative_reconstruction_loss (test)': 1}]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_dict_list = []\n",
    "iteration = 300\n",
    "r = 2*r0\n",
    "\n",
    "### LR\n",
    "clf = LogisticRegression(random_state=0).fit(X_train.T, Y_train[0,:])\n",
    "P_train = clf.predict_proba(X_train.T)\n",
    "P_pred = clf.predict_proba(X_test.T)\n",
    "results = compute_accuracy_metrics(Y_test[0], P_pred[:,1], train_data = [Y_train[0], P_train[:,1]], verbose=True)\n",
    "\n",
    "results.update({'method': 'LR'})\n",
    "results.update({'xi': None})\n",
    "results.update({'Relative_reconstruction_loss (test)': 1})\n",
    "results_dict_list.append(results.copy())\n",
    "results_dict_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "b11fe33d",
   "metadata": {},
   "outputs": [
    {
     "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": [
    "fpr, tpr, _ = roc_curve(Y_test[0], P_pred[:,1])\n",
    "roc_auc = auc(fpr, tpr)\n",
    "plt.figure()\n",
    "lw = 2\n",
    "plt.plot(\n",
    "    fpr,\n",
    "    tpr,\n",
    "    color=\"darkorange\",\n",
    "    lw=lw,\n",
    "    label=\"ROC curve (area = %0.2f)\" % roc_auc,\n",
    ")\n",
    "plt.plot([0, 1], [0, 1], color=\"navy\", lw=lw, linestyle=\"--\")\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel(\"False Positive Rate\")\n",
    "plt.ylabel(\"True Positive Rate\")\n",
    "plt.title(\"Receiver operating characteristic example\")\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "65b47162",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|▋                                                    | 4/300 [00:00<00:07, 38.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MF->LR\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:08<00:00, 35.62it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "threshold from training set used: 0.4402973316708951\n",
      "AUC ===> 0.961\n",
      "Opt_threshold ===> 0.440\n",
      "Accuracy ===> 0.880\n",
      "Sensitivity ===> 0.911\n",
      "Specificity ===> 0.855\n",
      "Precision ===> 0.837\n",
      "F_score ===> 0.872\n"
     ]
    }
   ],
   "source": [
    "# MF --> LR\n",
    "print('MF->LR')\n",
    "W, H = ALS(X_train,\n",
    "            n_components = r, # number of columns in the dictionary matrix W\n",
    "            n_iter=iteration,\n",
    "            a0 = 0, # L1 regularizer for H\n",
    "            a1 = 0, # L1 regularizer for W\n",
    "            a12 = 0, # L2 regularizer for W\n",
    "            H_nonnegativity=True,\n",
    "            W_nonnegativity=True,\n",
    "            compute_recons_error=False,\n",
    "            subsample_ratio = 1)\n",
    "\n",
    "clf = LogisticRegression(random_state=0).fit((W.T @ X_train).T, Y_train[0,:])\n",
    "P_train = clf.predict_proba((W.T @ X_train).T)\n",
    "P_pred = clf.predict_proba((W.T @ X_test).T)\n",
    "results = compute_accuracy_metrics(Y_test[0], P_pred[:,1], train_data=[Y_train[0], P_train[:,1]], verbose=True)\n",
    "results.update({'xi': None})\n",
    "results.update({'method': 'MF-->LR'})\n",
    "\n",
    "coder = SparseCoder(dictionary=W.T, transform_n_nonzero_coefs=None,\n",
    "                        transform_alpha=0, transform_algorithm='lasso_lars', positive_code=True)\n",
    "H1 = coder.transform(X_test.T).T\n",
    "error_data = np.linalg.norm((X_test - W @ H1).reshape(-1, 1), ord=2)**2\n",
    "rel_error_data = error_data / np.linalg.norm(X_test.reshape(-1, 1), ord=2)**2\n",
    "results.update({'Relative_reconstruction_loss (test)': rel_error_data})\n",
    "results_dict_list.append(results.copy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "87e6338c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_dictionary_list2([W_true_Y], grid_shape=[1,2], fig_size=[4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "4c477942",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_dictionary_list2([W], grid_shape=[1,2], fig_size=[4,4], score_list = clf.coef_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e61ae04a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:22<00:00,  8.99it/s]\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:21<00:00,  9.43it/s]\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:21<00:00,  9.12it/s]\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:21<00:00,  9.15it/s]\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:22<00:00,  8.93it/s]\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:22<00:00,  8.76it/s]\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:23<00:00,  8.61it/s]\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:22<00:00,  8.93it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.665 1.68  1.715 1.71 ]\n"
     ]
    }
   ],
   "source": [
    "### SNMF - filter_based learning\n",
    "\n",
    "iteration1 = 200\n",
    "\n",
    "# Cross-validation\n",
    "xi_list = [0, 0.1, 1, 5, 10]\n",
    "beta = 1\n",
    "iter_avg = 2\n",
    "\n",
    "SNMF_AUC_array = np.zeros(shape=[iter_avg, len(xi_list)])\n",
    "for j in range(len(xi_list)):\n",
    "    xi = xi_list[j]\n",
    "    for i in range(iter_avg):\n",
    "        SNMF_class_new = SNMF(X=[X_train, Y_train],  # data, label\n",
    "                        X_test=[X_test, Y_test],\n",
    "                        n_components=r,  # =: r = number of columns in dictionary matrices W, W'\n",
    "                        # ini_loading=None,  # Initialization for [W,W'], W1.shape = [d1, r], W2.shape = [d2, r]\n",
    "                        #ini_loading=[W_true, np.hstack((np.array([[0]]), Beta_true))],\n",
    "                        #ini_code = H_true, \n",
    "                        xi=xi,  # weight on label reconstruction error\n",
    "                        L1_reg = [0,0,0], # L1 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                        L2_reg = [0,0,0], # L2 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                        nonnegativity=[True,True,False], # nonnegativity constraints on code H, dictionary W[0], reg params W[1]\n",
    "                        full_dim=False) # if true, dictionary is Id with full dimension --> Pure regression\n",
    "\n",
    "        results_dict_new_snmf_cv = SNMF_class_new.train_logistic(iter=iteration1, subsample_size=None, \n",
    "                                                beta = beta,\n",
    "                                                search_radius_const=1,\n",
    "                                                update_nuance_param=False,\n",
    "                                                if_compute_recons_error=False, if_validate=False)\n",
    "        #results_dict_new.update({'method': 'SDL-filt'})\n",
    "        #results_dict_new.update({'beta': beta})\n",
    "        #results_dict_list.append(results_dict_new.copy())\n",
    "        SNMF_AUC_array[i, j] = results_dict_new_snmf_cv.get('Accuracy')\n",
    "        # print('Beta_learned', results_dict.get('loading')[1])\n",
    "\n",
    "print(np.sum(SNMF_AUC_array, 0))        \n",
    "xi_SNMF = xi_list[np.argmax(np.sum(SNMF_AUC_array, 0))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "dcfa4472",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:35<00:00,  8.56it/s]\n"
     ]
    }
   ],
   "source": [
    "beta = 1\n",
    "xi_SNMF = xi_list[np.argmax(np.sum(SNMF_AUC_array, 0))]\n",
    "#xi_SNMF = 0.1\n",
    "\n",
    "# Analysis\n",
    "\n",
    "SNMF_class_new = SNMF(X=[X_train, Y_train],  # data, label\n",
    "                X_test=[X_test, Y_test],\n",
    "                n_components=r,  # =: r = number of columns in dictionary matrices W, W'\n",
    "                ini_loading=[W_true, np.hstack((np.array([[0]]), Beta_true))],\n",
    "                ini_code = H_train, \n",
    "                xi=xi_SNMF,  # weight on label reconstruction error\n",
    "                L1_reg = [0,0,0], # L1 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                L2_reg = [0,0,0], # L2 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                nonnegativity=[True,True,False], # nonnegativity constraints on code H, dictionary W[0], reg params W[1]\n",
    "                full_dim=False) # if true, dictionary is Id with full dimension --> Pure regression\n",
    "\n",
    "results_dict_new = SNMF_class_new.train_logistic(iter=iteration, subsample_size=None, \n",
    "                                        beta = beta,\n",
    "                                        search_radius_const=1,\n",
    "                                        update_nuance_param=False,\n",
    "                                        if_compute_recons_error=False, if_validate=False)\n",
    "results_dict_new.update({'method': 'SDL-filt'})\n",
    "results_dict_new.update({'xi': xi_SNMF})\n",
    "#results_dict_list.append(results_dict_new.copy())\n",
    "#results_dict_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "9a82aae4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "W = results_dict_new.get('loading')[0]\n",
    "W_beta = results_dict_new.get('loading')[1]\n",
    "display_dictionary_list2([W], grid_shape=[1,2], fig_size=[4,4], score_list = [W_beta[0][1:]]) # 2, 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "7e836490",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_dictionary_list(W_true_Y, grid_shape=[1,2], fig_size=[4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "17382420",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_dictionary_list(W_true, grid_shape=[1,2], fig_size=[4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "80e18686",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "d = {'AUC': results_dict_new.get('AUC'), 'Opt_threshold': results_dict_new.get('Training_threshold'), 'Accuracy': results_dict_new.get('Accuracy'), 'Sensitivity': results_dict_new.get('Sensitivity'), 'Specificity': results_dict_new.get('Specificity'), 'Precision': results_dict_new.get('Precision'), 'F_score': results_dict_new.get('F_score'), 'method': results_dict_new.get('method'), 'xi': xi_SNMF, 'Relative_reconstruction_loss (test)': results_dict_new.get('Relative_reconstruction_loss (test)')}\n",
    "d2 = results_dict_list.copy()\n",
    "d2.append(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "f0ce7681",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'AUC': 1.0,\n",
       "  'Opt_threshold': 0.9599,\n",
       "  'Accuracy': 0.8,\n",
       "  'Sensitivity': 0.6778,\n",
       "  'Specificity': 0.9,\n",
       "  'Precision': 0.8472,\n",
       "  'F_score': 0.7531,\n",
       "  'method': 'LR',\n",
       "  'xi': None,\n",
       "  'Relative_reconstruction_loss (test)': 1},\n",
       " {'AUC': 0.9605,\n",
       "  'Opt_threshold': 0.4403,\n",
       "  'Accuracy': 0.88,\n",
       "  'Sensitivity': 0.9111,\n",
       "  'Specificity': 0.8545,\n",
       "  'Precision': 0.8367,\n",
       "  'F_score': 0.8723,\n",
       "  'xi': None,\n",
       "  'method': 'MF-->LR',\n",
       "  'Relative_reconstruction_loss (test)': 0.8772233747973432},\n",
       " {'AUC': 0.9414,\n",
       "  'Opt_threshold': 0.3782,\n",
       "  'Accuracy': 0.85,\n",
       "  'Sensitivity': 0.8444,\n",
       "  'Specificity': 0.8545,\n",
       "  'Precision': None,\n",
       "  'F_score': 0.8351,\n",
       "  'method': 'SDL-filt',\n",
       "  'xi': 1,\n",
       "  'Relative_reconstruction_loss (test)': 0.880131877591288}]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "e23671f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|▏                                                    | 1/300 [00:00<00:47,  6.32it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial loading beta [[0.18417932 0.06942541 0.10424468]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 72.49it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [1.000, 0.906, 0.830]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|▊                                                    | 3/200 [00:00<00:07, 25.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:05<00:00, 34.59it/s]\n",
      "  4%|██▏                                                | 13/300 [00:00<00:02, 127.58it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.017, 0.472, 0.515]\n",
      "initial loading beta [[0.83419792 0.53033408 0.91279825]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:03<00:00, 91.78it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                             | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.000, 0.766, 0.765]\n",
      "!!! pred_type exhaustive\n",
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████▌                               | 79/200 [00:02<00:03, 37.25it/s]C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\LMF.py:296: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  dist = np.linalg.norm(H1 - H1_old, 2) / np.linalg.norm(H1_old, 2)\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:05<00:00, 35.74it/s]\n",
      "  3%|█▋                                                  | 10/300 [00:00<00:03, 93.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.613, 0.511, 0.540]\n",
      "initial loading beta [[0.47607931 0.10102684 0.16735193]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:05<00:00, 52.00it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                             | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.995, 0.945, 0.875]\n",
      "!!! pred_type exhaustive\n",
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:05<00:00, 36.88it/s]\n",
      "  4%|██▏                                                | 13/300 [00:00<00:02, 127.66it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.002, 0.935, 0.670]\n",
      "initial loading beta [[0.51104597 0.61557148 0.29576766]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 73.77it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                             | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.939, 0.945, 0.860]\n",
      "!!! pred_type exhaustive\n",
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:05<00:00, 37.36it/s]\n",
      "  4%|██                                                 | 12/300 [00:00<00:02, 115.01it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.003, 0.940, 0.690]\n",
      "initial loading beta [[0.57595824 0.38909323 0.45605665]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 63.48it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.192, 0.956, 0.870]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|█                                                    | 4/200 [00:00<00:06, 31.52it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:05<00:00, 37.35it/s]\n",
      "  3%|█▌                                                   | 9/300 [00:00<00:03, 86.71it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.000, 0.957, 0.885]\n",
      "initial loading beta [[0.3335301  0.52806491 0.81480252]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 73.84it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.013, 0.956, 0.875]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|█▎                                                   | 5/200 [00:00<00:04, 42.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:07<00:00, 26.93it/s]\n",
      "  3%|█▍                                                   | 8/300 [00:00<00:03, 75.58it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.000, 0.956, 0.870]\n",
      "initial loading beta [[0.31705691 0.52311176 0.88965762]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 61.21it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.484, 0.867, 0.790]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|█▌                                                   | 6/200 [00:00<00:03, 56.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:03<00:00, 55.77it/s]\n",
      "  3%|█▌                                                   | 9/300 [00:00<00:03, 88.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.048, 0.863, 0.795]\n",
      "initial loading beta [[0.63381813 0.44795348 0.06450544]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 71.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.512, 0.944, 0.880]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6%|███                                                | 12/200 [00:00<00:01, 117.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████| 200/200 [00:01<00:00, 102.56it/s]\n",
      "  6%|███▎                                                | 19/300 [00:00<00:02, 94.68it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.019, 0.946, 0.890]\n",
      "initial loading beta [[0.41042619 0.17391857 0.07496863]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:03<00:00, 78.55it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.000, 0.738, 0.730]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|██                                                   | 8/200 [00:00<00:02, 78.52it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 42%|█████████████████████▌                              | 83/200 [00:01<00:02, 48.68it/s]C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\LMF.py:296: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  dist = np.linalg.norm(H1 - H1_old, 2) / np.linalg.norm(H1_old, 2)\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:04<00:00, 43.43it/s]\n",
      "  3%|█▋                                                  | 10/300 [00:00<00:02, 97.15it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.901, 0.459, 0.560]\n",
      "initial loading beta [[0.7806385  0.3175477  0.04440717]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:03<00:00, 76.94it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.000, 0.654, 0.665]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|▌                                                    | 2/200 [00:00<00:11, 17.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  9%|████▋                                               | 18/200 [00:00<00:06, 28.38it/s]C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\LMF.py:296: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  dist = np.linalg.norm(H1 - H1_old, 2) / np.linalg.norm(H1_old, 2)\n",
      "100%|███████████████████████████████████████████████████| 200/200 [00:06<00:00, 29.50it/s]\n",
      "  3%|█▌                                                   | 9/300 [00:00<00:03, 84.90it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.965, 0.488, 0.540]\n",
      "initial loading beta [[0.61946203 0.68570076 0.84431204]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 63.52it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.833, 0.930, 0.845]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|█                                                    | 4/200 [00:00<00:05, 33.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:06<00:00, 33.31it/s]\n",
      "  4%|██▏                                                | 13/300 [00:00<00:02, 125.54it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.000, 0.913, 0.640]\n",
      "initial loading beta [[0.33429614 0.71215129 0.905703  ]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:03<00:00, 81.86it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [1.000, 0.929, 0.860]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|█                                                    | 4/200 [00:00<00:06, 32.32it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:06<00:00, 31.06it/s]\n",
      "  3%|█▌                                                   | 9/300 [00:00<00:03, 87.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.998, 0.948, 0.545]\n",
      "initial loading beta [[0.38771935 0.34593404 0.95503129]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:05<00:00, 51.08it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.107, 0.955, 0.890]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|█                                                    | 4/200 [00:00<00:05, 34.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:07<00:00, 27.28it/s]\n",
      "  3%|█▌                                                   | 9/300 [00:00<00:03, 87.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.000, 0.954, 0.870]\n",
      "initial loading beta [[0.09454373 0.1029885  0.51166652]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 63.13it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.275, 0.952, 0.880]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|█                                                    | 4/200 [00:00<00:05, 33.21it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:06<00:00, 31.27it/s]\n",
      "  3%|█▋                                                  | 10/300 [00:00<00:03, 95.99it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.000, 0.953, 0.880]\n",
      "initial loading beta [[0.4059787  0.96538187 0.18745063]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 71.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.504, 0.954, 0.875]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6%|██▊                                                 | 11/200 [00:00<00:01, 99.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:02<00:00, 83.20it/s]\n",
      "  3%|█▍                                                   | 8/300 [00:00<00:04, 71.01it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.017, 0.956, 0.885]\n",
      "initial loading beta [[0.67237203 0.78765799 0.3894869 ]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 72.96it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.520, 0.954, 0.875]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6%|██▊                                                | 11/200 [00:00<00:01, 102.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:02<00:00, 87.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.014, 0.954, 0.885]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# LMF - feature-based\n",
    "\n",
    "iteration1 = 200\n",
    "\n",
    "# Cross-validation\n",
    "xi_list = [0, 0.1, 1, 10]\n",
    "beta_list = [1, None]\n",
    "iter_avg = 2\n",
    "\n",
    "LMF_AUC_array_naive = np.zeros(shape=[iter_avg, len(xi_list)])\n",
    "LMF_AUC_array_exhaustive = np.zeros(shape=[iter_avg, len(xi_list)])\n",
    "for beta in beta_list:\n",
    "    for j in range(len(xi_list)):\n",
    "        xi = xi_list[j]\n",
    "        for i in range(iter_avg):\n",
    "            LMF_class_new = LMF(X=[X_train, Y_train],  # data, label\n",
    "                            X_test=[X_test, Y_test],\n",
    "                            #X_auxiliary = None,\n",
    "                            n_components=r,  # =: r = number of columns in dictionary matrices W, W'\n",
    "                            # ini_loading=None,  # Initializatio for [W,W'], W1.shape = [d1, r], W2.shape = [d2, r]\n",
    "                            # ini_loading=[W_true, np.hstack((np.array([[0]]), Beta_true))],\n",
    "                            # ini_code = H_true, \n",
    "                            xi=xi,  # weight on label reconstruction error\n",
    "                            L1_reg = [0,0,0], # L1 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                            L2_reg = [0,0,1], # L2 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                            nonnegativity=[True,True,False], # nonnegativity constraints on code H, dictionary W[0], reg params W[1]\n",
    "                            full_dim=False) # if true, dictionary is Id with full dimension --> Pure regression\n",
    "\n",
    "            results_dict_new = LMF_class_new.train_logistic(iter=iteration, subsample_size=None, \n",
    "                                                    beta = beta, \n",
    "                                                    search_radius_const=1000,\n",
    "                                                    fine_tune_beta=True,\n",
    "                                                    update_nuance_param=False,\n",
    "                                                    if_compute_recons_error=False, if_validate=False)\n",
    "\n",
    "            results_dict_new.update({'method': 'SDL-feat (naive)'})\n",
    "            results_dict_new.update({'beta': beta})\n",
    "            results_dict_new.update({'Accuracy': results_dict_new.get('Accuracy (naive)')})\n",
    "            results_dict_new.update({'F_score': results_dict_new.get('F_score (naive)')})\n",
    "            results_dict_list.append(results_dict_new.copy())\n",
    "\n",
    "            results_dict_new1 = results_dict_new.copy()\n",
    "            results_dict_new1.update({'method': 'SDL-feat (exhaustive)'})\n",
    "            results_dict_new1.update({'beta': beta})\n",
    "            results_dict_new1.update({'Accuracy': results_dict_new1.get('Accuracy (exhaustive)')})\n",
    "            results_dict_new1.update({'F_score': results_dict_new.get('F_score (exhaustive)')})\n",
    "            results_dict_list.append(results_dict_new1.copy())\n",
    "\n",
    "            LMF_AUC_array_naive[i,j] = results_dict_new.get('Accuracy (naive)') \n",
    "            LMF_AUC_array_exhaustive[i,j] = results_dict_new.get('Accuracy (exhaustive)') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "f5fc4c78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.395 1.705 1.77  1.75 ]\n",
      "1\n",
      "[1.1   1.185 1.75  1.77 ]\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(LMF_AUC_array_naive, 0))        \n",
    "xi_NMF_n = xi_list[np.argmax(np.sum(LMF_AUC_array_naive, 0))]\n",
    "print(xi_NMF_n)\n",
    "\n",
    "print(np.sum(LMF_AUC_array_exhaustive, 0))        \n",
    "xi_NMF_e = xi_list[np.argmax(np.sum(LMF_AUC_array_exhaustive, 0))]\n",
    "print(xi_NMF_e)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "aff63ed9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|█▋                                                  | 10/300 [00:00<00:03, 94.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial loading beta [[0.59985579 0.87379996 0.41604355]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 65.31it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.252, 0.958, 0.880]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|█▊                                                   | 7/200 [00:00<00:03, 62.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████| 200/200 [00:01<00:00, 118.29it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.002, 0.958, 0.875]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Analysis\n",
    "LMF_class_new = LMF(X=[X_train, Y_train],  # data, label\n",
    "                        X_test=[X_test, Y_test],\n",
    "                        #X_auxiliary = None,\n",
    "                        n_components=r,  # =: r = number of columns in dictionary matrices W, W'\n",
    "                        # ini_loading=None,  # Initializatio for [W,W'], W1.shape = [d1, r], W2.shape = [d2, r]\n",
    "                        # ini_loading=[W_true, np.hstack((np.array([[0]]), Beta_true))],\n",
    "                        # ini_code = H_true, \n",
    "                        xi=xi_NMF_e,  # weight on label reconstruction error\n",
    "                        L1_reg = [0,0,0], # L1 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                        L2_reg = [0,0,0], # L2 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                        nonnegativity=[True,True,False], # nonnegativity constraints on code H, dictionary W[0], reg params W[1]\n",
    "                        full_dim=False) # if true, dictionary is Id with full dimension --> Pure regression\n",
    "\n",
    "results_dict_new = LMF_class_new.train_logistic(iter=iteration, subsample_size=None, \n",
    "                                        beta = beta, \n",
    "                                        search_radius_const=1000,\n",
    "                                        fine_tune_beta=True,\n",
    "                                        update_nuance_param=False,\n",
    "                                        if_compute_recons_error=False, if_validate=False)\n",
    "\n",
    "#results_dict_new.update({'xi': xi_NMF_e})\n",
    "#results_dict_list.append(results_dict_new.copy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "e078f0dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "W = results_dict_new.get('loading')[0]\n",
    "W_beta = results_dict_new.get('loading')[1]\n",
    "display_dictionary_list2([W], grid_shape=[1,2], fig_size=[4,4], score_list = [W_beta[0][1:]]) # 2, 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "d2f85093",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_dictionary_list(W_true, grid_shape=[1,2], fig_size=[4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "a5066a17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_dictionary_list(W_true_Y, grid_shape=[1,2], fig_size=[4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "bcd1758b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|█▋                                                  | 10/300 [00:00<00:02, 98.89it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial loading beta [[0.98200751 0.12263158 0.48386269]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 300/300 [00:04<00:00, 64.37it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy] = [0.226, 0.955, 0.875]\n",
      "!!! pred_type exhaustive\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|█▌                                                   | 6/200 [00:00<00:03, 54.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exhaustive prection..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████| 200/200 [00:05<00:00, 36.72it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Validation (exhaustive) --- [threshold, AUC, accuracy] = [0.000, 0.956, 0.875]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Analysis\n",
    "LMF_class_new = LMF(X=[X_train, Y_train],  # data, label\n",
    "                        X_test=[X_test, Y_test],\n",
    "                        #X_auxiliary = None,\n",
    "                        n_components=r,  # =: r = number of columns in dictionary matrices W, W'\n",
    "                        ini_loading=None,  # Initializatio for [W,W'], W1.shape = [d1, r], W2.shape = [d2, r]\n",
    "                        #ini_loading=[W_true, np.hstack((np.array([[0]]), Beta_true))],\n",
    "                        # ini_code = H_train, \n",
    "                        xi=xi_NMF_n,  # weight on label reconstruction error\n",
    "                        L1_reg = [0,0,0], # L1 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                        L2_reg = [0,0,0], # L2 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                        nonnegativity=[True,True,False], # nonnegativity constraints on code H, dictionary W[0], reg params W[1]\n",
    "                        full_dim=False) # if true, dictionary is Id with full dimension --> Pure regression\n",
    "\n",
    "results_dict_new = LMF_class_new.train_logistic(iter=iteration, subsample_size=None, \n",
    "                                        beta = beta, \n",
    "                                        search_radius_const=1000,\n",
    "                                        fine_tune_beta=True,\n",
    "                                        update_nuance_param=False,\n",
    "                                        if_compute_recons_error=False, if_validate=False)\n",
    "\n",
    "#results_dict_new.update({'xi': xi_NMF_e})\n",
    "#results_dict_list.append(results_dict_new.copy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "47ce5d11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "W = results_dict_new.get('loading')[0]\n",
    "W_beta = results_dict_new.get('loading')[1]\n",
    "display_dictionary_list2([W], grid_shape=[1,2], fig_size=[4,4], score_list = [W_beta[0][1:]]) # 2, 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "80c46de5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial loading beta [[ 0.54903179 -0.45629029  0.13759718]]\n",
      "*** rel_error_data train 30.989713397339727\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:01<04:27,  1.35s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984492139420924\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.769]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [222144.245248.3, 5475.566534.3, 5475.566534.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:05<01:29,  2.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.97302753825249\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:06<02:15,  1.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9841234546063563\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.787]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [222024.635637.3, 6339.962189.3, 6339.962189.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:15<02:59,  1.00it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.95343729092645\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:18<04:19,  1.45s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834809521012543\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.801]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [221884.206435.3, 3585.435713.3, 3585.435713.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:29<03:30,  1.24s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.933265271596685\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:31<04:28,  1.59s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9827453010877466\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.83]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [221739.606905.3, 2220.816749.3, 2220.816749.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:38<02:06,  1.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.91631162118032\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [00:40<02:59,  1.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824662965895335\n",
      "--- Training --- [threshold, AUC] =  [0.998, 0.873]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [221618.077679.3, 1529.850566.3, 1529.850566.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [00:46<01:46,  1.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.9039389849159\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [00:48<03:21,  1.35s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.982631228655954\n",
      "--- Training --- [threshold, AUC] =  [0.954, 0.918]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [221529.386638.3, 744.586851.3, 744.586851.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [00:56<01:51,  1.26it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.900576731252876\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [00:58<02:27,  1.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9828772333942298\n",
      "--- Training --- [threshold, AUC] =  [0.898, 0.949]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [221505.284921.3, 409.684845.3, 409.684845.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [01:05<02:05,  1.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.88893140571785\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [01:08<03:24,  1.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825056751179415\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.964]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [221421.807477.3, 1229.410848.3, 1229.410848.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:16<01:35,  1.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.86930177082956\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:18<02:14,  1.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.982477282932163\n",
      "--- Training --- [threshold, AUC] =  [0.679, 0.98]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [221281.095933.3, 188.097934.3, 188.097934.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [01:26<01:38,  1.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.868923991091528\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [01:28<02:18,  1.27s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825698889333879\n",
      "--- Training --- [threshold, AUC] =  [0.341, 0.988]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [221278.387886.3, 121.732692.3, 121.732692.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [01:36<01:30,  1.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.86860293130292\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [01:39<02:21,  1.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.982592225106204\n",
      "--- Training --- [threshold, AUC] =  [0.49, 0.993]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [221276.086426.3, 87.359051.3, 87.359051.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [01:47<01:31,  1.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.868363577534385\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [01:51<02:27,  1.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825943287773224\n",
      "--- Training --- [threshold, AUC] =  [0.506, 0.996]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [221274.370662.3, 66.086037.3, 66.086037.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [02:01<01:24,  1.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.868192069816537\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [02:04<02:11,  1.67s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825876173965682\n",
      "--- Training --- [threshold, AUC] =  [0.542, 0.998]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [221273.141239.3, 51.728787.3, 51.728787.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [02:18<01:34,  1.35s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.86806861962058\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [02:21<02:05,  1.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825765169816332\n",
      "--- Training --- [threshold, AUC] =  [0.481, 0.999]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [221272.256308.3, 41.636520.3, 41.636520.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [02:33<01:22,  1.37s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.867975485751664\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [02:36<01:53,  1.92s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825638262331396\n",
      "--- Training --- [threshold, AUC] =  [0.607, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [221271.588695.3, 34.528989.3, 34.528989.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [02:45<00:46,  1.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.867899688561824\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [02:47<01:03,  1.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825512402535254\n",
      "--- Training --- [threshold, AUC] =  [0.52, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [221271.045356.3, 29.526716.3, 29.526716.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [02:54<00:31,  1.29it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.867834409776133\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [02:56<00:43,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825393088904759\n",
      "--- Training --- [threshold, AUC] =  [0.487, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [221270.577417.3, 25.898371.3, 25.898371.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [03:02<00:22,  1.35it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.867776727848486\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [03:04<00:29,  1.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825281497761087\n",
      "--- Training --- [threshold, AUC] =  [0.581, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [221270.163934.3, 23.140101.3, 23.140101.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [03:11<00:15,  1.26it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.867725136453018\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [03:13<00:22,  1.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825177707995691\n",
      "--- Training --- [threshold, AUC] =  [0.647, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [221269.794110.3, 20.954299.3, 20.954299.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [03:20<00:08,  1.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.867678589839162\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [03:22<00:10,  1.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825081295553716\n",
      "--- Training --- [threshold, AUC] =  [0.695, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [221269.460449.3, 19.167340.3, 19.167340.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [03:29<00:00,  1.05s/it]\n",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.728, 1.0]\n",
      "!!! ACC_list [0.845]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.971, 0.916, 0.845, 0.984]\n",
      "initial loading beta [[ 0.43476056 -0.22125326  0.65799314]]\n",
      "*** rel_error_data train 30.396071290893875\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:02<06:38,  2.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844685826704179\n",
      "--- Training --- [threshold, AUC] =  [0.0, 0.499]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [217888.827459.3, 6805.937384.3, 6805.937384.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:09<02:37,  1.21it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.374678626548455\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:11<03:55,  1.25s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9838809277622269\n",
      "--- Training --- [threshold, AUC] =  [0.001, 0.783]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [217735.477952.3, 2251.756905.3, 2251.756905.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:18<02:25,  1.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.347756352247448\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:20<03:36,  1.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9828985775373306\n",
      "--- Training --- [threshold, AUC] =  [0.002, 0.817]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [217542.490420.3, 2115.730301.3, 2115.730301.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:28<02:35,  1.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.32499339137604\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:31<04:01,  1.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9823240873442316\n",
      "--- Training --- [threshold, AUC] =  [0.0, 0.866]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [217379.318186.3, 1462.698283.3, 1462.698283.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:38<02:11,  1.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.30919511609479\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [00:40<03:00,  1.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9823389177224202\n",
      "--- Training --- [threshold, AUC] =  [0.005, 0.917]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [217266.071061.3, 988.680377.3, 988.680377.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [00:46<01:49,  1.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.299319747953056\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [00:48<02:40,  1.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.982440826069083\n",
      "--- Training --- [threshold, AUC] =  [0.04, 0.95]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [217195.281242.3, 548.985021.3, 548.985021.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [00:56<02:01,  1.15it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.2953660215627\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [00:58<02:43,  1.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825491257005611\n",
      "--- Training --- [threshold, AUC] =  [0.035, 0.969]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [217166.939658.3, 308.127094.3, 308.127094.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [01:04<01:36,  1.35it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.292788673354707\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [01:06<02:20,  1.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9826279086678407\n",
      "--- Training --- [threshold, AUC] =  [0.088, 0.98]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [217148.464396.3, 258.634342.3, 258.634342.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:12<01:26,  1.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.2883748540031\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:15<02:47,  1.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825985810830835\n",
      "--- Training --- [threshold, AUC] =  [0.033, 0.987]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [217116.824718.3, 229.860841.3, 229.860841.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [01:23<01:29,  1.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.28638506320127\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [01:27<03:23,  1.86s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824996717502129\n",
      "--- Training --- [threshold, AUC] =  [0.399, 0.992]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [217102.561256.3, 92.734144.3, 92.734144.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [01:35<01:21,  1.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.286297839173834\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [01:37<02:01,  1.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825033485856633\n",
      "--- Training --- [threshold, AUC] =  [0.538, 0.996]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [217101.936006.3, 66.892785.3, 66.892785.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [01:45<01:22,  1.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.28625036635314\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [01:48<02:13,  1.50s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825084412912082\n",
      "--- Training --- [threshold, AUC] =  [0.653, 0.998]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [217101.595706.3, 50.993531.3, 50.993531.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [01:56<01:11,  1.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.286202048928715\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [01:59<01:45,  1.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825055970239295\n",
      "--- Training --- [threshold, AUC] =  [0.485, 0.999]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [217101.249351.3, 40.344597.3, 40.344597.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [02:06<01:00,  1.16it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.286156620737028\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [02:09<01:30,  1.31s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824967450228127\n",
      "--- Training --- [threshold, AUC] =  [0.542, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [217100.923707.3, 33.361396.3, 33.361396.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [02:15<00:44,  1.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.28611590657206\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [02:17<01:03,  1.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824847127141905\n",
      "--- Training --- [threshold, AUC] =  [0.486, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [217100.631855.3, 28.638282.3, 28.638282.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [02:23<00:34,  1.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.286080530344332\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [02:25<00:52,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824717267767616\n",
      "--- Training --- [threshold, AUC] =  [0.575, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [217100.378267.3, 25.230313.3, 25.230313.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [02:31<00:26,  1.54it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.286049988878744\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [02:33<00:35,  1.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824589136676767\n",
      "--- Training --- [threshold, AUC] =  [0.643, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [217100.159336.3, 22.626728.3, 22.626728.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [02:37<00:16,  1.87it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.286023407910914\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [02:39<00:24,  1.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824467168838128\n",
      "--- Training --- [threshold, AUC] =  [0.695, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [217099.968795.3, 20.553072.3, 20.553072.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [02:44<00:10,  1.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.285999980071292\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [02:45<00:15,  1.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824352683188844\n",
      "--- Training --- [threshold, AUC] =  [0.734, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [217099.800856.3, 18.851168.3, 18.851168.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [02:50<00:05,  1.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 30.2859790696936\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [02:52<00:08,  1.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824245717878072\n",
      "--- Training --- [threshold, AUC] =  [0.765, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [217099.650964.3, 17.422822.3, 17.422822.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [02:56<00:00,  1.13it/s]\n",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.787, 1.0]\n",
      "!!! ACC_list [0.79]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.248, 0.903, 0.790, 0.984]\n",
      "initial loading beta [[0.38241114 0.85894763 0.99732217]]\n",
      "*** rel_error_data train 27.754829091533402\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:01<05:16,  1.59s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9859814496665564\n",
      "--- Training --- [threshold, AUC] =  [0.0, 0.777]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [198955.552815.3, 2961.487750.3, 22857.043032.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:08<02:14,  1.41it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 22.849364508494745\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:09<03:05,  1.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.98540520271997\n",
      "--- Training --- [threshold, AUC] =  [0.0, 0.785]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [163791.602977.3, 2281.885876.3, 18661.046174.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:15<02:03,  1.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 18.838865645468108\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:17<02:53,  1.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9848130552575453\n",
      "--- Training --- [threshold, AUC] =  [0.001, 0.805]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [135043.055626.3, 1967.427567.3, 15471.733129.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:23<02:05,  1.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 15.552889348319926\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:25<02:41,  1.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9840970728293251\n",
      "--- Training --- [threshold, AUC] =  [0.001, 0.858]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [111488.119345.3, 1709.219256.3, 12858.031190.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:31<01:53,  1.40it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 12.857884666574437\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [00:33<02:35,  1.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9831583458183486\n",
      "--- Training --- [threshold, AUC] =  [0.003, 0.928]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [92169.457914.3, 915.912701.3, 10132.858492.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [00:40<02:07,  1.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 10.673716942473852\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [00:41<02:39,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825348525080452\n",
      "--- Training --- [threshold, AUC] =  [0.032, 0.966]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [76512.640300.3, 399.803933.3, 8051.067963.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [00:47<01:34,  1.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 8.884540958984337\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [00:49<02:12,  1.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9818628568463513\n",
      "--- Training --- [threshold, AUC] =  [0.002, 0.985]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [63687.250682.3, 565.210729.3, 6933.935797.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [00:56<01:37,  1.34it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 7.423055541130927\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [00:57<02:12,  1.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9813057146012093\n",
      "--- Training --- [threshold, AUC] =  [0.295, 0.992]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [53210.852565.3, 98.170462.3, 5419.255718.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:03<01:27,  1.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 6.234631382636802\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:05<02:07,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9807933191676219\n",
      "--- Training --- [threshold, AUC] =  [0.562, 0.998]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [44691.845489.3, 50.199025.3, 4519.383574.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [01:12<01:15,  1.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 5.262464944567007\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [01:13<01:48,  1.00it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9802151422845559\n",
      "--- Training --- [threshold, AUC] =  [0.575, 0.999]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [37723.043394.3, 30.022171.3, 3802.326511.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [01:20<01:23,  1.19it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 4.467204412716535\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [01:22<01:50,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9795613786371378\n",
      "--- Training --- [threshold, AUC] =  [0.665, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [32022.359804.3, 20.784795.3, 3223.020775.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [01:28<01:05,  1.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 3.8166473034550994\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [01:30<01:26,  1.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9788265573606373\n",
      "--- Training --- [threshold, AUC] =  [0.578, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [27358.956946.3, 16.366687.3, 2752.262382.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [01:36<00:55,  1.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 3.28442846259985\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [01:38<01:27,  1.10s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9780074642458018\n",
      "--- Training --- [threshold, AUC] =  [0.734, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [23543.840904.3, 13.864878.3, 2368.248969.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [01:44<00:51,  1.35it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2.8489829059969125\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [01:46<01:10,  1.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9771001517604772\n",
      "--- Training --- [threshold, AUC] =  [0.806, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [20422.426928.3, 12.173831.3, 2054.416524.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [01:52<00:41,  1.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2.4926757199789797\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [01:54<00:57,  1.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9760993018232349\n",
      "--- Training --- [threshold, AUC] =  [0.846, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [17868.302277.3, 10.920160.3, 1797.750388.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [02:00<00:35,  1.42it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2.20108429945508\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [02:02<00:48,  1.01it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9749993534256476\n",
      "--- Training --- [threshold, AUC] =  [0.871, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [15778.081074.3, 9.939629.3, 1587.747736.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [02:08<00:34,  1.16it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.9624131273901784\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [02:11<00:52,  1.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9737952415147452\n",
      "--- Training --- [threshold, AUC] =  [0.886, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [14067.209253.3, 9.145039.3, 1415.865964.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [02:19<00:28,  1.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.767015602647769\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [02:21<00:41,  1.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9724829903990106\n",
      "--- Training --- [threshold, AUC] =  [0.895, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [12666.536872.3, 8.484504.3, 1275.138191.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [02:28<00:14,  1.36it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.6070030860322557\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [02:30<00:18,  1.01it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9710603066899303\n",
      "--- Training --- [threshold, AUC] =  [0.903, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [11519.515624.3, 7.924675.3, 1159.876237.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [02:36<00:07,  1.29it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.4759252043434483\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [02:38<00:10,  1.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9695271995504988\n",
      "--- Training --- [threshold, AUC] =  [0.91, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [10579.907157.3, 7.442880.3, 1065.433595.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [02:47<00:00,  1.20it/s]\n",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.915, 1.0]\n",
      "!!! ACC_list [0.865]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.323, 0.921, 0.865, 0.971]\n",
      "initial loading beta [[-0.94378287 -0.72423462  0.66614286]]\n",
      "*** rel_error_data train 30.646599496961294\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:02<07:04,  2.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9846811168701302\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.734]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [219684.694317.3, 5866.757835.3, 27835.227266.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:10<03:14,  1.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 25.20766031153917\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:12<03:53,  1.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9839070581308365\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.781]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [180696.626735.3, 5121.997513.3, 23191.660187.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:18<01:56,  1.55it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 20.741032373262843\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:20<02:51,  1.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.981205629653596\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.83]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [148678.399285.3, 4009.216270.3, 18877.056199.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:26<01:56,  1.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 17.093170502873804\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:28<03:15,  1.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9799612365330737\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.901]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [122529.350678.3, 1647.927673.3, 13900.862741.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:34<02:05,  1.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 14.133633138203612\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [00:36<02:34,  1.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9809079911478433\n",
      "--- Training --- [threshold, AUC] =  [0.93, 0.953]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [101314.433788.3, 411.174663.3, 10542.618042.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [00:42<01:43,  1.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 11.718952428747574\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [00:44<02:26,  1.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9805426729574159\n",
      "--- Training --- [threshold, AUC] =  [0.996, 0.976]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [84005.224863.3, 563.831312.3, 8964.353798.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [00:49<01:30,  1.54it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 9.730508711825708\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [00:51<02:07,  1.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9796964005394968\n",
      "--- Training --- [threshold, AUC] =  [0.944, 0.988]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [69751.419962.3, 233.073565.3, 7208.215561.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [00:56<01:25,  1.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 8.121652906573644\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [00:58<02:03,  1.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9797754141659192\n",
      "--- Training --- [threshold, AUC] =  [0.599, 0.996]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [58218.623450.3, 59.536159.3, 5881.398504.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:04<01:20,  1.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 6.805680463806805\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:06<01:59,  1.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9793701942808769\n",
      "--- Training --- [threshold, AUC] =  [0.599, 0.999]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [48785.309198.3, 31.927686.3, 4910.458606.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [01:12<01:19,  1.38it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 5.729250465417362\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [01:14<01:53,  1.04s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9788520479341617\n",
      "--- Training --- [threshold, AUC] =  [0.543, 1.0]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [41069.112326.3, 20.260457.3, 4127.171689.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [01:20<01:16,  1.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 4.84872391893204\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [01:23<01:59,  1.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9782447317747895\n",
      "--- Training --- [threshold, AUC] =  [0.721, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [34757.214485.3, 15.369171.3, 3491.090619.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [01:29<01:00,  1.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 4.128422052933464\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [01:30<01:29,  1.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9775610475418413\n",
      "--- Training --- [threshold, AUC] =  [0.783, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [29593.858751.3, 12.765162.3, 2972.151037.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [01:36<00:53,  1.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 3.539162453680517\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [01:38<01:13,  1.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9768016167755565\n",
      "--- Training --- [threshold, AUC] =  [0.821, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [25369.856184.3, 11.053582.3, 2548.039200.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [01:43<00:47,  1.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 3.057074841284238\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [01:45<01:07,  1.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.975962585373773\n",
      "--- Training --- [threshold, AUC] =  [0.846, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [21914.096932.3, 9.813781.3, 2201.223474.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [01:51<00:40,  1.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2.662634797705683\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [01:53<00:58,  1.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9750389717302943\n",
      "--- Training --- [threshold, AUC] =  [0.864, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [19086.623678.3, 8.864053.3, 1917.526421.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [01:59<00:36,  1.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2.3398729149273985\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [02:01<00:49,  1.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9740256313778246\n",
      "--- Training --- [threshold, AUC] =  [0.879, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [16772.962563.3, 8.108518.3, 1685.404774.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [02:07<00:29,  1.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2.0757278249433075\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [02:09<00:42,  1.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9729177800959817\n",
      "--- Training --- [threshold, AUC] =  [0.89, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [14879.485496.3, 7.490533.3, 1495.439083.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [02:15<00:21,  1.42it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.8595170198402715\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [02:17<00:29,  1.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9717114451200033\n",
      "--- Training --- [threshold, AUC] =  [0.899, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [13329.616818.3, 6.974057.3, 1339.935739.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [02:23<00:13,  1.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.6825040474484823\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [02:25<00:19,  1.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9704039341937005\n",
      "--- Training --- [threshold, AUC] =  [0.906, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [12060.730829.3, 6.534895.3, 1212.607978.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [02:31<00:07,  1.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.5375445400797816\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [02:33<00:09,  1.04s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9689943409027473\n",
      "--- Training --- [threshold, AUC] =  [0.913, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [11021.614399.3, 6.156128.3, 1108.317567.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [02:40<00:00,  1.25it/s]\n",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.918, 1.0]\n",
      "!!! ACC_list [0.815]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.158, 0.922, 0.815, 0.970]\n",
      "initial loading beta [[ 0.71302313  0.92657262 -0.94236056]]\n",
      "*** rel_error_data train 23.937904744538386\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:02<06:42,  2.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9848968908609509\n",
      "--- Training --- [threshold, AUC] =  [0.008, 0.434]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [171594.609931.3, 2741.351395.3, 174335.961326.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:09<02:48,  1.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 3.6687166337906243\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:11<03:59,  1.27s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9786537579158927\n",
      "--- Training --- [threshold, AUC] =  [0.0, 0.922]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [26298.542268.3, 5366.735146.3, 31665.277413.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:19<02:35,  1.16it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.2202472248988638\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:21<03:44,  1.26s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9630594719173244\n",
      "--- Training --- [threshold, AUC] =  [0.007, 0.977]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [8747.125064.3, 452.973352.3, 9200.098417.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:29<02:31,  1.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.9177212239491972\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:31<03:28,  1.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9446886890857121\n",
      "--- Training --- [threshold, AUC] =  [0.305, 0.993]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [6578.521267.3, 101.219641.3, 6679.740908.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:38<02:11,  1.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8785913472344606\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [00:40<03:04,  1.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9361366278431511\n",
      "--- Training --- [threshold, AUC] =  [0.355, 0.998]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [6298.025710.3, 42.918143.3, 6340.943853.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [00:48<02:30,  1.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8736137731385578\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [00:51<03:34,  1.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9345358655265035\n",
      "--- Training --- [threshold, AUC] =  [0.564, 1.0]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [6262.344856.3, 24.069149.3, 6286.414004.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [00:58<01:52,  1.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8729855444966983\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [01:00<02:27,  1.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9343180510435057\n",
      "--- Training --- [threshold, AUC] =  [0.624, 1.0]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [6257.841510.3, 17.416862.3, 6275.258373.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [01:06<01:37,  1.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8729041864892746\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [01:08<02:14,  1.04s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342903341800236\n",
      "--- Training --- [threshold, AUC] =  [0.733, 1.0]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [6257.258310.3, 14.340070.3, 6271.598380.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:15<01:27,  1.37it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728890422761072\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:16<02:07,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342846277826392\n",
      "--- Training --- [threshold, AUC] =  [0.787, 1.0]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [6257.149751.3, 12.453927.3, 6269.603678.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [01:23<01:26,  1.27it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728791637185322\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [01:25<01:51,  1.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342797724768842\n",
      "--- Training --- [threshold, AUC] =  [0.818, 1.0]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [6257.078939.3, 11.139061.3, 6268.218000.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [01:31<01:20,  1.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728675709202355\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [01:33<01:47,  1.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342736753983404\n",
      "--- Training --- [threshold, AUC] =  [0.839, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [6256.995838.3, 10.156071.3, 6267.151909.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [01:43<01:27,  1.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728540762689375\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [01:45<02:00,  1.36s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342664946633542\n",
      "--- Training --- [threshold, AUC] =  [0.854, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [6256.899104.3, 9.387300.3, 6266.286403.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [01:54<01:14,  1.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728391573341373\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [01:56<01:44,  1.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342585326881445\n",
      "--- Training --- [threshold, AUC] =  [0.866, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [6256.792160.3, 8.766636.3, 6265.558796.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [02:04<01:03,  1.11it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728232245942286\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [02:07<01:32,  1.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342500200822744\n",
      "--- Training --- [threshold, AUC] =  [0.875, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [6256.677949.3, 8.253501.3, 6264.931450.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [02:15<00:54,  1.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728065791553044\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [02:18<01:28,  1.50s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342411216304127\n",
      "--- Training --- [threshold, AUC] =  [0.882, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [6256.558629.3, 7.821353.3, 6264.379982.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [02:27<00:55,  1.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.872789441228624\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [02:29<01:17,  1.59s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342319568413903\n",
      "--- Training --- [threshold, AUC] =  [0.888, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [6256.435779.3, 7.451973.3, 6263.887752.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [02:38<00:37,  1.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8727719749383255\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [02:40<00:52,  1.35s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342226144587235\n",
      "--- Training --- [threshold, AUC] =  [0.893, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [6256.310575.3, 7.132372.3, 6263.442947.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [02:49<00:28,  1.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8727543049622901\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [02:52<00:49,  1.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342131617557472\n",
      "--- Training --- [threshold, AUC] =  [0.898, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [6256.183911.3, 6.853001.3, 6263.036912.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [03:05<00:29,  1.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8727365275250824\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [03:08<00:38,  2.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342036505807003\n",
      "--- Training --- [threshold, AUC] =  [0.902, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [6256.056477.3, 6.606664.3, 6262.663140.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [03:18<00:10,  1.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8727187178355552\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [03:20<00:13,  1.45s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9341941214176267\n",
      "--- Training --- [threshold, AUC] =  [0.905, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [6255.928811.3, 6.387817.3, 6262.316628.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [03:29<00:00,  1.05s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.908, 1.0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.855]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.455, 0.942, 0.855, 0.938]\n",
      "initial loading beta [[ 0.23290745  0.19770631 -0.99831164]]\n",
      "*** rel_error_data train 23.636263695811312\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:03<10:52,  3.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9832743134249307\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.533]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [169432.349757.3, 7372.795479.3, 176805.145236.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:13<03:22,  1.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 3.628852663183102\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:16<04:59,  1.59s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9714910512689426\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.894]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [26012.784489.3, 5399.879560.3, 31412.664049.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:26<03:26,  1.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.2139013897935491\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:29<04:59,  1.67s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9601719965918599\n",
      "--- Training --- [threshold, AUC] =  [0.999, 0.97]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [8701.636075.3, 755.149939.3, 9456.786014.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:41<04:59,  1.76s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.9167312825214041\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:45<07:08,  2.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9439734423864976\n",
      "--- Training --- [threshold, AUC] =  [0.744, 0.993]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [6571.425048.3, 93.308225.3, 6664.733273.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:55<03:01,  1.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8784503282237194\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [00:58<04:24,  1.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9360321605650468\n",
      "--- Training --- [threshold, AUC] =  [0.685, 0.999]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [6297.014840.3, 37.214210.3, 6334.229050.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:07<02:31,  1.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.87358135188127\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:10<04:36,  1.86s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9345159782779415\n",
      "--- Training --- [threshold, AUC] =  [0.577, 1.0]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [6262.112450.3, 21.160459.3, 6283.272909.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [01:21<02:40,  1.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8729664521950284\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [01:23<03:45,  1.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9343077252801486\n",
      "--- Training --- [threshold, AUC] =  [0.703, 1.0]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [6257.704651.3, 16.180990.3, 6273.885640.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [01:34<02:50,  1.31s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.872889600183279\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [01:37<03:43,  1.74s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342825687337377\n",
      "--- Training --- [threshold, AUC] =  [0.768, 1.0]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [6257.153751.3, 13.610742.3, 6270.764492.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:47<02:17,  1.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728774553931813\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:51<03:42,  1.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342784565096177\n",
      "--- Training --- [threshold, AUC] =  [0.804, 1.0]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [6257.066693.3, 11.968413.3, 6269.035106.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [02:02<02:20,  1.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728698480498269\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [02:05<03:29,  1.92s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342748057771326\n",
      "--- Training --- [threshold, AUC] =  [0.828, 1.0]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [6257.012161.3, 10.803701.3, 6267.815862.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [02:16<02:05,  1.25s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728600218704625\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [02:19<02:46,  1.68s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342696479577437\n",
      "--- Training --- [threshold, AUC] =  [0.845, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [6256.941724.3, 9.923960.3, 6266.865684.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [02:29<01:55,  1.29s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728479255231955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [02:32<02:38,  1.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342632117596705\n",
      "--- Training --- [threshold, AUC] =  [0.858, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [6256.855013.3, 9.230584.3, 6266.085597.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [02:42<01:29,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728341346228666\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [02:45<02:01,  1.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342558509262624\n",
      "--- Training --- [threshold, AUC] =  [0.867, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [6256.756156.3, 8.667036.3, 6265.423192.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [02:55<01:36,  1.38s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728191302527336\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [02:59<02:12,  1.92s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342478333514115\n",
      "--- Training --- [threshold, AUC] =  [0.875, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [6256.648600.3, 8.198229.3, 6264.846829.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [03:12<01:33,  1.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8728032640453492\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [03:15<01:57,  1.99s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342393506087667\n",
      "--- Training --- [threshold, AUC] =  [0.882, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [6256.534865.3, 7.801073.3, 6264.335938.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [03:24<00:49,  1.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8727867924702565\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [03:27<01:11,  1.46s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342305414641555\n",
      "--- Training --- [threshold, AUC] =  [0.887, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [6256.416792.3, 7.459659.3, 6263.876451.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [03:35<00:39,  1.00it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8727699059001407\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [03:37<00:55,  1.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342215086129608\n",
      "--- Training --- [threshold, AUC] =  [0.892, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [6256.295744.3, 7.162622.3, 6263.458366.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [03:47<00:31,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8727527482355257\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [03:50<00:43,  1.50s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342123295501754\n",
      "--- Training --- [threshold, AUC] =  [0.896, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [6256.172752.3, 6.901591.3, 6263.074343.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [03:59<00:21,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8727354299535351\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [04:02<00:29,  1.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342030637048672\n",
      "--- Training --- [threshold, AUC] =  [0.9, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [6256.048609.3, 6.670244.3, 6262.718853.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [04:12<00:10,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8727180369600452\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [04:14<00:13,  1.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9341937572519503\n",
      "--- Training --- [threshold, AUC] =  [0.903, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [6255.923930.3, 6.463705.3, 6262.387635.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [04:24<00:00,  1.32s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.905, 1.0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.83]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.330, 0.934, 0.830, 0.938]\n",
      "initial loading beta [[-0.47341812 -0.0456344   0.73949541]]\n",
      "*** rel_error_data train 8.122023453072496\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:03<10:38,  3.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9821383998599195\n",
      "--- Training --- [threshold, AUC] =  [0.0, 0.761]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [58221.279646.3, 6327.361272.3, 297433.759505.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:14<04:25,  1.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710984001567111\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:17<05:57,  1.89s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933323660132544\n",
      "--- Training --- [threshold, AUC] =  [0.009, 0.974]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [6244.313852.3, 617.165859.3, 31838.735120.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:28<03:44,  1.24s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8712197546879079\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:31<05:10,  1.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933391287311949\n",
      "--- Training --- [threshold, AUC] =  [0.02, 0.989]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [6245.183760.3, 239.709744.3, 31465.628546.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:40<03:04,  1.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713669593230844\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:43<04:17,  1.52s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334702383216119\n",
      "--- Training --- [threshold, AUC] =  [0.383, 0.996]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [6246.238971.3, 65.087381.3, 31296.282235.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:52<02:56,  1.10s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8714560655587823\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [00:55<04:09,  1.57s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335180688350131\n",
      "--- Training --- [threshold, AUC] =  [0.5, 0.999]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [6246.877713.3, 35.800446.3, 31270.189010.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:04<02:30,  1.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8714822188767128\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:06<03:39,  1.47s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335321068017983\n",
      "--- Training --- [threshold, AUC] =  [0.595, 1.0]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [6247.065188.3, 26.554570.3, 31261.880511.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [01:17<02:56,  1.26s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8714692844246048\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [01:20<03:57,  1.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335251857315927\n",
      "--- Training --- [threshold, AUC] =  [0.514, 1.0]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [6246.972470.3, 23.356881.3, 31258.219231.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [01:30<02:28,  1.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8714432262722053\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [01:32<03:28,  1.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335112308076317\n",
      "--- Training --- [threshold, AUC] =  [0.567, 1.0]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [6246.785677.3, 21.913478.3, 31255.841861.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:43<02:29,  1.25s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.871414982475103\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:46<03:25,  1.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334961040693426\n",
      "--- Training --- [threshold, AUC] =  [0.593, 1.0]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [6246.583216.3, 21.125389.3, 31254.041469.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [01:56<02:07,  1.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713883599904185\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [01:59<02:59,  1.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334818451540825\n",
      "--- Training --- [threshold, AUC] =  [0.608, 1.0]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [6246.392378.3, 20.631653.3, 31252.593541.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [02:09<01:50,  1.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713645324763185\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [02:12<02:40,  1.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334690829064165\n",
      "--- Training --- [threshold, AUC] =  [0.618, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [6246.221574.3, 20.283521.3, 31251.391392.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [02:25<02:14,  1.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713436733904479\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [02:28<02:51,  1.93s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334579103666248\n",
      "--- Training --- [threshold, AUC] =  [0.625, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [6246.072050.3, 20.011706.3, 31250.371954.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [02:37<01:28,  1.10s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713255819025921\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [02:40<01:58,  1.50s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334482200569165\n",
      "--- Training --- [threshold, AUC] =  [0.63, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [6245.942364.3, 19.781584.3, 31249.493404.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [02:49<01:15,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713099364443037\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [02:52<01:49,  1.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334398398002093\n",
      "--- Training --- [threshold, AUC] =  [0.635, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [6245.830212.3, 19.575049.3, 31248.726110.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [03:02<01:08,  1.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8712963988004782\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [03:04<01:36,  1.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334325884823007\n",
      "--- Training --- [threshold, AUC] =  [0.639, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [6245.733170.3, 19.382324.3, 31248.048175.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [03:14<00:54,  1.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8712846549359317\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [03:19<01:50,  2.25s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334262979258531\n",
      "--- Training --- [threshold, AUC] =  [0.642, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [6245.648986.3, 19.198016.3, 31247.442948.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [03:28<00:44,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8712744284623714\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [03:32<01:12,  1.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334208201083332\n",
      "--- Training --- [threshold, AUC] =  [0.645, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [6245.575680.3, 19.019110.3, 31246.897508.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [03:43<00:37,  1.24s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.871265482423564\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [03:46<00:51,  1.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334160281213545\n",
      "--- Training --- [threshold, AUC] =  [0.649, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [6245.511552.3, 18.843926.3, 31246.401684.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [03:56<00:23,  1.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8712576163977244\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [03:59<00:32,  1.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334118146208995\n",
      "--- Training --- [threshold, AUC] =  [0.651, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [6245.455165.3, 18.671550.3, 31245.947377.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [04:09<00:11,  1.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8712506620401065\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [04:13<00:17,  1.93s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334080894419147\n",
      "--- Training --- [threshold, AUC] =  [0.654, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [6245.405314.3, 18.501516.3, 31245.528087.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [04:25<00:00,  1.33s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.657, 1.0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.87]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.308, 0.955, 0.870, 0.937]\n",
      "initial loading beta [[ 0.65599504 -0.90424156 -0.71340305]]\n",
      "*** rel_error_data train 8.27856897801197\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:02<08:58,  2.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9825661060141813\n",
      "--- Training --- [threshold, AUC] =  [2.0, 0.221]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [59343.448382.3, 5973.715804.3, 302690.957712.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:11<03:15,  1.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8719329110606295\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:14<04:19,  1.37s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9337607615971756\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.941]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [6250.295895.3, 6844.608561.3, 38096.088036.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:23<03:12,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8715128007467575\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:26<04:39,  1.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.93354822256088\n",
      "--- Training --- [threshold, AUC] =  [0.945, 0.986]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [6247.284409.3, 235.432619.3, 31471.854664.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:35<02:54,  1.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8715657530416209\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:37<04:06,  1.46s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335767165022606\n",
      "--- Training --- [threshold, AUC] =  [0.368, 0.996]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [6247.663988.3, 67.116861.3, 31305.436801.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:46<02:53,  1.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8716139274663273\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [00:50<04:42,  1.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336026152910278\n",
      "--- Training --- [threshold, AUC] =  [0.558, 0.999]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [6248.009318.3, 35.615291.3, 31275.661880.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:00<02:56,  1.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8716166828168197\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:02<04:03,  1.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336041209210291\n",
      "--- Training --- [threshold, AUC] =  [0.49, 1.0]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [6248.029069.3, 24.992028.3, 31265.137373.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [01:12<02:32,  1.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8715875612710567\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [01:15<03:55,  1.70s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335885327646187\n",
      "--- Training --- [threshold, AUC] =  [0.526, 1.0]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [6247.820316.3, 21.293239.3, 31260.394822.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [01:26<02:29,  1.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8715464941029994\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [01:28<03:33,  1.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335665404198524\n",
      "--- Training --- [threshold, AUC] =  [0.627, 1.0]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [6247.525934.3, 19.731409.3, 31257.361078.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:39<02:12,  1.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8715045043310398\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:42<03:16,  1.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335440523214418\n",
      "--- Training --- [threshold, AUC] =  [0.651, 1.0]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [6247.224938.3, 18.916163.3, 31255.040851.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [01:54<02:34,  1.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8714654642096862\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [01:58<03:38,  2.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335231432012581\n",
      "--- Training --- [threshold, AUC] =  [0.658, 1.0]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [6246.945085.3, 18.436057.3, 31253.161484.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [02:07<01:35,  1.05it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8714305366181047\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [02:09<02:20,  1.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335044361726667\n",
      "--- Training --- [threshold, AUC] =  [0.663, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [6246.694713.3, 18.126830.3, 31251.600396.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [02:18<01:35,  1.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.871399848519669\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [02:21<02:15,  1.52s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334879994268461\n",
      "--- Training --- [threshold, AUC] =  [0.666, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [6246.474731.3, 17.910263.3, 31250.283918.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [02:31<01:29,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713731219187205\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [02:33<01:57,  1.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334736842147109\n",
      "--- Training --- [threshold, AUC] =  [0.668, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [6246.283146.3, 17.745330.3, 31249.161060.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [02:42<01:12,  1.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713499367482458\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [02:45<01:57,  1.70s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334612656420374\n",
      "--- Training --- [threshold, AUC] =  [0.67, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [6246.116947.3, 17.609276.3, 31248.194013.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [02:55<01:13,  1.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713298458752133\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [02:58<01:35,  1.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334505043045466\n",
      "--- Training --- [threshold, AUC] =  [0.671, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [6245.972930.3, 17.489073.3, 31247.353721.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [03:08<00:58,  1.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8713124248458765\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [03:11<01:19,  1.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334411729113802\n",
      "--- Training --- [threshold, AUC] =  [0.673, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [6245.848050.3, 17.377149.3, 31246.617399.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [03:20<00:43,  1.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8712972913368405\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [03:24<01:07,  1.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334330667153239\n",
      "--- Training --- [threshold, AUC] =  [0.674, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [6245.739568.3, 17.269095.3, 31245.966936.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [03:34<00:36,  1.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8712841103634064\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [03:37<00:49,  1.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334260063205566\n",
      "--- Training --- [threshold, AUC] =  [0.676, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [6245.645083.3, 17.162388.3, 31245.387802.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [03:47<00:21,  1.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.871272592961572\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [03:49<00:31,  1.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334198369693186\n",
      "--- Training --- [threshold, AUC] =  [0.677, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [6245.562522.3, 17.055639.3, 31244.868250.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [04:01<00:12,  1.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8712624921231816\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [04:04<00:14,  1.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334144263682375\n",
      "--- Training --- [threshold, AUC] =  [0.679, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [6245.490116.3, 16.948150.3, 31244.398731.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [04:13<00:00,  1.27s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.68, 1.0]\n",
      "!!! ACC_list [0.875]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.256, 0.955, 0.875, 0.937]\n",
      "initial loading beta [[-0.70728687 -0.24742308 -0.65946266]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8753831629225424\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:02<08:20,  2.51s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9356191334745402\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.816]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [6275.028411.3, 12085.040432.3, 74835.324546.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:13<03:47,  1.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8705901212363714\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:16<05:44,  1.83s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9330541898712913\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.968]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [6240.670345.3, 1397.749307.3, 63804.452758.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:25<03:11,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8707892059544178\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:29<05:22,  1.80s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9331608682078443\n",
      "--- Training --- [threshold, AUC] =  [0.453, 0.987]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [6242.097448.3, 158.471820.3, 62579.446305.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:43<04:14,  1.50s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8708828527541579\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:48<07:04,  2.51s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332110440599212\n",
      "--- Training --- [threshold, AUC] =  [0.5, 0.994]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [6242.768739.3, 77.330824.3, 62505.018213.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:59<03:06,  1.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709456189843084\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:01<04:14,  1.60s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332446726257313\n",
      "--- Training --- [threshold, AUC] =  [0.533, 0.997]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [6243.218667.3, 53.246550.3, 62485.433224.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:11<02:42,  1.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.870984192469142\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:13<03:51,  1.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332653387269572\n",
      "--- Training --- [threshold, AUC] =  [0.816, 0.999]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [6243.495175.3, 76.823925.3, 62511.775672.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [01:23<02:29,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8711253308631861\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [01:26<03:51,  1.67s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333409510265721\n",
      "--- Training --- [threshold, AUC] =  [0.99, 0.998]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [6244.506900.3, 234.226693.3, 62679.295694.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [01:37<02:48,  1.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8711470016764841\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [01:40<04:08,  1.92s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333525602239512\n",
      "--- Training --- [threshold, AUC] =  [0.64, 0.999]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [6244.662243.3, 31.179134.3, 62477.801568.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:52<02:33,  1.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710919089310484\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:55<03:47,  1.91s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333230463944672\n",
      "--- Training --- [threshold, AUC] =  [0.627, 1.0]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [6244.267321.3, 29.120777.3, 62471.793986.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [02:05<02:03,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.871048424648801\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [02:08<03:17,  1.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332997506957778\n",
      "--- Training --- [threshold, AUC] =  [0.472, 1.0]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [6243.955612.3, 29.403384.3, 62468.959500.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [02:19<01:56,  1.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710166741398916\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [02:21<02:41,  1.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332827407275307\n",
      "--- Training --- [threshold, AUC] =  [0.608, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [6243.728014.3, 30.004630.3, 62467.284767.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [02:32<01:50,  1.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709944990174996\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [02:35<02:38,  1.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933270860478082\n",
      "--- Training --- [threshold, AUC] =  [0.604, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [6243.569055.3, 30.475904.3, 62466.166456.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [02:45<01:28,  1.10s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709792049193683\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [02:49<02:27,  1.86s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332626666268015\n",
      "--- Training --- [threshold, AUC] =  [0.447, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [6243.459422.3, 30.760146.3, 62465.354369.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [02:59<01:22,  1.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709686454527313\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [03:02<01:54,  1.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.93325700932419\n",
      "--- Training --- [threshold, AUC] =  [0.563, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [6243.383729.3, 30.887718.3, 62464.725004.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [03:12<01:07,  1.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709613320797006\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [03:16<01:55,  1.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332530911171422\n",
      "--- Training --- [threshold, AUC] =  [0.574, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [6243.331304.3, 30.916338.3, 62464.229378.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [03:26<00:55,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709565810563249\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [03:29<01:22,  1.68s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933250545703738\n",
      "--- Training --- [threshold, AUC] =  [0.569, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [6243.297247.3, 31.308372.3, 62464.280843.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [03:40<00:48,  1.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709609713962143\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [03:43<01:04,  1.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332528978772122\n",
      "--- Training --- [threshold, AUC] =  [0.786, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [6243.328718.3, 42.138888.3, 62475.426073.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [03:54<00:38,  1.27s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710435958106809\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [03:57<00:52,  1.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332971637215454\n",
      "--- Training --- [threshold, AUC] =  [0.958, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [6243.920997.3, 156.096930.3, 62595.306899.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [04:09<00:30,  1.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8711118522605306\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [04:13<00:42,  2.26s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333337303775807\n",
      "--- Training --- [threshold, AUC] =  [0.64, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [6244.410281.3, 23.190117.3, 62467.292928.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [04:24<00:12,  1.26s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710590531118334\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [04:27<00:16,  1.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333054447027691\n",
      "--- Training --- [threshold, AUC] =  [0.495, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [6244.031800.3, 23.665122.3, 62463.983120.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [04:39<00:00,  1.40s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.494, 1.0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.885]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.207, 0.957, 0.885, 0.937]\n",
      "initial loading beta [[-0.58477892  0.48820053 -0.40588118]]\n",
      "*** rel_error_data train 0.8709237427869877\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:03<10:21,  3.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332329520473599\n",
      "--- Training --- [threshold, AUC] =  [0.987, 0.934]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [6243.061852.3, 1159.002192.3, 63589.620710.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:14<04:14,  1.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8704800000746465\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:17<06:07,  1.94s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9329951768764116\n",
      "--- Training --- [threshold, AUC] =  [1.0, 0.954]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [6239.880961.3, 2816.934766.3, 65215.744378.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:29<03:52,  1.29s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8706968357810023\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:36<09:16,  3.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9331113737282395\n",
      "--- Training --- [threshold, AUC] =  [0.427, 0.988]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [6241.435309.3, 140.929701.3, 62555.282795.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:48<03:46,  1.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8708377267772827\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:51<05:07,  1.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9331868659476957\n",
      "--- Training --- [threshold, AUC] =  [0.796, 0.995]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [6242.445261.3, 87.001986.3, 62511.454600.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:02<03:33,  1.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.870976116355292\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:06<05:08,  1.94s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332610119137081\n",
      "--- Training --- [threshold, AUC] =  [0.985, 0.996]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [6243.437282.3, 225.228163.3, 62659.600987.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:17<02:58,  1.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8711194397824087\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:19<03:55,  1.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333377951108638\n",
      "--- Training --- [threshold, AUC] =  [0.716, 0.998]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [6244.464671.3, 51.002369.3, 62495.649078.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [01:29<02:28,  1.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710795830058631\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [01:31<03:32,  1.53s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333164431241223\n",
      "--- Training --- [threshold, AUC] =  [0.622, 0.999]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [6244.178965.3, 36.024944.3, 62477.814591.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [01:41<02:20,  1.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710453001549039\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [01:43<03:21,  1.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332980767988412\n",
      "--- Training --- [threshold, AUC] =  [0.556, 1.0]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [6243.933214.3, 33.384787.3, 62472.716929.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:53<02:14,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710155320606272\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:56<03:12,  1.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933282128865986\n",
      "--- Training --- [threshold, AUC] =  [0.587, 1.0]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [6243.719827.3, 33.025888.3, 62470.224157.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [02:06<02:06,  1.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709926729828606\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [02:08<02:55,  1.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332698821792444\n",
      "--- Training --- [threshold, AUC] =  [0.593, 1.0]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [6243.555966.3, 33.159531.3, 62468.719188.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [02:18<01:52,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709766859789859\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [02:21<02:38,  1.60s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332613170912989\n",
      "--- Training --- [threshold, AUC] =  [0.541, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [6243.441366.3, 33.846501.3, 62468.260158.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [02:31<01:39,  1.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709852133504448\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [02:34<02:22,  1.60s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332658856673403\n",
      "--- Training --- [threshold, AUC] =  [0.887, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [6243.502493.3, 79.149192.3, 62514.174119.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [02:43<01:28,  1.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8711509530836838\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [02:46<02:02,  1.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333546770031659\n",
      "--- Training --- [threshold, AUC] =  [0.996, 0.998]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [6244.690568.3, 303.411303.3, 62750.316987.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [02:57<01:31,  1.31s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8711630325573271\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [03:00<02:05,  1.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333611479793483\n",
      "--- Training --- [threshold, AUC] =  [0.55, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [6244.777158.3, 25.543363.3, 62473.314943.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [03:10<01:00,  1.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8711033336938747\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [03:12<01:20,  1.37s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933329166850514\n",
      "--- Training --- [threshold, AUC] =  [0.619, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [6244.349217.3, 24.824301.3, 62468.316474.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [03:20<00:48,  1.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710573411293083\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [03:22<01:06,  1.36s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333045275414174\n",
      "--- Training --- [threshold, AUC] =  [0.569, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [6244.019528.3, 25.650260.3, 62465.845538.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [03:32<00:40,  1.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710244380282297\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [03:34<00:54,  1.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332869001696261\n",
      "--- Training --- [threshold, AUC] =  [0.586, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [6243.783668.3, 26.537240.3, 62464.373917.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [03:43<00:32,  1.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8710015015484511\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [03:46<00:44,  1.53s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933274612077523\n",
      "--- Training --- [threshold, AUC] =  [0.481, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [6243.619252.3, 27.215501.3, 62463.408017.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [03:55<00:21,  1.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709855492188727\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [03:58<00:29,  1.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332660656098413\n",
      "--- Training --- [threshold, AUC] =  [0.521, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [6243.504900.3, 27.672615.3, 62462.721617.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [04:10<00:12,  1.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8709743742849083\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [04:12<00:14,  1.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332600785873725\n",
      "--- Training --- [threshold, AUC] =  [0.523, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [6243.424795.3, 27.950005.3, 62462.197952.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [04:22<00:00,  1.31s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type filter\n",
      "--- Training --- [threshold, AUC] =  [0.524, 1.0]\n",
      "!!! ACC_list [0.89]\n",
      "--- Validation (filter) --- [threshold, AUC, accuracy, rel_error_data] = [0.211, 0.957, 0.890, 0.937]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial loading beta [[-0.10456762  0.53464903  0.36463133]]\n",
      "*** rel_error_data train 76042.54989702317\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:02<08:55,  2.69s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528384612\n",
      "--- Training --- [threshold, AUC] =  [0.507, 0.494]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [218038.994256.3, 568.551598.3, 568.551598.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:11<03:12,  1.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.54771429156\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:14<04:49,  1.53s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528391535\n",
      "--- Training --- [threshold, AUC] =  [0.526, 0.494]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [218038.987998.3, 564.276829.3, 564.276829.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:22<02:55,  1.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.5455380454\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:25<04:19,  1.45s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528397972\n",
      "--- Training --- [threshold, AUC] =  [0.538, 0.495]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [218038.981758.3, 562.152192.3, 562.152192.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:35<03:14,  1.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.54336869987\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:37<04:36,  1.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528403951\n",
      "--- Training --- [threshold, AUC] =  [0.547, 0.495]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [218038.975537.3, 560.908972.3, 560.908972.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [00:46<02:33,  1.04it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.54120641496\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [00:49<03:52,  1.47s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528409517\n",
      "--- Training --- [threshold, AUC] =  [0.553, 0.496]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [218038.969338.3, 560.108885.3, 560.108885.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [00:57<02:14,  1.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.53905123976\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [00:59<03:26,  1.39s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528414717\n",
      "--- Training --- [threshold, AUC] =  [0.558, 0.496]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [218038.963158.3, 559.559738.3, 559.559738.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [01:07<02:10,  1.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.53690316636\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [01:10<03:23,  1.46s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528419545\n",
      "--- Training --- [threshold, AUC] =  [0.562, 0.496]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [218038.956999.3, 559.163988.3, 559.163988.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [01:18<02:06,  1.03it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.53476215256\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [01:21<02:59,  1.39s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528424053\n",
      "--- Training --- [threshold, AUC] =  [0.565, 0.497]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [218038.950860.3, 558.867008.3, 558.867008.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [01:29<01:51,  1.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.53262813909\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [01:31<02:46,  1.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528428245\n",
      "--- Training --- [threshold, AUC] =  [0.568, 0.497]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [218038.944741.3, 558.635990.3, 558.635990.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [01:41<01:56,  1.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.53050105336\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [01:44<02:49,  1.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528432082\n",
      "--- Training --- [threshold, AUC] =  [0.57, 0.498]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [218038.938642.3, 558.450201.3, 558.450201.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [01:53<01:46,  1.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.52838081171\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [01:56<02:41,  1.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984423652843564\n",
      "--- Training --- [threshold, AUC] =  [0.571, 0.498]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [218038.932562.3, 558.296030.3, 558.296030.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [02:05<01:29,  1.00it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.5262673277\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [02:08<02:14,  1.51s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528438922\n",
      "--- Training --- [threshold, AUC] =  [0.574, 0.499]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [218038.926502.3, 558.164285.3, 558.164285.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [02:17<01:21,  1.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.52416050994\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [02:20<01:57,  1.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528441934\n",
      "--- Training --- [threshold, AUC] =  [0.576, 0.499]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [218038.920461.3, 558.048619.3, 558.048619.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [02:30<01:18,  1.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.52206026218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [02:33<01:55,  1.67s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528444671\n",
      "--- Training --- [threshold, AUC] =  [0.577, 0.5]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [218038.914439.3, 557.944577.3, 557.944577.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [02:44<01:09,  1.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.51996648748\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [02:46<01:34,  1.59s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528447144\n",
      "--- Training --- [threshold, AUC] =  [0.575, 0.5]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [218038.908436.3, 557.848986.3, 557.848986.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [02:56<01:04,  1.29s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.51787908483\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [02:59<01:27,  1.79s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984423652844936\n",
      "--- Training --- [threshold, AUC] =  [0.576, 0.5]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [218038.902450.3, 557.759566.3, 557.759566.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [03:10<00:47,  1.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.51579795178\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [03:14<01:21,  2.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984423652845133\n",
      "--- Training --- [threshold, AUC] =  [0.576, 0.5]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [218038.896483.3, 557.674661.3, 557.674661.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [03:33<00:56,  1.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.51372298803\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [03:38<01:26,  3.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528453081\n",
      "--- Training --- [threshold, AUC] =  [0.577, 0.501]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [218038.890533.3, 557.593062.3, 557.593062.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [03:58<00:45,  2.29s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.51165408666\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [04:04<01:02,  3.27s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984423652845459\n",
      "--- Training --- [threshold, AUC] =  [0.58, 0.501]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [218038.884601.3, 557.513874.3, 557.513874.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [04:22<00:19,  1.92s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76042.50959114327\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [04:27<00:24,  2.69s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844236528455881\n",
      "--- Training --- [threshold, AUC] =  [0.581, 0.501]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [218038.878686.3, 557.436437.3, 557.436437.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [04:47<00:00,  1.44s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [0.406, 0.774]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.685]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [0.406, 0.774, 0.685, 0.985]\n",
      "initial loading beta [[ 0.06655242 -0.41377005 -0.13151085]]\n",
      "*** rel_error_data train 76874.55930656618\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:05<17:10,  5.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434535376\n",
      "--- Training --- [threshold, AUC] =  [0.499, 0.482]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [220424.638808.3, 562.626420.3, 562.626420.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:21<05:26,  1.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56027995085\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:25<07:11,  2.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434573565\n",
      "--- Training --- [threshold, AUC] =  [0.492, 0.483]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [220424.641599.3, 561.413426.3, 561.413426.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:41<04:47,  1.60s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56124794105\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:45<07:19,  2.46s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434609823\n",
      "--- Training --- [threshold, AUC] =  [0.487, 0.483]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [220424.644375.3, 560.573961.3, 560.573961.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [01:01<04:27,  1.57s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56221050689\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [01:04<06:16,  2.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434644241\n",
      "--- Training --- [threshold, AUC] =  [0.581, 0.483]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [220424.647135.3, 559.957621.3, 559.957621.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:20<04:16,  1.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56316762418\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:23<05:43,  2.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434676883\n",
      "--- Training --- [threshold, AUC] =  [0.48, 0.483]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [220424.649879.3, 559.485168.3, 559.485168.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:35<03:32,  1.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56411927339\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:39<05:22,  2.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434707897\n",
      "--- Training --- [threshold, AUC] =  [0.575, 0.483]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [220424.652608.3, 559.110885.3, 559.110885.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [01:53<03:22,  1.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.5650654407\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [01:57<05:16,  2.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434737278\n",
      "--- Training --- [threshold, AUC] =  [0.572, 0.483]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [220424.655321.3, 558.806541.3, 558.806541.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [02:13<04:01,  1.86s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56600612217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [02:18<05:39,  2.64s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984300943476516\n",
      "--- Training --- [threshold, AUC] =  [0.57, 0.483]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [220424.658018.3, 558.553768.3, 558.553768.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [02:37<04:10,  2.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56694131096\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [02:42<06:00,  3.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434791589\n",
      "--- Training --- [threshold, AUC] =  [0.567, 0.483]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [220424.660699.3, 558.340100.3, 558.340100.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [03:03<04:17,  2.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56787101323\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [03:08<05:47,  3.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434816685\n",
      "--- Training --- [threshold, AUC] =  [0.561, 0.483]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [220424.663365.3, 558.156780.3, 558.156780.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [03:27<03:31,  2.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56879523519\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [03:32<05:12,  3.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434840508\n",
      "--- Training --- [threshold, AUC] =  [0.56, 0.483]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [220424.666015.3, 557.997479.3, 557.997479.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [03:49<02:33,  1.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.56971398869\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [03:53<03:43,  2.52s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434863085\n",
      "--- Training --- [threshold, AUC] =  [0.558, 0.484]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [220424.668650.3, 557.857511.3, 557.857511.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [04:12<02:45,  2.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.57062729067\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [04:16<03:26,  2.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434884501\n",
      "--- Training --- [threshold, AUC] =  [0.556, 0.483]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [220424.671268.3, 557.733331.3, 557.733331.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [04:34<02:29,  2.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.57153515908\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [04:39<03:19,  2.89s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984300943490485\n",
      "--- Training --- [threshold, AUC] =  [0.556, 0.483]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [220424.673872.3, 557.622209.3, 557.622209.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [04:59<02:23,  2.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.57243761506\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [05:02<02:30,  2.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434924127\n",
      "--- Training --- [threshold, AUC] =  [0.555, 0.483]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [220424.676459.3, 557.522009.3, 557.522009.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [05:16<01:22,  1.64s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.5733346841\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [05:20<01:59,  2.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434942417\n",
      "--- Training --- [threshold, AUC] =  [0.554, 0.483]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [220424.679031.3, 557.431038.3, 557.431038.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [05:35<01:03,  1.59s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.57422639498\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [05:39<01:33,  2.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434959781\n",
      "--- Training --- [threshold, AUC] =  [0.553, 0.483]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [220424.681588.3, 557.347931.3, 557.347931.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [05:53<00:46,  1.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.57511277481\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [05:57<01:06,  2.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984300943497627\n",
      "--- Training --- [threshold, AUC] =  [0.551, 0.483]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [220424.684130.3, 557.271585.3, 557.271585.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [06:12<00:29,  1.48s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.5759938553\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [06:16<00:41,  2.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009434991921\n",
      "--- Training --- [threshold, AUC] =  [0.55, 0.483]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [220424.686656.3, 557.201089.3, 557.201089.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [06:29<00:14,  1.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76874.57686966925\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [06:33<00:19,  2.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9843009435006752\n",
      "--- Training --- [threshold, AUC] =  [0.55, 0.483]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [220424.689167.3, 557.135691.3, 557.135691.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [06:48<00:00,  2.04s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [1.551, 0.22]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:1056: RuntimeWarning: invalid value encountered in longlong_scalars\n",
      "  precision = tp / (tp + fp)\n",
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.55]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [1.551, 0.213, 0.550, 0.985]\n",
      "initial loading beta [[-0.68190547  0.20053387  0.184822  ]]\n",
      "*** rel_error_data train 79167.32098542374\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:04<13:33,  4.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9835016918330796\n",
      "--- Training --- [threshold, AUC] =  [0.64, 0.498]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [226998.740429.3, 578.288167.3, 23278.162210.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:19<04:54,  1.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 76060.1138379426\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:22<06:55,  2.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.983500685506996\n",
      "--- Training --- [threshold, AUC] =  [0.61, 0.498]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [218089.355850.3, 567.869472.3, 22376.805057.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:39<05:17,  1.76s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 73074.86158239236\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:43<07:11,  2.41s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834996588168764\n",
      "--- Training --- [threshold, AUC] =  [0.596, 0.498]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [209529.656047.3, 563.886815.3, 21516.852419.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:58<04:42,  1.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 70206.77760653601\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [01:02<06:40,  2.37s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834986113502808\n",
      "--- Training --- [threshold, AUC] =  [0.586, 0.498]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [201305.916228.3, 561.773445.3, 20692.365068.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:19<05:29,  2.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 67451.26316753977\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:23<07:00,  2.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.98349754268639\n",
      "--- Training --- [threshold, AUC] =  [0.58, 0.498]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [193404.950285.3, 560.460542.3, 19900.955570.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:42<05:15,  2.10s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 64803.90001868212\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:47<07:38,  3.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834964523958352\n",
      "--- Training --- [threshold, AUC] =  [0.575, 0.498]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [185814.089652.3, 559.564396.3, 19140.973362.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [02:04<04:52,  2.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 62260.44332514187\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [02:10<07:17,  3.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834953400405584\n",
      "--- Training --- [threshold, AUC] =  [0.571, 0.498]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [178521.162993.3, 558.912939.3, 18411.029238.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [02:31<05:04,  2.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 59816.81485777222\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [02:36<06:42,  3.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834942051735863\n",
      "--- Training --- [threshold, AUC] =  [0.568, 0.498]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [171514.476683.3, 558.417415.3, 17709.865083.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [02:51<03:31,  1.76s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 57469.096453999744\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [02:56<05:29,  2.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834930473388839\n",
      "--- Training --- [threshold, AUC] =  [0.565, 0.498]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [164782.796061.3, 558.027373.3, 17036.306979.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [03:15<03:46,  2.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 55213.52373537347\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [03:20<05:21,  2.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834918660711666\n",
      "--- Training --- [threshold, AUC] =  [0.563, 0.498]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [158315.327418.3, 557.712000.3, 16389.244742.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [03:38<03:24,  2.04s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 53046.48007168125\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [03:43<04:59,  3.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834906608956805\n",
      "--- Training --- [threshold, AUC] =  [0.561, 0.499]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [152101.700684.3, 557.451410.3, 15767.621478.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [03:58<02:40,  1.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 50964.490781978326\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [04:02<03:37,  2.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834894313280588\n",
      "--- Training --- [threshold, AUC] =  [0.559, 0.499]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [146131.952807.3, 557.232189.3, 15170.427469.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [04:19<02:26,  1.83s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 48964.21756321771\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [04:22<03:04,  2.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.983488176874088\n",
      "--- Training --- [threshold, AUC] =  [0.558, 0.499]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [140396.511775.3, 557.044959.3, 14596.696136.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [04:38<02:06,  1.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 47042.45313753989\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [04:42<02:45,  2.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834868970295085\n",
      "--- Training --- [threshold, AUC] =  [0.556, 0.499]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [134886.181268.3, 556.882965.3, 14045.501092.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [05:00<02:09,  2.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 45196.11610967105\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [05:05<02:56,  2.99s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834855912798374\n",
      "--- Training --- [threshold, AUC] =  [0.555, 0.499]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [129592.125911.3, 556.741218.3, 13515.953809.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [05:23<01:44,  2.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 43422.24602614365\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [05:29<02:28,  3.04s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.983484259100139\n",
      "--- Training --- [threshold, AUC] =  [0.553, 0.499]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [124505.857112.3, 556.615948.3, 13007.201659.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [05:45<01:11,  1.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 41717.998628449226\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [05:49<01:37,  2.51s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.983482899954805\n",
      "--- Training --- [threshold, AUC] =  [0.545, 0.499]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [119619.219446.3, 556.504259.3, 12518.426204.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [06:06<00:51,  1.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 40080.64129249842\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [06:10<01:11,  2.48s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834815132973654\n",
      "--- Training --- [threshold, AUC] =  [0.544, 0.499]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [114924.377581.3, 556.403883.3, 12048.841641.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [06:27<00:41,  2.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 38507.5486470762\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [06:32<00:59,  3.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9834800985702417\n",
      "--- Training --- [threshold, AUC] =  [0.544, 0.499]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [110413.803715.3, 556.313021.3, 11597.693392.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [06:53<00:23,  2.36s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 36996.19836426825\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [06:59<00:28,  3.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.983478655204526\n",
      "--- Training --- [threshold, AUC] =  [0.543, 0.499]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [106080.265504.3, 556.230225.3, 11164.256775.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [07:17<00:00,  2.19s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [0.431, 0.775]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.65]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [0.431, 0.755, 0.650, 0.984]\n",
      "initial loading beta [[ 0.23463303 -0.47626819 -0.39670379]]\n",
      "*** rel_error_data train 78917.32995701408\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:04<16:17,  4.91s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837657752123556\n",
      "--- Training --- [threshold, AUC] =  [0.555, 0.527]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [226281.933950.3, 559.464176.3, 23187.657571.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:22<05:57,  1.88s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 75819.93719688695\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:27<08:20,  2.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.983764795663471\n",
      "--- Training --- [threshold, AUC] =  [0.549, 0.527]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [217400.690447.3, 557.724882.3, 22297.793927.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:46<06:32,  2.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 72844.11416821548\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:52<09:04,  3.04s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837637963441795\n",
      "--- Training --- [threshold, AUC] =  [0.536, 0.527]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [208868.027338.3, 556.674862.3, 21443.477596.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [01:12<06:48,  2.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 69985.08937603669\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [01:16<08:25,  2.99s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837627768597881\n",
      "--- Training --- [threshold, AUC] =  [0.529, 0.528]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [200670.263177.3, 555.988734.3, 20623.015052.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:31<04:44,  1.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 67238.27860193359\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:35<06:50,  2.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837617368080689\n",
      "--- Training --- [threshold, AUC] =  [0.524, 0.528]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [192794.253503.3, 555.515324.3, 19834.940674.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:51<04:25,  1.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 64599.27755363966\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:55<06:04,  2.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837606757791432\n",
      "--- Training --- [threshold, AUC] =  [0.52, 0.529]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [185227.369763.3, 555.174814.3, 19077.911791.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [02:11<04:13,  1.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 62063.854803132504\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [02:15<05:56,  2.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837595933553515\n",
      "--- Training --- [threshold, AUC] =  [0.518, 0.529]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [177957.479060.3, 554.921169.3, 18350.669075.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [02:32<04:03,  1.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 59627.945001882086\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [02:37<06:03,  2.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837584891111443\n",
      "--- Training --- [threshold, AUC] =  [0.516, 0.529]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [170972.924703.3, 554.726077.3, 17652.018547.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [02:53<03:45,  1.88s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 57287.642362395454\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [02:58<05:27,  2.75s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837573626129653\n",
      "--- Training --- [threshold, AUC] =  [0.513, 0.53]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [164262.507516.3, 554.571279.3, 16980.822031.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [03:15<03:28,  1.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 55039.19439560034\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [03:19<04:39,  2.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837562134191432\n",
      "--- Training --- [threshold, AUC] =  [0.512, 0.53]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [157815.467879.3, 554.444568.3, 16335.991356.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [03:38<03:26,  2.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 52878.99589403093\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [03:44<04:56,  2.99s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837550410797686\n",
      "--- Training --- [threshold, AUC] =  [0.51, 0.53]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [151621.468476.3, 554.337550.3, 15716.484397.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [04:02<02:48,  1.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 50803.58315116858\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [04:06<03:53,  2.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.983753845136592\n",
      "--- Training --- [threshold, AUC] =  [0.508, 0.53]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [145670.577721.3, 554.244322.3, 15121.302094.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [04:24<02:47,  2.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 48809.62840765793\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [04:30<04:11,  3.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837526251229398\n",
      "--- Training --- [threshold, AUC] =  [0.507, 0.531]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [139953.253835.3, 554.160658.3, 14549.486041.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [04:48<02:23,  2.05s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 46893.93451552109\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [04:53<03:20,  2.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837513805635658\n",
      "--- Training --- [threshold, AUC] =  [0.506, 0.531]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [134460.329544.3, 554.083481.3, 14000.116435.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [05:14<02:19,  2.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 45053.429811778595\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [05:19<03:05,  3.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837501109745866\n",
      "--- Training --- [threshold, AUC] =  [0.511, 0.532]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [129182.997378.3, 554.010518.3, 13472.310256.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [05:37<01:50,  2.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 43285.16319328339\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [05:42<02:31,  3.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837488158633886\n",
      "--- Training --- [threshold, AUC] =  [0.512, 0.532]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [124112.795555.3, 553.940062.3, 12965.219618.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [05:58<01:09,  1.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 41586.29938486322\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [06:02<01:36,  2.48s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837474947285232\n",
      "--- Training --- [threshold, AUC] =  [0.511, 0.533]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [119241.594410.3, 553.870808.3, 12478.030249.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [06:18<00:52,  1.74s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 39954.11439318103\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [06:23<01:17,  2.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837461470596489\n",
      "--- Training --- [threshold, AUC] =  [0.509, 0.533]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [114561.583357.3, 553.801737.3, 12009.960073.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [06:38<00:35,  1.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 38385.99113902854\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [06:43<00:55,  2.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837447723374294\n",
      "--- Training --- [threshold, AUC] =  [0.509, 0.533]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [110065.258369.3, 553.732037.3, 11560.257874.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [06:59<00:16,  1.68s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 36879.41526104685\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [07:03<00:21,  2.39s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9837433700335003\n",
      "--- Training --- [threshold, AUC] =  [0.508, 0.534]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [105745.409947.3, 553.661038.3, 11128.202032.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [07:21<00:00,  2.21s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [1.607, 0.234]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:1056: RuntimeWarning: invalid value encountered in longlong_scalars\n",
      "  precision = tp / (tp + fp)\n",
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.55]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [1.607, 0.227, 0.550, 0.985]\n",
      "initial loading beta [[-0.84682689  0.93479293  0.40159779]]\n",
      "*** rel_error_data train 71470.0283062337\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:05<17:16,  5.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9850792698945303\n",
      "--- Training --- [threshold, AUC] =  [0.605, 0.501]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [204928.071356.3, 566.475668.3, 205494.547023.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:21<05:33,  1.76s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 47714.25693644888\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:26<08:17,  2.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9850678412941276\n",
      "--- Training --- [threshold, AUC] =  [0.588, 0.502]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [136812.463656.3, 564.026905.3, 137376.490561.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:42<05:24,  1.80s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 31854.71384938848\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:46<07:17,  2.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9850538525386711\n",
      "--- Training --- [threshold, AUC] =  [0.578, 0.502]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [91337.938818.3, 562.924716.3, 91900.863534.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [01:01<04:35,  1.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 21266.75552217908\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [01:05<06:42,  2.38s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9850367017945469\n",
      "--- Training --- [threshold, AUC] =  [0.571, 0.503]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [60978.780846.3, 562.255051.3, 61541.035897.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:24<05:47,  2.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 14198.148966318024\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:30<08:22,  3.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9850157555271445\n",
      "--- Training --- [threshold, AUC] =  [0.566, 0.505]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [40710.761608.3, 561.680101.3, 41272.441709.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:48<05:30,  2.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 9479.089410934159\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:52<06:52,  2.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9849900657348037\n",
      "--- Training --- [threshold, AUC] =  [0.564, 0.508]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [27179.666179.3, 561.031210.3, 27740.697390.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [02:10<04:49,  2.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 6328.605798451056\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [02:15<06:37,  2.86s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9849586339473863\n",
      "--- Training --- [threshold, AUC] =  [0.562, 0.511]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [18146.193746.3, 560.184753.3, 18706.378499.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [02:36<05:14,  2.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 4225.3155586758185\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [02:41<06:58,  3.24s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9849202025026664\n",
      "--- Training --- [threshold, AUC] =  [0.564, 0.516]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [12115.369041.3, 559.009585.3, 12674.378626.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [03:00<04:01,  2.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2821.139488064222\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [03:05<05:35,  2.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984873159225516\n",
      "--- Training --- [threshold, AUC] =  [0.563, 0.524]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [8089.134537.3, 557.334713.3, 8646.469249.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [03:25<04:04,  2.22s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1883.697165562235\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [03:30<05:34,  3.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9848155281421793\n",
      "--- Training --- [threshold, AUC] =  [0.561, 0.535]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [5401.179156.3, 554.920828.3, 5956.099984.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [03:46<02:55,  1.75s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1257.8497723573428\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [03:50<04:00,  2.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.984744969873177\n",
      "--- Training --- [threshold, AUC] =  [0.549, 0.552]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [3606.668893.3, 551.432427.3, 4158.101320.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [04:08<03:11,  2.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 840.0259330086383\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [04:12<04:21,  2.94s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9846586007190806\n",
      "--- Training --- [threshold, AUC] =  [0.581, 0.576]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [2408.630561.3, 546.421574.3, 2955.052135.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [04:27<02:29,  1.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 561.0815941139521\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [04:31<03:26,  2.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9845527890711869\n",
      "--- Training --- [threshold, AUC] =  [0.583, 0.609]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [1608.805421.3, 539.362103.3, 2148.167524.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [04:49<02:21,  2.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 374.85696080282827\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [04:54<03:17,  2.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844232740579004\n",
      "--- Training --- [threshold, AUC] =  [0.587, 0.653]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [1074.838164.3, 529.805689.3, 1604.643853.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [05:08<01:32,  1.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 250.53601558447093\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [05:13<02:34,  2.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9842645696851737\n",
      "--- Training --- [threshold, AUC] =  [0.57, 0.707]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [718.369136.3, 517.681013.3, 1236.050149.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [05:34<01:57,  2.35s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 167.54444653703735\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [05:40<02:40,  3.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9840697329213935\n",
      "--- Training --- [threshold, AUC] =  [0.466, 0.765]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [480.405019.3, 503.514127.3, 983.919146.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [06:00<01:25,  2.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 112.14417992174211\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [06:04<01:48,  2.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9838299067758425\n",
      "--- Training --- [threshold, AUC] =  [0.498, 0.824]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [321.554238.3, 488.230604.3, 809.784842.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [06:18<00:51,  1.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 75.16212811604932\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [06:23<01:19,  2.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9835333815022087\n",
      "--- Training --- [threshold, AUC] =  [0.488, 0.88]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [215.514536.3, 472.686701.3, 688.201237.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [06:37<00:30,  1.51s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 50.47443748620702\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [06:42<00:47,  2.50s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9831656955242044\n",
      "--- Training --- [threshold, AUC] =  [0.52, 0.926]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [144.726809.3, 457.415184.3, 602.141993.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [06:57<00:15,  1.59s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 33.99349220447896\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [07:01<00:19,  2.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9827084713627945\n",
      "--- Training --- [threshold, AUC] =  [0.512, 0.962]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [97.470520.3, 442.666276.3, 540.136796.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [07:15<00:00,  2.18s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [0.357, 0.683]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.665]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [0.357, 0.710, 0.665, 0.983]\n",
      "initial loading beta [[-0.94660679  0.60617485 -0.10902415]]\n",
      "*** rel_error_data train 77243.51339456713\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:04<15:05,  4.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9832584887860297\n",
      "--- Training --- [threshold, AUC] =  [0.722, 0.482]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [221482.551495.3, 601.243577.3, 222083.795072.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:21<06:05,  1.92s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 51568.6829109387\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:26<08:40,  2.76s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9832470858685518\n",
      "--- Training --- [threshold, AUC] =  [0.661, 0.484]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [147864.370307.3, 573.461734.3, 148437.832040.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:42<05:43,  1.91s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 34427.961143320725\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:46<07:33,  2.53s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9832331301703857\n",
      "--- Training --- [threshold, AUC] =  [0.633, 0.485]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [98716.284924.3, 566.701309.3, 99282.986233.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [01:05<05:46,  2.04s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 22984.67830904007\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [01:10<08:37,  3.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9832160504958016\n",
      "--- Training --- [threshold, AUC] =  [0.614, 0.488]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [65904.630350.3, 563.500070.3, 66468.130420.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:26<05:13,  1.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 15345.051022760423\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:32<07:52,  2.97s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9831951481225162\n",
      "--- Training --- [threshold, AUC] =  [0.5, 0.491]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [43999.306919.3, 561.503886.3, 44560.810805.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:48<04:18,  1.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 10244.774368363174\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:52<06:16,  2.52s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9831695685708455\n",
      "--- Training --- [threshold, AUC] =  [0.6, 0.494]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [29375.136719.3, 560.007168.3, 29935.143887.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [02:06<03:37,  1.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 6839.788264644747\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [02:10<05:23,  2.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9831382673250002\n",
      "--- Training --- [threshold, AUC] =  [0.49, 0.5]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [19611.921959.3, 558.701029.3, 20170.622988.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [02:27<04:12,  1.94s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 4566.5914206466705\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [02:32<06:13,  2.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9830999827938219\n",
      "--- Training --- [threshold, AUC] =  [0.485, 0.507]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [13093.919153.3, 557.398099.3, 13651.317252.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [02:49<03:52,  1.93s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 3048.9858171231085\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [02:53<05:04,  2.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9830531285866341\n",
      "--- Training --- [threshold, AUC] =  [0.583, 0.518]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [8742.444881.3, 555.937206.3, 9298.382087.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [03:08<02:58,  1.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2035.8185824381947\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [03:12<04:12,  2.32s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9829958467171386\n",
      "--- Training --- [threshold, AUC] =  [0.481, 0.532]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [5837.361277.3, 554.128747.3, 6391.490024.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [03:29<03:38,  2.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1359.4179952195075\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [03:34<05:10,  3.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9829257591146373\n",
      "--- Training --- [threshold, AUC] =  [0.568, 0.552]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [3897.898385.3, 551.700519.3, 4449.598904.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [03:54<03:08,  2.10s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 907.845110205781\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [03:59<04:07,  2.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9828400910210431\n",
      "--- Training --- [threshold, AUC] =  [0.564, 0.582]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [2603.090441.3, 548.228954.3, 3151.319396.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [04:18<02:49,  2.12s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 606.368943427868\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [04:24<04:01,  3.05s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9827354393955715\n",
      "--- Training --- [threshold, AUC] =  [0.557, 0.624]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [1738.659142.3, 543.072844.3, 2281.731987.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [04:42<02:18,  1.98s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 405.09951432881996\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [04:47<03:16,  2.85s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9826074500465382\n",
      "--- Training --- [threshold, AUC] =  [0.545, 0.682]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [1161.553509.3, 535.419816.3, 1696.973326.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [05:08<02:23,  2.39s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 270.73140177098026\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [05:14<03:16,  3.32s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9824509150614879\n",
      "--- Training --- [threshold, AUC] =  [0.538, 0.753]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [776.275949.3, 524.669004.3, 1300.944953.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [05:35<02:02,  2.46s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 181.02988648221674\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [05:40<02:43,  3.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.982258919136363\n",
      "--- Training --- [threshold, AUC] =  [0.546, 0.834]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [519.072209.3, 511.066910.3, 1030.139120.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [06:01<01:31,  2.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 121.1486963227967\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [06:06<02:00,  3.10s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9820227898842108\n",
      "--- Training --- [threshold, AUC] =  [0.536, 0.907]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [347.373148.3, 495.743083.3, 843.116230.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [06:26<01:07,  2.25s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 81.17432546274158\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [06:32<01:34,  3.26s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9817309745204693\n",
      "--- Training --- [threshold, AUC] =  [0.521, 0.965]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [232.753482.3, 479.908618.3, 712.662100.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [06:50<00:43,  2.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 54.48837068351933\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [06:55<00:52,  2.75s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.981370273950435\n",
      "--- Training --- [threshold, AUC] =  [0.509, 0.995]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [156.236075.3, 464.302817.3, 620.538892.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [07:13<00:20,  2.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 36.67301829733239\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [07:19<00:27,  3.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9809207367117051\n",
      "--- Training --- [threshold, AUC] =  [0.508, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [105.153602.3, 449.243349.3, 554.396951.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [07:40<00:00,  2.30s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [0.443, 0.594]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.58]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [0.446, 0.614, 0.580, 0.981]\n",
      "initial loading beta [[-0.48553531 -0.17741944 -0.10563011]]\n",
      "*** rel_error_data train 59109.27674292404\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:04<15:17,  4.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9845430157258226\n",
      "--- Training --- [threshold, AUC] =  [0.642, 0.494]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [169485.732260.3, 591.130924.3, 848019.792226.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:22<06:31,  2.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 7187.098509854488\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:27<09:32,  3.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844365785779737\n",
      "--- Training --- [threshold, AUC] =  [0.594, 0.494]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [20607.774632.3, 571.186054.3, 103610.059213.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:47<07:05,  2.36s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 874.5744436099611\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:52<09:45,  3.27s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9841308281110462\n",
      "--- Training --- [threshold, AUC] =  [0.592, 0.496]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [2507.692500.3, 565.450532.3, 13103.913034.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [01:11<05:54,  2.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 107.11990206802157\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [01:16<08:40,  3.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9832510540347928\n",
      "--- Training --- [threshold, AUC] =  [0.58, 0.513]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [307.147982.3, 561.963651.3, 2097.703558.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:34<05:13,  1.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 13.813737788527742\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:39<07:21,  2.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.980704355705466\n",
      "--- Training --- [threshold, AUC] =  [0.581, 0.653]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [39.608528.3, 553.924754.3, 751.967396.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:57<05:29,  2.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2.4621391112744337\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [02:02<07:49,  3.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.972257981068989\n",
      "--- Training --- [threshold, AUC] =  [0.567, 0.92]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [7.059762.3, 535.351773.3, 570.650585.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [02:16<04:01,  1.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.0725497796681278\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [02:20<05:16,  2.27s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9520946450311291\n",
      "--- Training --- [threshold, AUC] =  [0.555, 1.0]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [3.075353.3, 516.024319.3, 531.401083.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [02:37<04:17,  1.98s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8992320887464671\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [02:40<04:56,  2.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9392264114426427\n",
      "--- Training --- [threshold, AUC] =  [0.558, 1.0]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [2.578394.3, 497.541071.3, 510.433042.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [02:57<03:33,  1.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8772631433770245\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [03:01<04:51,  2.45s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.93453470225662\n",
      "--- Training --- [threshold, AUC] =  [0.562, 1.0]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [2.515402.3, 479.919291.3, 492.496300.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [03:16<03:21,  1.83s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8743800223921723\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [03:21<04:54,  2.70s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335357523979603\n",
      "--- Training --- [threshold, AUC] =  [0.565, 1.0]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [2.507135.3, 463.235571.3, 475.771246.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [03:39<03:31,  2.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8739368419695211\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [03:45<05:11,  3.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.93337438822188\n",
      "--- Training --- [threshold, AUC] =  [0.568, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [2.505864.3, 447.557531.3, 460.086852.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [04:04<03:20,  2.22s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8738272070130279\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [04:10<04:41,  3.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333525434556597\n",
      "--- Training --- [threshold, AUC] =  [0.572, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [2.505550.3, 432.869538.3, 445.397288.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [04:26<02:21,  1.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8737743771759173\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [04:30<03:11,  2.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333408019320577\n",
      "--- Training --- [threshold, AUC] =  [0.577, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [2.505398.3, 419.065986.3, 431.592978.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [04:48<02:29,  2.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8737378242023474\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [04:52<02:58,  2.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333426660256603\n",
      "--- Training --- [threshold, AUC] =  [0.584, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [2.505294.3, 406.013171.3, 418.539639.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [05:08<01:45,  1.75s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8737095248803141\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [05:12<02:26,  2.48s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333463059554616\n",
      "--- Training --- [threshold, AUC] =  [0.592, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [2.505212.3, 393.608256.3, 406.134319.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [05:27<01:26,  1.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8736867344954582\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [05:31<01:55,  2.35s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333532111667754\n",
      "--- Training --- [threshold, AUC] =  [0.601, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [2.505147.3, 381.788973.3, 394.314709.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [05:49<01:20,  2.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8736679739138755\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [05:54<01:53,  2.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333686516379088\n",
      "--- Training --- [threshold, AUC] =  [0.611, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [2.505093.3, 370.515801.3, 383.041267.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [06:12<00:58,  1.97s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8736522751347263\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [06:17<01:20,  2.79s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333771245845488\n",
      "--- Training --- [threshold, AUC] =  [0.62, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [2.505048.3, 359.757484.3, 372.282725.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [06:34<00:39,  1.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8736389582935287\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [06:38<00:47,  2.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333877259165493\n",
      "--- Training --- [threshold, AUC] =  [0.628, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [2.505010.3, 349.485692.3, 362.010743.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [06:53<00:15,  1.59s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8736275291742143\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [06:56<00:20,  2.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9333951546376482\n",
      "--- Training --- [threshold, AUC] =  [0.637, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [2.504977.3, 339.673832.3, 352.198719.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [07:13<00:00,  2.17s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [0.54, 0.821]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.725]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [0.540, 0.751, 0.725, 0.938]\n",
      "initial loading beta [[0.00241871 0.23967128 0.59828574]]\n",
      "*** rel_error_data train 57178.100302241466\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:04<15:19,  4.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.983982516910081\n",
      "--- Training --- [threshold, AUC] =  [0.407, 0.538]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [163948.414411.3, 566.912993.3, 820308.985048.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:18<05:47,  1.83s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 6952.310156695282\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:24<09:22,  2.98s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9838725883584123\n",
      "--- Training --- [threshold, AUC] =  [0.431, 0.539]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [19934.559222.3, 560.260391.3, 100233.056502.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:43<05:58,  1.99s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 846.020757889242\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:48<07:53,  2.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9835555153839808\n",
      "--- Training --- [threshold, AUC] =  [0.443, 0.55]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [2425.819695.3, 555.952057.3, 12685.050530.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [01:09<06:54,  2.44s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 103.6309900134038\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [01:13<08:56,  3.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9826244410590771\n",
      "--- Training --- [threshold, AUC] =  [0.447, 0.605]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [297.144123.3, 547.017391.3, 2032.738009.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:32<05:50,  2.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 13.381516683450666\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:37<07:48,  2.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9798347793865592\n",
      "--- Training --- [threshold, AUC] =  [0.443, 0.719]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [38.369208.3, 530.094031.3, 721.940073.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:54<04:57,  1.98s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 2.411493543537373\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:59<07:03,  2.84s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9720918970186281\n",
      "--- Training --- [threshold, AUC] =  [0.462, 0.829]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [6.914545.3, 511.415345.3, 545.988070.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [02:19<04:49,  2.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 1.0703135536675628\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [02:24<06:43,  2.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9564684563204015\n",
      "--- Training --- [threshold, AUC] =  [0.48, 0.91]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [3.068941.3, 493.522433.3, 508.867138.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [02:40<04:08,  1.91s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8999271322640912\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [02:45<05:59,  2.79s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9398544991913569\n",
      "--- Training --- [threshold, AUC] =  [0.483, 0.964]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [2.580387.3, 476.600842.3, 489.502777.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [03:05<04:19,  2.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8775060231069555\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [03:10<06:02,  3.05s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.934360980516804\n",
      "--- Training --- [threshold, AUC] =  [0.499, 0.992]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [2.516098.3, 460.611292.3, 473.191784.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [03:32<04:22,  2.38s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8743697263538889\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [03:38<06:07,  3.37s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9334278757467372\n",
      "--- Training --- [threshold, AUC] =  [0.503, 0.999]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [2.507106.3, 445.489062.3, 458.024590.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [03:59<03:57,  2.38s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.873786537228686\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [04:04<05:08,  3.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332779503841842\n",
      "--- Training --- [threshold, AUC] =  [0.508, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [2.505433.3, 431.155343.3, 443.682510.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [04:23<03:19,  2.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.873586900937734\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [04:29<04:47,  3.24s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332319904959592\n",
      "--- Training --- [threshold, AUC] =  [0.522, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [2.504861.3, 417.534963.3, 430.059268.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [04:48<02:45,  2.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8734740611873215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [04:55<04:27,  3.39s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332091258491055\n",
      "--- Training --- [threshold, AUC] =  [0.535, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [2.504537.3, 404.568682.3, 417.091368.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [05:16<02:50,  2.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8733982573319049\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [05:22<03:48,  3.31s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9331970755706946\n",
      "--- Training --- [threshold, AUC] =  [0.546, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [2.504320.3, 392.212315.3, 404.733915.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [05:40<01:49,  1.83s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8733453304492893\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [05:45<02:36,  2.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9331873022389434\n",
      "--- Training --- [threshold, AUC] =  [0.558, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [2.504168.3, 380.430236.3, 392.951077.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [06:01<01:25,  1.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8733081048849765\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [06:05<01:55,  2.37s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9331840156395345\n",
      "--- Training --- [threshold, AUC] =  [0.569, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [2.504061.3, 369.190721.3, 381.711029.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [06:19<01:03,  1.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.873281943641082\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [06:24<01:39,  2.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9331874636869322\n",
      "--- Training --- [threshold, AUC] =  [0.579, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [2.503986.3, 358.464172.3, 370.984105.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [06:40<00:54,  1.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8732636683131778\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [06:45<01:18,  2.69s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933194732723937\n",
      "--- Training --- [threshold, AUC] =  [0.589, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [2.503934.3, 348.222657.3, 360.742327.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [07:02<00:38,  1.94s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.873251064457184\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [07:07<00:54,  2.88s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9331984538958904\n",
      "--- Training --- [threshold, AUC] =  [0.599, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [2.503898.3, 338.439789.3, 350.959279.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [07:23<00:18,  1.85s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8732425732667044\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [07:28<00:23,  2.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9332119619987234\n",
      "--- Training --- [threshold, AUC] =  [0.609, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [2.503874.3, 329.090661.3, 341.610029.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [07:46<00:00,  2.33s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [0.495, 0.956]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.86]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [0.494, 0.909, 0.860, 0.937]\n",
      "initial loading beta [[-0.00415334 -0.8264525  -0.35410153]]\n",
      "*** rel_error_data train 52002.91591009151\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:05<18:37,  5.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9849359523846999\n",
      "--- Training --- [threshold, AUC] =  [0.578, 0.486]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [149109.459096.3, 595.251834.3, 1491689.842795.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:21<05:56,  1.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 600.4412276916065\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:25<08:13,  2.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9844302039346707\n",
      "--- Training --- [threshold, AUC] =  [0.514, 0.494]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [1721.662432.3, 571.296207.3, 17787.920527.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:43<05:45,  1.92s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 7.812362432905726\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:47<07:50,  2.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9796748276399723\n",
      "--- Training --- [threshold, AUC] =  [0.599, 0.575]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [22.400612.3, 551.089037.3, 775.095156.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [01:03<04:47,  1.69s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.9595966157486788\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [01:08<06:58,  2.48s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9450362615265513\n",
      "--- Training --- [threshold, AUC] =  [0.574, 0.679]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [2.751479.3, 529.878909.3, 557.393699.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:23<04:54,  1.84s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8765280850584924\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:28<07:35,  2.86s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9346213559981432\n",
      "--- Training --- [threshold, AUC] =  [0.5, 0.775]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [2.513294.3, 510.538359.3, 535.671302.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:45<04:25,  1.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8752782196964772\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:51<07:12,  2.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.934070557736915\n",
      "--- Training --- [threshold, AUC] =  [0.532, 0.855]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [2.509710.3, 492.573348.3, 517.670453.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [02:06<03:55,  1.68s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8750611688016245\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [02:11<06:02,  2.60s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9339283273013421\n",
      "--- Training --- [threshold, AUC] =  [0.514, 0.918]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [2.509088.3, 475.724415.3, 500.815296.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [02:29<04:07,  1.91s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8748846971947224\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [02:34<06:01,  2.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9338250149687499\n",
      "--- Training --- [threshold, AUC] =  [0.51, 0.96]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [2.508582.3, 459.834251.3, 484.920072.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [02:48<03:06,  1.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8747348702060118\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [02:54<05:43,  2.89s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9337452103337047\n",
      "--- Training --- [threshold, AUC] =  [0.501, 0.985]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [2.508152.3, 444.786150.3, 469.867675.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [03:09<02:53,  1.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8746082795610144\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [03:13<04:31,  2.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336990786337259\n",
      "--- Training --- [threshold, AUC] =  [0.512, 0.996]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [2.507790.3, 430.491984.3, 455.569879.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [03:29<03:03,  1.83s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8745012915708206\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [03:34<04:29,  2.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336523464770534\n",
      "--- Training --- [threshold, AUC] =  [0.505, 0.999]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [2.507483.3, 416.888236.3, 441.963064.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [03:49<02:34,  1.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8744105758282927\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [03:54<04:01,  2.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336280160067094\n",
      "--- Training --- [threshold, AUC] =  [0.506, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [2.507223.3, 403.928513.3, 429.000740.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [04:10<02:54,  2.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.874333285711009\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [04:15<04:03,  3.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336123888801654\n",
      "--- Training --- [threshold, AUC] =  [0.515, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [2.507001.3, 391.575455.3, 416.645465.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [04:31<02:16,  1.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8742670628330964\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [04:39<04:02,  3.52s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336121179254583\n",
      "--- Training --- [threshold, AUC] =  [0.527, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [2.506811.3, 379.795808.3, 404.863919.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [05:03<02:28,  2.47s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8742099821829196\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [05:10<03:39,  3.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335995829216376\n",
      "--- Training --- [threshold, AUC] =  [0.539, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [2.506647.3, 368.558519.3, 393.624994.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [05:30<01:54,  2.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.874160482603936\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [05:36<02:38,  3.24s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335945836220485\n",
      "--- Training --- [threshold, AUC] =  [0.55, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [2.506506.3, 357.834226.3, 382.899282.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [05:50<01:02,  1.57s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8741173000336561\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [05:54<01:33,  2.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335996497333259\n",
      "--- Training --- [threshold, AUC] =  [0.561, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [2.506382.3, 347.595131.3, 372.658948.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [06:08<00:47,  1.57s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8740794095726038\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [06:13<01:13,  2.53s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336045445483852\n",
      "--- Training --- [threshold, AUC] =  [0.572, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [2.506273.3, 337.814940.3, 362.877670.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [06:30<00:42,  2.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8740459775982666\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [06:35<00:55,  2.93s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336137083531287\n",
      "--- Training --- [threshold, AUC] =  [0.583, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [2.506177.3, 328.468807.3, 353.530579.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [06:51<00:17,  1.79s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8740163231756726\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [06:56<00:23,  2.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336192027317188\n",
      "--- Training --- [threshold, AUC] =  [0.593, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [2.506092.3, 319.533276.3, 344.594198.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [07:12<00:00,  2.16s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [0.65, 0.934]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                          | 0/200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! ACC_list [0.815]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [0.650, 0.892, 0.815, 0.938]\n",
      "initial loading beta [[ 0.71841337  0.1776504  -0.84321796]]\n",
      "*** rel_error_data train 48369.17447598039\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  0%|▍                                                                                 | 1/200 [00:04<15:54,  4.79s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9855093897182471\n",
      "--- Training --- [threshold, AUC] =  [0.507, 0.493]\n",
      "--- Iteration 0: Training loss --- [Data, Label, Total] = [138690.327587.3, 572.365218.3, 1387475.641086.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|████                                                                             | 10/200 [00:18<04:49,  1.52s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 558.5462434009263\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      "  6%|████▍                                                                            | 11/200 [00:22<06:59,  2.22s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9849957826766922\n",
      "--- Training --- [threshold, AUC] =  [0.533, 0.514]\n",
      "--- Iteration 10: Training loss --- [Data, Label, Total] = [1601.535737.3, 562.402334.3, 16577.759699.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|████████                                                                         | 20/200 [00:36<04:33,  1.52s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 7.326995143458892\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 10%|████████▌                                                                        | 21/200 [00:40<06:58,  2.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9800203998289894\n",
      "--- Training --- [threshold, AUC] =  [0.425, 0.612]\n",
      "--- Iteration 20: Training loss --- [Data, Label, Total] = [21.008904.3, 542.747776.3, 752.836819.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 15%|████████████▏                                                                    | 30/200 [00:54<04:27,  1.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.9545235196059059\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 16%|████████████▌                                                                    | 31/200 [00:59<06:33,  2.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9468559342332199\n",
      "--- Training --- [threshold, AUC] =  [0.44, 0.714]\n",
      "--- Iteration 30: Training loss --- [Data, Label, Total] = [2.736933.3, 522.749334.3, 550.118661.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|████████████████▏                                                                | 40/200 [01:14<04:25,  1.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8765975459544234\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 20%|████████████████▌                                                                | 41/200 [01:18<06:16,  2.36s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9348483121679937\n",
      "--- Training --- [threshold, AUC] =  [0.443, 0.804]\n",
      "--- Iteration 40: Training loss --- [Data, Label, Total] = [2.513493.3, 504.139236.3, 529.274170.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 25%|████████████████████▎                                                            | 50/200 [01:34<04:39,  1.86s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.875348293623546\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 26%|████████████████████▋                                                            | 51/200 [01:40<07:00,  2.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9342360041039987\n",
      "--- Training --- [threshold, AUC] =  [0.48, 0.879]\n",
      "--- Iteration 50: Training loss --- [Data, Label, Total] = [2.509911.3, 486.677025.3, 511.776139.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|████████████████████████▎                                                        | 60/200 [01:57<04:42,  2.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8750887146248562\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 30%|████████████████████████▋                                                        | 61/200 [02:02<06:49,  2.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9340346120427653\n",
      "--- Training --- [threshold, AUC] =  [0.489, 0.938]\n",
      "--- Iteration 60: Training loss --- [Data, Label, Total] = [2.509167.3, 470.213225.3, 495.304895.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|████████████████████████████▎                                                    | 70/200 [02:19<04:02,  1.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8748782672525719\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 36%|████████████████████████████▊                                                    | 71/200 [02:24<05:56,  2.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9338812491949817\n",
      "--- Training --- [threshold, AUC] =  [0.514, 0.977]\n",
      "--- Iteration 70: Training loss --- [Data, Label, Total] = [2.508564.3, 454.637702.3, 479.723339.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████████████████████████████████▍                                                | 80/200 [02:39<03:32,  1.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8747026611483183\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 40%|████████████████████████████████▊                                                | 81/200 [02:44<05:02,  2.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9337987986659005\n",
      "--- Training --- [threshold, AUC] =  [0.504, 0.995]\n",
      "--- Iteration 80: Training loss --- [Data, Label, Total] = [2.508060.3, 439.860007.3, 464.940609.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████████████████████████████████████▍                                            | 90/200 [03:01<03:41,  2.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8745570111791291\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 46%|████████████████████████████████████▊                                            | 91/200 [03:07<05:18,  2.92s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9337306574565765\n",
      "--- Training --- [threshold, AUC] =  [0.506, 1.0]\n",
      "--- Iteration 90: Training loss --- [Data, Label, Total] = [2.507643.3, 425.808642.3, 450.885067.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|████████████████████████████████████████                                        | 100/200 [03:24<03:27,  2.07s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8744361637122421\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 50%|████████████████████████████████████████▍                                       | 101/200 [03:30<04:56,  2.99s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933679729617849\n",
      "--- Training --- [threshold, AUC] =  [0.51, 1.0]\n",
      "--- Iteration 100: Training loss --- [Data, Label, Total] = [2.507296.3, 412.429752.3, 437.502713.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 55%|████████████████████████████████████████████                                    | 110/200 [03:48<03:08,  2.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8743354829032294\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 56%|████████████████████████████████████████████▍                                   | 111/200 [03:53<04:20,  2.93s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933655364653753\n",
      "--- Training --- [threshold, AUC] =  [0.522, 1.0]\n",
      "--- Iteration 110: Training loss --- [Data, Label, Total] = [2.507007.3, 399.681538.3, 424.751611.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|████████████████████████████████████████████████                                | 120/200 [04:10<02:35,  1.94s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8742510953773518\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 60%|████████████████████████████████████████████████▍                               | 121/200 [04:15<03:35,  2.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.933616653633977\n",
      "--- Training --- [threshold, AUC] =  [0.534, 1.0]\n",
      "--- Iteration 120: Training loss --- [Data, Label, Total] = [2.506765.3, 387.528484.3, 412.596138.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|████████████████████████████████████████████████████                            | 130/200 [04:30<01:56,  1.67s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8741798710245753\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 66%|████████████████████████████████████████████████████▍                           | 131/200 [04:34<02:44,  2.38s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9336061824209347\n",
      "--- Training --- [threshold, AUC] =  [0.546, 1.0]\n",
      "--- Iteration 130: Training loss --- [Data, Label, Total] = [2.506561.3, 375.938156.3, 401.003767.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|████████████████████████████████████████████████████████                        | 140/200 [04:52<01:52,  1.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.874119317728679\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 70%|████████████████████████████████████████████████████████▍                       | 141/200 [04:56<02:35,  2.64s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335879635591027\n",
      "--- Training --- [threshold, AUC] =  [0.557, 1.0]\n",
      "--- Iteration 140: Training loss --- [Data, Label, Total] = [2.506388.3, 364.880049.3, 389.943924.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 75%|████████████████████████████████████████████████████████████                    | 150/200 [05:12<01:32,  1.85s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8740674616753327\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 76%|████████████████████████████████████████████████████████████▍                   | 151/200 [05:17<02:10,  2.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335799210670745\n",
      "--- Training --- [threshold, AUC] =  [0.568, 1.0]\n",
      "--- Iteration 150: Training loss --- [Data, Label, Total] = [2.506239.3, 354.325303.3, 379.387691.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████████████████████████████████████████████████████████████                | 160/200 [05:32<01:07,  1.69s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8740227393382668\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 80%|████████████████████████████████████████████████████████████████▍               | 161/200 [05:38<01:53,  2.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335802175592132\n",
      "--- Training --- [threshold, AUC] =  [0.578, 1.0]\n",
      "--- Iteration 160: Training loss --- [Data, Label, Total] = [2.506111.3, 344.246607.3, 369.307713.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████████████████████████████████████████████████████████████████            | 170/200 [06:00<01:16,  2.54s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8739839082243472\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 86%|████████████████████████████████████████████████████████████████████▍           | 171/200 [06:05<01:33,  3.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335757336085694\n",
      "--- Training --- [threshold, AUC] =  [0.589, 1.0]\n",
      "--- Iteration 170: Training loss --- [Data, Label, Total] = [2.505999.3, 334.618145.3, 359.678137.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|████████████████████████████████████████████████████████████████████████        | 180/200 [06:23<00:40,  2.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8739499760641247\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 90%|████████████████████████████████████████████████████████████████████████▍       | 181/200 [06:29<01:04,  3.37s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335746843694822\n",
      "--- Training --- [threshold, AUC] =  [0.599, 1.0]\n",
      "--- Iteration 180: Training loss --- [Data, Label, Total] = [2.505902.3, 325.415533.3, 350.474553.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|████████████████████████████████████████████████████████████████████████████    | 190/200 [06:55<00:26,  2.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** rel_error_data train 0.8739201457267782\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ljw95\\OneDrive\\PycharmProjects\\LMF\\src\\SDL_SVP.py:329: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  time_error = np.append(time_error, np.array([[elapsed_time, error_data, error_label]]), axis=0)\n",
      "\r",
      " 96%|████████████████████████████████████████████████████████████████████████████▍   | 191/200 [07:00<00:30,  3.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~ rel_error_data train 0.9335655446032028\n",
      "--- Training --- [threshold, AUC] =  [0.608, 1.0]\n",
      "--- Iteration 190: Training loss --- [Data, Label, Total] = [2.505816.3, 316.615762.3, 341.673927.3]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [07:18<00:00,  2.19s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!! pred_type naive\n",
      "--- Training --- [threshold, AUC] =  [0.591, 0.943]\n",
      "!!! ACC_list [0.865]\n",
      "--- Validation (naive) --- [threshold, AUC, accuracy, rel_error_data] = [0.591, 0.936, 0.865, 0.938]\n"
     ]
    }
   ],
   "source": [
    "# SDL_SVP_filter\n",
    "\n",
    "results_dict_list = []\n",
    "r = 2*r0\n",
    "\n",
    "iteration1 = 200\n",
    "\n",
    "# Cross-validation\n",
    "xi_list = [0, 0.1, 1, 5, 10]\n",
    "beta = 1\n",
    "iter_avg = 2\n",
    "\n",
    "data_scale=10\n",
    "for j in range(len(xi_list)):\n",
    "    xi = xi_list[j]\n",
    "    for i in range(iter_avg):\n",
    "        SDL_SVP_class = SDL_SVP(X=[X_train/data_scale, Y_train],  # data, label\n",
    "                                X_test=[X_test/data_scale, Y_test],\n",
    "                                #X_auxiliary = None,\n",
    "                                n_components=r,  # =: r = number of columns in dictionary matrices W, W'\n",
    "                                # ini_loading=None,  # Initializatio for [W,W'], W1.shape = [d1, r], W2.shape = [d2, r]\n",
    "                                # ini_loading=[W_true, np.hstack((np.array([[0]]), Beta_true))],\n",
    "                                # ini_code = H_true,\n",
    "                                xi=xi,  # weight on label reconstruction error\n",
    "                                L1_reg = [0,0,0], # L1 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                                L2_reg = [0,0,0], # L2 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                                nonnegativity=[True,True,False], # nonnegativity constraints on code H, dictionary W[0], reg params W[1]\n",
    "                                full_dim=False) # if true, dictionary is Id with full dimension --> Pure regression\n",
    "\n",
    "        results_dict_new = SDL_SVP_class.fit(iter=iteration1, subsample_size=None,\n",
    "                                                beta = 0,\n",
    "                                                nu = 2,\n",
    "                                                search_radius_const=0.05,\n",
    "                                                update_nuance_param=False,\n",
    "                                                SDL_option = 'filter',\n",
    "                                                prediction_method_list = ['filter'],\n",
    "                                                fine_tune_beta = False,\n",
    "                                                if_compute_recons_error=True, if_validate=False)\n",
    "        results_dict_new.update({'method': 'SDL-conv-filt'})\n",
    "        results_dict_new.update({'beta': None})\n",
    "        results_dict_new.update({'Accuracy': results_dict_new.get('Accuracy (filter)')})\n",
    "        results_dict_new.update({'F_score': results_dict_new.get('F_score (filter)')})\n",
    "        results_dict_list.append(results_dict_new.copy())\n",
    "\n",
    "# SDL_SVP_feature\n",
    "data_scale=10\n",
    "prediction_method_list = ['naive']\n",
    "for j in range(len(xi_list)):\n",
    "    xi = xi_list[j]\n",
    "    for i in range(iter_avg):\n",
    "        data_scale=500\n",
    "        SDL_SVP_class = SDL_SVP(X=[X_train/data_scale, Y_train],  # data, label\n",
    "                                X_test=[X_test/data_scale, Y_test],\n",
    "                                #X_auxiliary = None,\n",
    "                                n_components=r,  # =: r = number of columns in dictionary matrices W, W'\n",
    "                                # ini_loading=None,  # Initializatio for [W,W'], W1.shape = [d1, r], W2.shape = [d2, r]\n",
    "                                # ini_loading=[W_true, np.hstack((np.array([[0]]), Beta_true))],\n",
    "                                # ini_code = H_true,\n",
    "                                xi=xi,  # weight on label reconstruction error\n",
    "                                L1_reg = [0,0,0], # L1 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                                L2_reg = [0,0,0], # L2 regularizer for code H, dictionary W[0], reg param W[1]\n",
    "                                nonnegativity=[True,True,False], # nonnegativity constraints on code H, dictionary W[0], reg params W[1]\n",
    "                                full_dim=False) # if true, dictionary is Id with full dimension --> Pure regression\n",
    "\n",
    "        results_dict_new = SDL_SVP_class.fit(iter=iteration1, subsample_size=None,\n",
    "                                            beta = 0,\n",
    "                                            nu = 2,\n",
    "                                            search_radius_const=0.01,\n",
    "                                            update_nuance_param=False,\n",
    "                                            SDL_option = 'feature',\n",
    "                                            #prediction_method_list = ['naive', 'exhaustive'],\n",
    "                                            prediction_method_list = prediction_method_list,\n",
    "                                            fine_tune_beta = False,\n",
    "                                            if_compute_recons_error=True, if_validate=False)\n",
    "\n",
    "        for pred_type in prediction_method_list:\n",
    "            results_dict_new.update({'method': 'SDL-conv-feat ({})'.format(str(pred_type))})\n",
    "            results_dict_new.update({'beta': None})\n",
    "            results_dict_new.update({'Accuracy': results_dict_new.get('Accuracy ({})'.format(str(pred_type)))})\n",
    "            results_dict_new.update({'F_score': results_dict_new.get('F_score ({})'.format(str(pred_type)))})\n",
    "            results_dict_list.append(results_dict_new.copy())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "804db707",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "569574c8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdd7a2f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "display_dictionary_list(W_true, grid_shape=[1,2], fig_size=[4,4])\n",
    "W = results_dict_new.get('loading')[0]\n",
    "W_beta = results_dict_new.get('loading')[1]\n",
    "display_dictionary_list2([W], grid_shape=[1,2], fig_size=[4,4], score_list = [W_beta[0][1:]]) # 2, 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "909ebc57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AUC</th>\n",
       "      <th>Opt_threshold</th>\n",
       "      <th>Accuracy</th>\n",
       "      <th>Sensitivity</th>\n",
       "      <th>Specificity</th>\n",
       "      <th>Precision</th>\n",
       "      <th>F_score</th>\n",
       "      <th>method</th>\n",
       "      <th>xi</th>\n",
       "      <th>Relative_reconstruction_loss (test)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0000</td>\n",
       "      <td>0.9599</td>\n",
       "      <td>0.80</td>\n",
       "      <td>0.6778</td>\n",
       "      <td>0.9000</td>\n",
       "      <td>0.8472</td>\n",
       "      <td>0.7531</td>\n",
       "      <td>LR</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.9605</td>\n",
       "      <td>0.4403</td>\n",
       "      <td>0.88</td>\n",
       "      <td>0.9111</td>\n",
       "      <td>0.8545</td>\n",
       "      <td>0.8367</td>\n",
       "      <td>0.8723</td>\n",
       "      <td>MF--&gt;LR</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.877223</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.9414</td>\n",
       "      <td>0.3782</td>\n",
       "      <td>0.85</td>\n",
       "      <td>0.8444</td>\n",
       "      <td>0.8545</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.8351</td>\n",
       "      <td>SDL-filt</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.880132</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      AUC  Opt_threshold  Accuracy  Sensitivity  Specificity  Precision  \\\n",
       "0  1.0000         0.9599      0.80       0.6778       0.9000     0.8472   \n",
       "1  0.9605         0.4403      0.88       0.9111       0.8545     0.8367   \n",
       "2  0.9414         0.3782      0.85       0.8444       0.8545        NaN   \n",
       "\n",
       "   F_score    method   xi  Relative_reconstruction_loss (test)  \n",
       "0   0.7531        LR  NaN                             1.000000  \n",
       "1   0.8723   MF-->LR  NaN                             0.877223  \n",
       "2   0.8351  SDL-filt  1.0                             0.880132  "
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "results_dict_list\n",
    "df = pd.DataFrame(data=d2)\n",
    "df\n",
    "#df.insert(0, 'method', df.pop('method'))\n",
    "#df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "ffc94408",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'xi': 1,\n",
       " 'L1_reg': [0, 0, 0],\n",
       " 'L2_reg': [0, 0, 0],\n",
       " 'nonnegativity': [True, True, False],\n",
       " 'n_components': 2,\n",
       " 'loading': [array([[0.00085889, 0.00659746],\n",
       "         [0.00223646, 0.        ],\n",
       "         [0.        , 0.00250078],\n",
       "         ...,\n",
       "         [0.00354757, 0.        ],\n",
       "         [0.00703508, 0.00137883],\n",
       "         [0.00221847, 0.00246036]]),\n",
       "  array([[-4,  3, -9]])],\n",
       " 'code': array([[1.34490029, 0.55681713, 1.00481794, ..., 1.13032865, 0.25430974,\n",
       "         0.79075944],\n",
       "        [0.72999442, 0.46440686, 0.70320146, ..., 0.80036893, 0.4844102 ,\n",
       "         1.06413968]]),\n",
       " 'time_error': array([], shape=(3, 0), dtype=float64),\n",
       " 'iter': 300,\n",
       " 'dict_update_freq': 1,\n",
       " 'Relative_reconstruction_loss (test)': 0.880131877591288,\n",
       " 'AUC': 0.9414,\n",
       " 'Training_threshold': 0.3782,\n",
       " 'Accuracy': 0.85,\n",
       " 'Misclassification': 0.15000000000000002,\n",
       " 'Sensitivity': 0.8444,\n",
       " 'Specificity': 0.8545,\n",
       " 'F_score': 0.8351,\n",
       " 'method': 'SDL-filt'}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_dict_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e8cfc4a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b077a20a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_openml\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import trange\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2183398e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def list2onehot(y, list_classes):\n",
    "    \n",
    "    \"\"\"\n",
    "    y = list of class lables of length n\n",
    "    output = n x k array, i th row = one-hot encoding of y[i] (e.g., [0,0,1,0,0])\n",
    "    \"\"\"\n",
    "    \n",
    "    Y = np.zeros(shape = [len(y), len(list_classes)], dtype = int)\n",
    "    for i in np.arange(Y.shape[0]):\n",
    "        for j in np.arange(len(list_classes)):\n",
    "            if y[i] == list_classes[j]:\n",
    "                Y[i,j] = 1\n",
    "    return Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5c3e3262",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_MNIST(list_digits = ['0','1', '2'], full_MNIST = None, padding_thickness = 0, sample_size = None):\n",
    "    \n",
    "    # get train and test set from MNIST of given digits\n",
    "    # e.g., list_digits = ['0', '1', '2']\n",
    "    # pad each 28 x 28 image with zeros so that it has now \"padding_thickness\" more rows and columns\n",
    "    # The original image is superimposed at a uniformly chosen location\n",
    "    if full_MNIST is not None:\n",
    "        X, y = full_MNIST\n",
    "    else:\n",
    "        X, y = fetch_openml('mnist_784', version = 1, return_X_y = True)\n",
    "        X = X / 255.\n",
    "        \n",
    "    Y = list2onehot(y.tolist(), list_digits)\n",
    "\n",
    "    idx = [i for i in np.arange(len(y)) if y[i] in list_digits] # list of indices where the label y is in list_digits\n",
    "    if sample_size is not None:\n",
    "        idx = np.random.choice(idx, sample_size, replace = False)\n",
    "\n",
    "    X01 = X[idx,:]\n",
    "    y01 = Y[idx,:]\n",
    "\n",
    "    X_train = []\n",
    "    y_train = []\n",
    "    for i in trange(X01.shape[0]):\n",
    "        # for each example i, make it into train set with probabiliy 0.8 and into test set otherwise\n",
    "        # U = np.random.rand() # Uniform([0,1]) variable\n",
    "        img_padded = random_padding(X01[i,:].reshape(28,28), thickness = padding_thickness)\n",
    "        img_padded_vec = img_padded.reshape(1,-1)\n",
    "        X_train.append(img_padded_vec[0,:].copy())\n",
    "        y_train.append(y01[i,:].copy())\n",
    "\n",
    "    X_train = np.asarray(X_train).T\n",
    "    y_train = np.asarray(y_train).T\n",
    "    \n",
    "    return X_train,  y_train\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7d4b04eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Data Generation (Beat separate NMF + logistic regression by joint optimization)\n",
    "\n",
    "def sim_data_gen_MNIST(r = 2, n = 1000,\n",
    "                       digits_X = ['2', '7'],\n",
    "                       digits_Y = ['1', '4'],\n",
    "                       full_MNIST = None,\n",
    "                       noise_std = 0,\n",
    "                       random_seed = 1,\n",
    "                       padding_thickness = 0):\n",
    "    \n",
    "    np.random.seed(random_seed)\n",
    "\n",
    "    W_true, y_train = sample_MNIST(list_digits = digits_X,\n",
    "                                   sample_size = r,\n",
    "                                   padding_thickness = padding_thickness,\n",
    "                                   full_MNIST=full_MNIST)\n",
    "    p = W_true.shape[0]\n",
    "\n",
    "    W_true_Y, y_train = sample_MNIST(list_digits=digits_Y,\n",
    "                                     sample_size=r,\n",
    "                                     padding_thickness=padding_thickness,\n",
    "                                     full_MNIST=full_MNIST)\n",
    "    Beta_true = (2*y_train[0,:]-1) # 1 if the first digit, -1 otherwise\n",
    "    Beta_true = Beta_true[np.newaxis, :]\n",
    "    print('Beta_true', Beta_true)\n",
    "\n",
    "    #print('y_train \\n', y_train)\n",
    "    Sigma = ((noise_std)**2) * np.eye(p)\n",
    "    Noise = np.random.multivariate_normal(np.zeros(p),  Sigma, n).T\n",
    "\n",
    "    H_true = np.random.rand(r, n)\n",
    "    X = W_true @ H_true\n",
    "\n",
    "    Y = generate_Y(W_true_Y.T @ X, Beta_true, n) # true labels\n",
    "\n",
    "    X += Noise # corrupt true signal\n",
    "\n",
    "    X_train, X_test, Y_train, Y_test = train_test_split(X.T, Y.T, test_size=0.2)\n",
    "    X_train, X_test = X_train.T, X_test.T\n",
    "    Y_train, Y_test = Y_train.T, Y_test.T\n",
    "\n",
    "    print('X_train.shape', X_train.shape)\n",
    "    print('Y_train.shape', Y_train.shape)\n",
    "    print('X_test.shape', X_test.shape)\n",
    "    print('Y_test.shape', Y_test.shape)\n",
    "\n",
    "    return X_train, X_test, Y_train, Y_test, W_true, H_true, X, Y, Beta_true\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45f96597",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8 (jleeenv)",
   "language": "python",
   "name": "jleeenv"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}