{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b9b5254c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-12-08 12:31:20.847911: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-12-08 12:31:20.970203: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2022-12-08 12:31:20.970223: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n",
      "2022-12-08 12:31:21.000070: E tensorflow/stream_executor/cuda/cuda_blas.cc:2981] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2022-12-08 12:31:21.657584: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
      "2022-12-08 12:31:21.657651: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
      "2022-12-08 12:31:21.657661: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n"
     ]
    }
   ],
   "source": [
    "from library.analysis import loadDataset, testSets\n",
    "from library.generators.XConvGeN import XConvGeN\n",
    "from library.timing import timing\n",
    "from fdc.fdc import FDC\n",
    "#from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6bfec0a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Load 'folding_abalone_17_vs_7_8_9_10'\n",
      "from pickle file\n",
      "Data loaded.\n"
     ]
    }
   ],
   "source": [
    "data = loadDataset(testSets[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6d686da5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2338, 2280, 58)\n"
     ]
    }
   ],
   "source": [
    "print((len(data.data), len(data.data0), len(data.data1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9e3e3806",
   "metadata": {},
   "outputs": [],
   "source": [
    "fdc = FDC()\n",
    "fdc.nom_list = [0]\n",
    "fdc.cont_list = list(range(data.data0.shape[1]))[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "01d71d6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "gen = XConvGeN(data.data0.shape[1], neb=5, fdc=fdc, debug=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ad01be2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-12-08 12:31:28.412341: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory\n",
      "2022-12-08 12:31:28.412369: W tensorflow/stream_executor/cuda/cuda_driver.cc:263] failed call to cuInit: UNKNOWN ERROR (303)\n",
      "2022-12-08 12:31:28.412397: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (f689f5a8be0b): /proc/driver/nvidia/version does not exist\n",
      "2022-12-08 12:31:28.412565: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "neb=5, gen=5\n",
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)           [(None, 5, 8)]       0           []                               \n",
      "                                                                                                  \n",
      " UnsharpenInput (Conv1D)        (None, 3, 8)         200         ['input_1[0][0]']                \n",
      "                                                                                                  \n",
      " InputMatrixToVector (Flatten)  (None, 24)           0           ['UnsharpenInput[0][0]']         \n",
      "                                                                                                  \n",
      " P3_dense (Dense)               (None, 15)           375         ['InputMatrixToVector[0][0]']    \n",
      "                                                                                                  \n",
      " P5_dense (Dense)               (None, 10)           250         ['InputMatrixToVector[0][0]']    \n",
      "                                                                                                  \n",
      " P3_reshape (Reshape)           (None, 5, 3)         0           ['P3_dense[0][0]']               \n",
      "                                                                                                  \n",
      " P5_reshape (Reshape)           (None, 5, 2)         0           ['P5_dense[0][0]']               \n",
      "                                                                                                  \n",
      " tf.math.reduce_sum (TFOpLambda  (None, 3)           0           ['P3_reshape[0][0]']             \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.reduce_sum_1 (TFOpLamb  (None, 2)           0           ['P5_reshape[0][0]']             \n",
      " da)                                                                                              \n",
      "                                                                                                  \n",
      " P3_make_non_zero (Lambda)      (None, 3)            0           ['tf.math.reduce_sum[0][0]']     \n",
      "                                                                                                  \n",
      " P5_make_non_zero (Lambda)      (None, 2)            0           ['tf.math.reduce_sum_1[0][0]']   \n",
      "                                                                                                  \n",
      " tf.math.reciprocal (TFOpLambda  (None, 3)           0           ['P3_make_non_zero[0][0]']       \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " tf.math.reciprocal_1 (TFOpLamb  (None, 2)           0           ['P5_make_non_zero[0][0]']       \n",
      " da)                                                                                              \n",
      "                                                                                                  \n",
      " P3_normalize (Multiply)        (None, 5, 3)         0           ['tf.math.reciprocal[0][0]',     \n",
      "                                                                  'P3_reshape[0][0]']             \n",
      "                                                                                                  \n",
      " P5_normalize (Multiply)        (None, 5, 2)         0           ['tf.math.reciprocal_1[0][0]',   \n",
      "                                                                  'P5_reshape[0][0]']             \n",
      "                                                                                                  \n",
      " tf.__operators__.getitem (Slic  (5, 3)              0           ['P3_normalize[0][0]']           \n",
      " ingOpLambda)                                                                                     \n",
      "                                                                                                  \n",
      " tf.__operators__.getitem_1 (Sl  (5, 2)              0           ['P5_normalize[0][0]']           \n",
      " icingOpLambda)                                                                                   \n",
      "                                                                                                  \n",
      " tf.compat.v1.transpose (TFOpLa  (3, 5)              0           ['tf.__operators__.getitem[0][0]'\n",
      " mbda)                                                           ]                                \n",
      "                                                                                                  \n",
      " tf.compat.v1.transpose_1 (TFOp  (2, 5)              0           ['tf.__operators__.getitem_1[0][0\n",
      " Lambda)                                                         ]']                              \n",
      "                                                                                                  \n",
      " tf.linalg.matmul (TFOpLambda)  (None, 3, 8)         0           ['tf.compat.v1.transpose[0][0]', \n",
      "                                                                  'input_1[0][0]']                \n",
      "                                                                                                  \n",
      " tf.linalg.matmul_1 (TFOpLambda  (None, 2, 8)        0           ['tf.compat.v1.transpose_1[0][0]'\n",
      " )                                                               , 'input_1[0][0]']               \n",
      "                                                                                                  \n",
      " tf.concat (TFOpLambda)         (None, 5, 8)         0           ['tf.linalg.matmul[0][0]',       \n",
      "                                                                  'tf.linalg.matmul_1[0][0]']     \n",
      "                                                                                                  \n",
      " RandomNoise (Sequential)       (None, 40)           3280        ['tf.concat[0][0]']              \n",
      "                                                                                                  \n",
      " ReshapeNoise (Reshape)         (None, 5, 8)         0           ['RandomNoise[0][0]']            \n",
      "                                                                                                  \n",
      " AddNoise (Add)                 (None, 5, 8)         0           ['tf.concat[0][0]',              \n",
      "                                                                  'ReshapeNoise[0][0]']           \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 4,105\n",
      "Trainable params: 4,105\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n",
      "None\n",
      "\n",
      "\n",
      "Model: \"model_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_3 (InputLayer)        [(None, 8)]               0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 250)               2250      \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 125)               31375     \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 75)                9450      \n",
      "                                                                 \n",
      " dense_4 (Dense)             (None, 2)                 152       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 43,227\n",
      "Trainable params: 0\n",
      "Non-trainable params: 43,227\n",
      "_________________________________________________________________\n",
      "None\n",
      "\n",
      "\n",
      "Model: \"model_2\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_4 (InputLayer)           [(None, 2, 5, 8)]    0           []                               \n",
      "                                                                                                  \n",
      " SplitForGen (Lambda)           (None, 5, 8)         0           ['input_4[0][0]']                \n",
      "                                                                                                  \n",
      " model (Functional)             (None, 5, 8)         4105        ['SplitForGen[0][0]']            \n",
      "                                                                                                  \n",
      " SplitForDisc (Lambda)          (None, 5, 8)         0           ['input_4[0][0]']                \n",
      "                                                                                                  \n",
      " tf.reshape_1 (TFOpLambda)      (None, 8)            0           ['model[0][0]']                  \n",
      "                                                                                                  \n",
      " tf.reshape (TFOpLambda)        (None, 8)            0           ['SplitForDisc[0][0]']           \n",
      "                                                                                                  \n",
      " model_1 (Functional)           (None, 2)            43227       ['tf.reshape_1[0][0]',           \n",
      "                                                                  'tf.reshape[0][0]']             \n",
      "                                                                                                  \n",
      " tf.reshape_2 (TFOpLambda)      (None, 5, 2)         0           ['model_1[0][0]']                \n",
      "                                                                                                  \n",
      " tf.reshape_3 (TFOpLambda)      (None, 5, 2)         0           ['model_1[1][0]']                \n",
      "                                                                                                  \n",
      " tf.concat_1 (TFOpLambda)       (None, 10, 2)        0           ['tf.reshape_2[0][0]',           \n",
      "                                                                  'tf.reshape_3[0][0]']           \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 47,332\n",
      "Trainable params: 4,105\n",
      "Non-trainable params: 43,227\n",
      "__________________________________________________________________________________________________\n",
      "None\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "gen.reset(data.data1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6b04627-0cac-4e5a-9b97-4c2eadb047c2",
   "metadata": {},
   "source": [
    "def repeat(x, times):\n",
    "    return [x for _i in range(times)]\n",
    "\n",
    "def create01Labels(totalSize, sizeFirstHalf):\n",
    "    labels = repeat(np.array([1,0]), sizeFirstHalf)\n",
    "    labels.extend(repeat(np.array([0,1]), totalSize - sizeFirstHalf))\n",
    "    return np.array(labels)\n",
    "\n",
    "\n",
    "\n",
    "def _rough_learning(self, data, discTrainCount, batchSize=32):\n",
    "    generator = self.conv_sample_generator\n",
    "    discriminator = self.maj_min_discriminator\n",
    "    convGeN = self.cg\n",
    "    loss_history = [] ## this is for stroring the loss for every run\n",
    "    minSetSize = len(data)\n",
    "\n",
    "    ## Create labels for one neighborhood training.\n",
    "    nLabels = 2 * self.gen\n",
    "    labels = np.array(create01Labels(nLabels, self.gen))\n",
    "    labelsGeN = np.array([labels])\n",
    "\n",
    "    def getNeighborhoods():\n",
    "        for index in range(self.minSetSize):\n",
    "            yield indexToBatches(index)\n",
    "\n",
    "    def indexToBatches(min_idx):\n",
    "        self.timing[\"NBH\"].start()\n",
    "        ## generate minority neighbourhood batch for every minority class sampls by index\n",
    "        min_batch_indices = self.nmbMin.neighbourhoodOfItem(min_idx)\n",
    "        min_batch = self.nmbMin.getPointsFromIndices(min_batch_indices)\n",
    "\n",
    "        ## generate random proximal majority batch\n",
    "        maj_batch = self._BMB(min_batch_indices)\n",
    "        self.timing[\"NBH\"].stop()\n",
    "\n",
    "        return (min_batch, maj_batch)\n",
    "\n",
    "    def unbatch(rows):\n",
    "        def fn():\n",
    "            for row in rows:\n",
    "                for part in row:\n",
    "                    for x in part:\n",
    "                        yield x\n",
    "        return fn\n",
    "\n",
    "    def genLabels():\n",
    "        for min_idx in range(minSetSize):\n",
    "            for x in labels:\n",
    "                yield x\n",
    "\n",
    "    padd = np.zeros((self.gen - self.neb, self.n_feat))\n",
    "    discTrainCount = 1 + max(0, discTrainCount)    \n",
    "\n",
    "    ### LOOP\n",
    "    \n",
    "    ## Training of the discriminator.\n",
    "    #\n",
    "    # Get all neighborhoods and synthetic points as data stream.\n",
    "    nbhPairs = tf.data.Dataset.from_generator(getNeighborhoods, output_types=tf.float32).repeat().take(discTrainCount * self.minSetSize)\n",
    "    nbhMin = nbhPairs.map(lambda x: x[0])\n",
    "    batchMaj = nbhPairs.map(lambda x: x[1])\n",
    "\n",
    "    fnCt = self.correct_feature_types()\n",
    "    synth_batch = self.conv_sample_generator.predict(nbhMin.batch(32), verbose=0)\n",
    "    pairMinMaj = tf.data.Dataset.zip(\n",
    "        ( nbhMin\n",
    "        , tf.data.Dataset.from_tensor_slices(synth_batch)\n",
    "        , batchMaj\n",
    "        )).map(lambda x, y, z: [fnCt(x,y), z])\n",
    "\n",
    "    a = tf.data.Dataset.from_generator(unbatch(pairMinMaj), output_types=tf.float32)\n",
    "\n",
    "    # Get all labels as data stream.\n",
    "    b = tf.data.Dataset.from_tensor_slices(labels).repeat()\n",
    "\n",
    "    # Zip data and matching labels together for training. \n",
    "    samples = tf.data.Dataset.zip((a, b)).batch(batchSize * 2 * self.gen)\n",
    "\n",
    "    # train the discriminator with the concatenated samples and the one-hot encoded labels\n",
    "    self.timing[\"Fit\"].start()\n",
    "    discriminator.trainable = True\n",
    "    discriminator.fit(x=samples, verbose=0)\n",
    "    discriminator.trainable = False\n",
    "    self.timing[\"Fit\"].stop()\n",
    "\n",
    "    ## use the complete network to make the generator learn on the decisions\n",
    "    ## made by the previous discriminator training\n",
    "    #\n",
    "    # Get all neighborhoods as data stream.\n",
    "    a = (tf.data.Dataset\n",
    "       .from_generator(getNeighborhoods, output_types=tf.float32)\n",
    "       .map(lambda x: [[tf.concat([x[0], padd], axis=0), x[1]]]))\n",
    "\n",
    "    # Get all labels as data stream.\n",
    "    b = tf.data.Dataset.from_tensor_slices(labelsGeN).repeat()\n",
    "\n",
    "    # Zip data and matching labels together for training. \n",
    "    samples = tf.data.Dataset.zip((a, b)).batch(batchSize)\n",
    "\n",
    "    # Train with the data stream. Store the loss for later usage.\n",
    "    gen_loss_history = convGeN.fit(samples, verbose=0, batch_size=batchSize)\n",
    "    loss_history.append(gen_loss_history.history['loss'])\n",
    "\n",
    "        \n",
    "_rough_learning(gen, data.data1, 3, 32)\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4698522c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FDC.normalize (init): 0.00002 / 0.000s\n",
      "|data| = (58, 8)\n",
      "umap with metric 'euclidean'\n",
      "|part| = (58, 7)\n",
      "|emb_A| = (58, 2)\n",
      "|emb_A| = (58, 2)\n",
      "FDC.normalize (clustering CONT): 6.67152 / 6.672s\n",
      "FDC.normalize (clustering ORD): 0.00002 / 6.672s\n",
      "umap with metric 'hamming'\n",
      "|part| = (58, 1)\n",
      "|emb_A| = (58, 1)\n",
      "|emb_A| = (58, 1)\n",
      "FDC.normalize (clustering NOM): 1.36434 / 8.036s\n",
      "FDC.normalize (concat): 0.00004 / 8.036s\n",
      "|fdc| = (58, 3)\n",
      "FDC.normalize (total): 0.00002 / 8.036s\n",
      "|N| = (58, 3)\n",
      "|D| = (58, 8)\n",
      "[==========] [======    ] [======    ]\r"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train: #1 56.1896s\n"
     ]
    }
   ],
   "source": [
    "t = timing(\"train\")\n",
    "t.start()\n",
    "gen.train(data.data1)\n",
    "t.stop()\n",
    "print(t)\n",
    "\n",
    "# train: #1 225.9655s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cda17654",
   "metadata": {},
   "outputs": [],
   "source": [
    "syntheticPoints = gen.generateData(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "41853bd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        , -0.11512733, -0.34728152, -1.8602949 ,  1.4430457 ,\n",
       "         0.4695732 , -0.785573  ,  0.7366079 ],\n",
       "       [ 1.        ,  1.7078505 , -0.5532761 , -1.570407  ,  1.4081728 ,\n",
       "        -0.12439936,  0.6630753 , -0.79970264],\n",
       "       [ 1.        ,  0.37536496,  0.11935598,  0.3527735 ,  0.81573707,\n",
       "         0.91100633, -0.50719476, -0.84459543],\n",
       "       [ 1.        ,  0.5336523 , -1.3042464 ,  0.16190486,  1.6334012 ,\n",
       "         3.285755  , -0.4888891 ,  2.6727762 ],\n",
       "       [ 2.        ,  1.2943587 , -1.1841304 ,  1.930803  ,  0.7843776 ,\n",
       "        -0.23363888,  0.81241167,  0.6573316 ],\n",
       "       [ 0.        ,  1.3406477 ,  0.34173208, -1.0710777 ,  2.1775146 ,\n",
       "         0.03189439,  0.36828828,  3.5259023 ],\n",
       "       [ 0.        ,  1.9894404 , -0.81197995,  0.15882066,  2.123022  ,\n",
       "        -0.21708447,  1.5266575 , -0.84448785],\n",
       "       [ 0.        ,  0.4987496 ,  0.37130105,  1.3313326 ,  0.11073577,\n",
       "         2.3298285 , -1.0263131 ,  1.1622958 ],\n",
       "       [ 2.        ,  0.6656306 , -0.9874371 ,  0.42957813,  1.8524462 ,\n",
       "         1.5630099 ,  0.3685266 , -0.17899394],\n",
       "       [ 0.        , -0.07121497,  0.55396426,  0.6976439 ,  2.9024813 ,\n",
       "         0.94756806, -0.05772188,  1.1774163 ]], dtype=float32)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "syntheticPoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "da5ebdb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.    , 0.565 , 0.425 , 0.16  , 0.9425, 0.3495, 0.2185, 0.275 ],\n",
       "       [0.    , 0.495 , 0.4   , 0.155 , 0.6445, 0.242 , 0.1325, 0.205 ],\n",
       "       [2.    , 0.54  , 0.435 , 0.18  , 0.996 , 0.3835, 0.226 , 0.325 ],\n",
       "       [0.    , 0.69  , 0.56  , 0.215 , 1.719 , 0.68  , 0.299 , 0.47  ],\n",
       "       [0.    , 0.68  , 0.55  , 0.21  , 1.7445, 0.5975, 0.305 , 0.625 ]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.data1[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4043256c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.550746540296984\n",
      "2.6627853494520455\n",
      "1.4586633879592674\n",
      "3.8243275775928702\n",
      "2.646804313974124\n",
      "3.1022753279642634\n",
      "2.702869128876532\n",
      "2.8217694004675185\n",
      "1.8797246943940664\n",
      "1.315439567520313\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "for p in syntheticPoints:\n",
    "    print(min([math.sqrt(sum(y*y)) for y in (data.data1 - p) ]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3bcc8cb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - 0s 3ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.35528004, 0.5160366, 0.42069311748290883)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = gen.predictReal(data.data1)\n",
    "(min(v), max(v), sum(v) / len(v))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}