0116_1854.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "1uPeqW35oBR4y8YXCA9T3ZyG6gOU1Kl-k",
      "authorship_tag": "ABX9TyN4GlbccbBCXx/p2wxdd2/B",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/seiji0906/machine/blob/main/0116_1854.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# # 使うデータ\n",
        "# import cv2\n",
        "# from google.colab.patches import cv2_imshow\n",
        "\n",
        "# path = '/content/drive/MyDrive/Colab Notebooks/相転移/'\n",
        "\n",
        "# files = []\n",
        "\n",
        "# files.append(path + \"beta=0.06938775510204082_step=99.jpg\")\n",
        "# files.append(path + \"beta=0.3989795918367347_step=99.jpg\")\n",
        "# files.append(path + \"beta=0.6510204081632653_step=99.jpg\")\n",
        "\n",
        "# for num, file in enumerate(files):\n",
        "#   img = cv2.imread(file)\n",
        "#   img = cv2.resize(img,dsize=(180,180))\n",
        "#   print(\"image\" + str(num))\n",
        "#   cv2_imshow(img)"
      ],
      "metadata": {
        "id": "SbF6s9YLlUxy"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import cv2\n",
        "import glob as glob\n",
        "from keras.utils import np_utils\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "path = '/content/drive/MyDrive/Colab Notebooks'\n",
        "\n",
        "\n",
        "folder = ['常磁性', '強磁性2']\n",
        "\n",
        "X_image = []\n",
        "Y_label = []\n",
        "\n",
        "for label,class_name in enumerate(folder):\n",
        "  files = glob.glob(path + \"/\" +  class_name + \"/*.jpg\")\n",
        "  for file in files:\n",
        "    img = cv2.imread(file)\n",
        "    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
        "    img = cv2.resize(img,dsize=(180,180))\n",
        "    X_image.append(img)\n",
        "    Y_label.append(label)\n",
        "\n",
        "X_image = np.array(X_image)\n",
        "X_image = X_image.astype('float32')\n",
        "X_image /= 255.0\n",
        "\n",
        "Y_label = np.array(Y_label)\n",
        "Y_label = np_utils.to_categorical(Y_label, len(folder))\n",
        "Y_label[:5]\n",
        "\n",
        "\n",
        "\n",
        "X_train,X_test,Y_train,Y_test = train_test_split(X_image,Y_label,test_size=0.2, shuffle=True)\n",
        "\n",
        "print(len(X_train))\n",
        "print(len(X_test))"
      ],
      "metadata": {
        "id": "JHb-NVoCX89o",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d655348d-7a7c-4705-f430-68cfcaabc2ee"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3576\n",
            "894\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3576+894\n",
        "print(1/0.05)\n",
        "print(1/0.4)\n",
        "print(1/0.5)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xPEstVV880be",
        "outputId": "16da0b13-322d-423f-88da-abcc52c79665"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20.0\n",
            "2.5\n",
            "2.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.python import metrics\n",
        "from warnings import filters\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "\n",
        "inputs = keras.Input(shape=(180, 180, 1))\n",
        "\n",
        "x = layers.Rescaling(1./255)(inputs)\n",
        "x = layers.Conv2D(filters=32, kernel_size=3, activation=\"relu\")(x)\n",
        "x = layers.MaxPooling2D(pool_size=2)(x)\n",
        "x = layers.Conv2D(filters=64, kernel_size=3, activation=\"relu\")(x)\n",
        "x = layers.MaxPooling2D(pool_size=2)(x)\n",
        "x = layers.Conv2D(filters=128, kernel_size=3, activation=\"relu\")(x)\n",
        "x = layers.MaxPooling2D(pool_size=2)(x)\n",
        "x = layers.Conv2D(filters=256, kernel_size=3, activation=\"relu\")(x)\n",
        "x = layers.MaxPooling2D(pool_size=2)(x)\n",
        "x = layers.Flatten()(x)\n",
        "outputs = layers.Dense(2, activation=\"sigmoid\")(x)\n",
        "model = keras.Model(inputs=inputs, outputs=outputs)\n",
        "\n",
        "model.summary()\n",
        "\n",
        "model.compile(loss=\"binary_crossentropy\",\n",
        "              optimizer=\"rmsprop\",\n",
        "              metrics=[\"accuracy\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hvi_yd58aYow",
        "outputId": "9fdd4dc1-b796-40ba-ef84-357188bbfbf4"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, 180, 180, 1)]     0         \n",
            "                                                                 \n",
            " rescaling (Rescaling)       (None, 180, 180, 1)       0         \n",
            "                                                                 \n",
            " conv2d (Conv2D)             (None, 178, 178, 32)      320       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 89, 89, 32)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 87, 87, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 43, 43, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 41, 41, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 20, 20, 128)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 18, 18, 256)       295168    \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 9, 9, 256)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 20736)             0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 2)                 41474     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 429,314\n",
            "Trainable params: 429,314\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 学習データで学習\n",
        "model.fit(X_train, Y_train, epochs=10, batch_size=32)\n",
        "\n",
        "#テストデータで精度確認\n",
        "score = model.evaluate(X_test, Y_test, batch_size=32)\n",
        "\n",
        "print(score)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j1gLsWHXYIXC",
        "outputId": "2d51d7f5-6d30-4b5d-c24b-24243d4304b0"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "112/112 [==============================] - 244s 2s/step - loss: 0.6797 - accuracy: 0.5724\n",
            "Epoch 2/10\n",
            "112/112 [==============================] - 242s 2s/step - loss: 0.6678 - accuracy: 0.5663\n",
            "Epoch 3/10\n",
            "112/112 [==============================] - 240s 2s/step - loss: 0.4795 - accuracy: 0.7900\n",
            "Epoch 4/10\n",
            "112/112 [==============================] - 240s 2s/step - loss: 0.3014 - accuracy: 0.8753\n",
            "Epoch 5/10\n",
            "112/112 [==============================] - 242s 2s/step - loss: 0.2081 - accuracy: 0.9676\n",
            "Epoch 6/10\n",
            "112/112 [==============================] - 240s 2s/step - loss: 0.1003 - accuracy: 0.9841\n",
            "Epoch 7/10\n",
            "112/112 [==============================] - 240s 2s/step - loss: 0.2881 - accuracy: 0.9256\n",
            "Epoch 8/10\n",
            "112/112 [==============================] - 240s 2s/step - loss: 0.1372 - accuracy: 0.9645\n",
            "Epoch 9/10\n",
            "112/112 [==============================] - 242s 2s/step - loss: 0.1510 - accuracy: 0.9541\n",
            "Epoch 10/10\n",
            "112/112 [==============================] - 239s 2s/step - loss: 0.0372 - accuracy: 0.9947\n",
            "28/28 [==============================] - 16s 579ms/step - loss: 2.1465e-04 - accuracy: 1.0000\n",
            "[0.00021465045574586838, 1.0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "path = '/content/drive/MyDrive/Colab Notebooks'\n",
        "\n",
        "\n",
        "folder = ['相転移10']\n",
        "\n",
        "X_image = []\n",
        "\n",
        "for label,class_name in enumerate(folder):\n",
        "  files = glob.glob(path + \"/\" +  class_name + \"/*.jpg\")\n",
        "  for file in files:\n",
        "    img = cv2.imread(file)\n",
        "    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
        "    img = cv2.resize(img,dsize=(180,180))\n",
        "    X_image.append(img)\n",
        "\n",
        "X_image = np.array(X_image)\n",
        "X_image = X_image.astype('float32')\n",
        "X_image /= 255.0\n",
        "\n",
        "print(len(X_image))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JDWQJmhgYN-m",
        "outputId": "6fb969d8-a4ac-437a-acda-69ac77eeccdb"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.predict(X_image)\n",
        "# plt.plot(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jg4NhT8zYRUr",
        "outputId": "a4a29de4-7994-440e-8fd3-4bb438abf81c"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "63/63 [==============================] - 36s 569ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# print(history)\n",
        "import matplotlib.pyplot as plt\n",
        "from statistics import mean\n",
        "\n",
        "# print(history)\n",
        "plt.plot(history)\n",
        "\n",
        "# print(history)\n",
        "\n",
        "predict = []\n",
        "\n",
        "\n",
        "\n",
        "# for i in range():\n",
        "\n",
        "\n",
        "for i in range(len(history)):\n",
        "  predict.append(history[i][1])\n",
        "\n",
        "# print(predict)\n",
        "\n",
        "# print(mean(predict[0:9]))\n",
        "\n",
        "# result = []\n",
        "\n",
        "# for i in range(50):\n",
        "#   result.append(mean(predict[10*i:10*i+9]))\n",
        "\n",
        "\n",
        "\n",
        "# print(result)\n",
        "\n",
        "\n",
        "\n",
        "# betas=np.linspace(0.2, 0.6, 50).tolist()\n",
        "\n",
        "\n",
        "# fig, ax = plt.subplots()\n",
        "# ax.errorbar(betas, predict, capsize=4, marker='.')\n",
        "# plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "TYzBCBwv0dKZ",
        "outputId": "dce8f5b5-bd73-4e53-ccd3-bbe61c572c8f"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# history\n",
        "print(len(history))\n",
        "\n",
        "# predictを20要素ずつ平均を取る"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5Pkm_8hgY0id",
        "outputId": "2479b7a3-140e-44c4-b576-6b2469f0ce71"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# for i in range(len(predict)):\n",
        "#   print(predict[i])\n",
        "from statistics import mean\n",
        "\n",
        "result = []\n",
        "\n",
        "p = 0\n",
        "\n",
        "for i in range(100):\n",
        "  for j in range(20):\n",
        "    # print(i*20 + j)\n",
        "    # mean(predict[])\n",
        "    p += predict[i*20+j]\n",
        "  result.append(p / 20)\n",
        "  p = 0\n",
        "\n",
        "\n",
        "# print(result)\n",
        "\n",
        "# plt.plot(result)\n",
        "\n",
        "betas=np.linspace(0.4, 0.5, 100).tolist()\n",
        "\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.title(\"ferromagnetism probability\")\n",
        "plt.xlabel('beta (1/T)')\n",
        "plt.ylabel('probability')\n",
        "ax.errorbar(betas, result, capsize=4, marker='.', linestyle=\"\")\n",
        "# mpl.rcParams['lines.linestyle'] = ''\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "OquT3WC7aEZm",
        "outputId": "3694d72a-f0c0-421f-e70b-ee3ab5f4031e"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5gdVZ3u8e+bhACBKAF0uCQhKJcR0OHSXDw6IyhgUIERUK4qCqIjHPXMeFCPmonoHHGOo6MSRwMiCCggKEYMoswJoA5x0g2IJAzaBEKaiwQICoLk0r/5o2qHys6+9t61L13v53n6SV1W1V5rd2f9qtZatUoRgZmZFdeEbmfAzMy6y4HAzKzgHAjMzArOgcDMrOAcCMzMCs6BwMys4BwIDABJe0q6U9LTkj7Y7fz0MklLJR3a7Xw0Q9IDkg4f47E3Szqzyr6Zkp6RNLE8raRTJf107Lm2TpnU7QxYzzgXWBQR+3Y7I71E0iXASER8srQtIvbuXo56S0Q8CGxdZd8VwBWldUkB7B4Rwx3KnjXIdwRWsguwdCwHStrkgqLSNsuHv2trlQOBIen/A4cBF6S3+XtI2lzSFyQ9KOn3kr4uacs0/aGSRiR9VNKjwLckzZV0jaTLJf0ROF3STpIWSHpS0rCk92Y+c66k76Xpn5b0m/RzPy7pMUkrJR2ZSf9uSfekaZdLel9ZGc6V9IikhyWdKSkk7Zbuu0TSPEk/To//laSXZ479S0k/S/N5r6S3p9vPAk4Fzk2/lx+l2zc0s0g6SNKgpD+m39MX0+2z0jy8Oy3Laknvl3SgpLskPSXpghq/k9L3eVWa59sl/VVm/wPp938X8CdJkyQdkzZbPZU20byi7LQHSlqW5uVbkrZIzzVN0vWSVqX7rpc0vezYl0v6z7ScP5S0bVk5K10MnC7pF+nyrenmX6ff5YmS7pZ0dCb9ZpIel7Rfte/FchIR/vEPwM3AmZn1LwELgG2BqcCPgM+l+w4F1gGfBzYHtgTmAmuBvyW5wNgSuBX4GrAFsC+wCnh9eo65wJ+BN5I0UX4buB/4BLAZ8F7g/kx+3gy8HBDwOuBZYP9032zgUWBvYApwORDAbun+S4AngIPSz7oCuDLdtxWwEnh3um8/4HFgr8yxny37rh4ADk+XbwPekS5vDRySLs9K8/D1tPxHpuW9DngpsDPwGPC6Kr+P0vd5Qvp9fCT9fjbL5OFOYEb6Xe8B/Ak4Ik1/LjAMTM6kvztNvy3wy1K5gO2A49PvbirwPeC6sr+Nh4B90u/rWuDysnJOKv87Ak4HfpE5z4bfSbp+LnBVZv1Y4Dfd/r9QxJ+uZ8A/vfFT9h9YaaXy8sz+V5NWzCSBYA2wRWb/XODWzPoMYD0wNbPtc8AlmfQ/y+w7GngGmJiuT00rjm2q5Pc64EPp8sWkQSpd341NA8FFmf1vAv4rXT4R+HnZub8B/GPm2FqB4Fbg08D2ZWlKFeTOmW1PACdm1q8FPlylfHOBxZn1CcAjwF9n8vCezP5PAVeXpX8IODST/v1l38F9VT57X2B12d/G+Zn1vdLf/0RaCwQ7AU8DL0rXrwHO7fb/hSL+uGnIKnkJydXhUNrM8BTwk3R7yaqI+HPZcSszyzsBT0bE05ltK0iuhEt+n1l+Dng8ItZn1iHtiJR0lKTFafPNUyQV2faZz8p+dna55NHM8rO80MG5C3BwqZzpuU8FdqhwjkrOILka/y9JSyS9pWx/eRnL1yt2tKY2lCMiRoERkrJusj/dvqIs/Uo2/r6z6VeUziVpiqRvSFqRNuvdCmyjdCRQlWM344Xvf0wi4mGSO5PjJW0DHEWmc9k6x51MVsnjJJXU3hHxUJU0laatzW57GNhW0tRMMJhJcpXaFEmbk1w9vxP4YUSslXQdyZ0LJFfK2TbtGU2cfiVwS0QcUWV/zel5I+J3wMmSJgDHAddI2q6Jz69lQznS808n+V4r5e1h4JWZ9EqPz37f2e9lZuZc/wDsCRwcEY9K2he4gxe+30rHriX5O2nmu67kUuBMkrrothp/b5Yj3xHYJtKryQuBL0l6KYCknSW9sYlzrAT+A/icpC0kvYrk6vnyMWRpMklfxCpgnaSjSNrcS64G3i3pFZKmkDSTNOp6YA9J70g7KzdLO3RLHa2/B15W7WBJp0l6SfqdPZVuHm3i82s5QNJxaUfsh4HngcVV0l4NvFnSGyRtRlK5P0/yOyg5W9L0tKP3E8BV6fapJIH/qXTfP1Y4/2mS9kq/3/OAazJ3b42q9F1eB+wPfIikn8i6wIHAqvkoSWfj4rS54CaSq8ZmnEzShvww8AOSdvebms1IekfxQZLKbjVwCklHdmn/DcBXgEWlPKe7nm/w3EcCJ6X5fJQXOsEBvgnslTYbXVfhFLOBpZKeAb4MnBQRz1VINxY/JOnDWA28AzguItZWKce9wGnAV0mu1I8Gjo6INZlk3wF+CiwH7gM+m27/V5IO58dJvrufVPiIy0j6Sx4l6fwey0OHc4FL0+/y7Wm+nyO529sV+P4YzmltoLSTxmzcSK/m7wY2j4h13c7PWEiaS9Kxelq385I3SXOAPYpQ1l7lOwIbFyS9VcmzD9NIruh/1K9BoEjSpqgzgPndzkuRORDYePE+knH595EMW/277mbH6lHygOFK4IaIuLVeesuPm4bMzArOdwRmZgXXd88RbL/99jFr1qxuZ8PMrK8MDQ09HhEvqbSv7wLBrFmzGBwc7HY2zMz6iqQV1fa5acjMrOAcCMzMCs6BwMys4BwIzMwKzoHAzKzgcgsEki5W8srBu6vsl6SvKHmF4V2S9s8rL2ZmVl2ew0cvAS6g+tSyRwG7pz8HA/+W/mtmtpGhFatZvPwJDnnZdhywy7Sm0jRybK1zAR1bPmCXaQ19dqPlaFRugSAibpU0q0aSY4FvRzLHxWJJ20jaMSIeyStPZkXXrsqyWmVVXpG1UmGVzjNtymTOu34pa9aNMnnSBOa8ZW9WP7tmo88uT3PFmYdsyMupFy3eaHs2v5WWs+eaNEEgsW59/sulstX77Gz52qWbD5TtzMavvxtJt20SCCSdBZwFMHPmzI5kzqwfNFPpVqoUq1WWtc6VTV+rIqtWaTdydZv9jAkSoxGMBqxZO8qcH97NaMRGn51Ns3bdKIuXP8EBu0xj8fInWLNudMP2a28f4fu3j9SsaDc61/oAgqADy+tGueHuR17Ib410pfK1S188WRwR80mnqR0YGPAseWZUr9irKa8Uq1WW9SqZjdLXqMiqVdqVgkcpWJQ+N/sZRDBhghCBqlTS2TSbTZrAtCmTmbdomGlTJjN50gTWrhtls0kTENStaLPnmpjmdf360dyXN5s0gaP22ZElDzzJ2nW105WCabt0MxA8xMbvO53OGN5na1ZUjVbg2SaWbKVYrbKsVslUOk+tiqxapZ1dzgaLbDA75GXbbZSnUrAoNdtU+uzyNNXuSq69faRuRdvInUweywfsMo09d5g6fvoIGrAAOEfSlSSdxH9w/4AVWbNt6+WVZaUKvPyuodHKct6i4Y3yUe08tSqyapV2dllVmnQO2GUaV5x5SMXvo1pFWUozb9HwRgFy9bNrOPuw3TYcnz1v9vhK5yrJrndiuZF07ZRbIJD0XeBQYHtJIyQvxN4MICK+DiwE3kTyjtlngXfnlRezXtdsMw9Qs7IsKb9rKFWK1SrLavmodp5sXrLLpfV6V7fZYFEezMorxGrby9PUC5DdqGh7XZ6jhk6usz+As/P6fLN+0mw7fUm1yrKkWqVYbXu1fDRy99FI/iotZ4NFOyriRgKkbawvOovNxruxVrTVZJuZKlWK1SrLavnIs3KtF8x65ZzjWd+9qnJgYCD8PgIbj9o5/r7ZZqY88mG9RdJQRAxU2uc7ArMe0a6r2LE2M7U7H9Y/POmc2ThTat6ZKHIZc56noRWrmbdomKEVq7udlULxHYHZONPO9vxONhO12qRlY+dAYNZnGqmc29G80+mKudUmLRs7BwKzNsr7CrqTlXOnK+Z2j5yyxjkQmLVJJyrpTlbOna6YPf6/exwIzNqkE5V0JyvnblTMHrHUHQ4EZm2SZyVd7wGxvLhiLgYHArM2yesKulKTU3aeH7NWORCYtVEeV9AeTWN58wNlZj2unx8Qs/7gOwKzHufRNJY3BwKzPuBOW8uTm4bMzArOgcDMrOAcCMzGCc/caWPlPgKzccAzd1orfEdg1gF5X61XetbArFG+IzDLWSeu1j1zp7XCgcAsZ514MtjPGlgrHAjMctapq3U/a2Bj5UBgljNfrVuvcyAw6wBfrVsv86ghM7OCcyAwMys4BwIzs4JzIDAzKzgHAjOzgnMgMOtBnkDOOinX4aOSZgNfBiYCF0XE+WX7ZwKXAtukaT4WEQvzzJNZr/MEctZpud0RSJoIzAOOAvYCTpa0V1myTwJXR8R+wEnA1/LKj1m/8ARy1ml5Ng0dBAxHxPKIWANcCRxbliaAF6XLLwYezjE/Zn3BL6u3TsuzaWhnYGVmfQQ4uCzNXOCnkv4nsBVweKUTSToLOAtg5syZbc+oWS/xlBTWad2eYuJk4JKI+BdJrwYuk7RPRIxmE0XEfGA+wMDAQHQhn2Yd5SkprJPybBp6CJiRWZ+ebss6A7gaICJuA7YAts8xT2Zd5xFB1mvyvCNYAuwuaVeSAHAScEpZmgeBNwCXSHoFSSBYlWOezDpmaMXqTZp3PCLIelFugSAi1kk6B7iRZGjoxRGxVNJ5wGBELAD+AbhQ0v8i6Tg+PSLc9GN9r1qF34mX1Jg1K9c+gvSZgIVl2+ZklpcBr8kzD2bdUK3CL39JzbQpk5m3aNidwtZV3e4sNut7lZqAqr2VLDsiaNqUyZx3/VI3E1nXORCYtaBaE1CtIaCl/fMWDbuZyHqCA4FZC2q1+dcbAtqpdxmb1eNAYFZDpWafrFYqcz84Zr1C/TZIZ2BgIAYHB7udDSuARod61gsWZr1A0lBEDFTa5zsCsyoaHerpp4Ct3/l9BFZIjTzd68nfrCh8R2CF02iTj9vwrSgcCKxwmnm6180+VgRuGrLCcZOP2cZ8R2CF4yYfs405EFgh1Wry8XBQKxoHArMMTxNtReQ+ArMMvzjeisiBwCzDHclWRG4aMstwR7IVkQOBGZt2EDsAWJE4EFjhuYPYis59BFZ47iC2onMgsMJzB7EVnZuGbFxo5SEwdxBb0TkQWN9rRxu/O4ityNw0ZH3PbfxmrXEgsL7nNn6z1rhpyPqe2/jNWuNAYOOC2/jNxs5NQ2ZmBedAYGZWcA4EZg0aWrGaeYuGGVqxuttZMWurhvoIJH0f+CZwQ0SM5psls97j+YhsPGv0juBrwCnA7ySdL2nPRg6SNFvSvZKGJX2sSpq3S1omaamk7zSYH7OO8rMKNp41dEcQETcBN0l6MXByurwSuBC4PCLWlh8jaSIwDzgCGAGWSFoQEcsyaXYHPg68JiJWS3ppyyUyy0HpWYW160b9rIKNOw0PH5W0HXAa8A7gDuAK4LXAu4BDKxxyEDAcEcvT468EjgWWZdK8F5gXEasBIuKx5otglj8/q2DjWaN9BD8A9gQuA46OiEfSXVdJGqxy2M7Aysz6CHBwWZo90vP/EpgIzI2In1T4/LOAswBmzpzZSJbN2s7PKth41egdwYURsTC7QdLmEfF8RAy0+Pm7k9xRTAdulfTKiHgqmygi5gPzAQYGBqKFzzMzszKNdhZ/tsK22+oc8xAwI7M+Pd2WNQIsiIi1EXE/8FuSwGBmZh1S845A0g4kTTxbStoPULrrRcCUOudeAuwuaVeSAHASycijrOtIOp+/JWl7kqai5U2VwKxBrbyzwGw8q9c09EbgdJKr+S9mtj8N/J9aB0bEOknnADeStP9fHBFLJZ0HDEbEgnTfkZKWAeuB/x0RHpdnbefnAMyqqxkIIuJS4FJJx0fEtc2ePO1XWFi2bU5mOYC/T3/MclPpOQAHArNEvaah0yLicmCWpE0q64j4YoXDzHIz1uYdPwdgVl29pqGt0n+3zjsjZvW00rzj5wDMqqvXNPSN9N9PdyY7ZtW12rzTzucA3PFs40m9pqGv1NofER9sb3bMquuV5h13PNt4U69paKgjuTBrQK8077jj2cabRkYNmfWMXpjmoVfuTMzapV7T0L9GxIcl/QjYZGqHiDgmt5yZ9aheuTMxa5d6TUOXpf9+Ie+MmPWTXrgzMWuXek1DQ+m/t0iaDPwlyZ3BvRGxpgP5MzOznDU06ZykNwP3AV8BLgCGJR2VZ8bM6vE7hM3ao9FpqP8FOCwihgEkvRz4MXBDXhkzq6XWEE6P8TdrTqOB4OlSEEgtJ5l4zqwrqg3h9Bh/s+bVGzV0XLo4KGkhcDVJH8HbSKaZNuuKakM4PcbfrHn17giOziz/HnhdurwK2DKXHJk1oNoQTo/xN2uekpmg+8fAwEAMDlZ7TbKZ+wjMKpE0VO3Vwo2+vH4L4Axgb2CL0vaIeE9bcmjWRh7jb9acRt9ZfBmwA8kby24heWOZO4vNzMaBRgPBbhHxKeBP6fxDbwYOzi9bZmbWKY0GgrXpv09J2gd4MfDSfLJkZmad1OhzBPMlTQM+BSwgeWPZp3LLlZmZdUxDgSAiLkoXbwFell92zNrLI4jM6mt01NB2wFzgNSQPlP0c+ExEPJFf1qwI8qyo/ZSxWWMabRq6ErgVOD5dPxW4Cjg8j0xZMeRdUfspY7PGNNpZvGNEfCYi7k9/Pgv8RZ4Zs/GvUkXdTqWnjCcKP2VsVkOjdwQ/lXQSyVxDACcAN+aTJSuKvKeD8JvEzBpTc4oJSU+T9AkI2AoYTXdNAJ6JiBflnsMynmJifHFnrllnjHmKiYiYmk+WzBKeDsKs+xptGkLSMcDfpKs3R8T1+WTJzMw6qdFXVZ4PfAhYlv58SNLn8syYmZl1RqN3BG8C9o2IUQBJlwJ3AB/PK2NmZtYZjQ4fBdgms/zidmfEzMy6o9FA8H+BOyRdkt4NDAH/VO8gSbMl3StpWNLHaqQ7XlJIqtijbWZm+anbNCRpAsmw0UOAA9PNH42IR+scNxGYBxwBjABLJC2IiGVl6aaS9D/8qvnsm5lZq+reEaT9AudGxCMRsSD9qRkEUgcBwxGxPCLWkExTcWyFdJ8BPg/8uZmMm5lZezTaNHSTpI9ImiFp29JPnWN2BlZm1kfSbRtI2h+YERE/rnUiSWdJGpQ0uGrVqgazbGZmjWh01NCJJE8Yf6Bs+5inpE6bnL4InF4vbUTMB+ZD8mTxWD/TzMw21Wgg2IskCLyWF6ah/nqdYx4CZmTWp6fbSqYC+wA3S4LkncgLJB0TEZ5DwsysQxptGroUeAXwFeCrJIHh0jrHLAF2l7SrpMnASSRvNwMgIv4QEdtHxKyImAUsBhwEzMw6rNE7gn0iYq/M+iJJy6qmBiJinaRzSGYpnQhcHBFLJZ0HDEbEglrHW//zhHJm/aHRQHC7pEMiYjGApIOBulfuEbEQWFi2bU6VtIc2mBfrA347mFn/aLRp6ADgPyQ9IOkB4DbgQEm/kXRXbrmzvpX3S2fMrH0avSOYnWsubNzJ+6UzZtY+DQWCiFiRd0ZsfPHbwcz6R8PvIzBrVrteOuNOZ7N8ORBYT3Ons1n+mpmG2qzj3Olslj8HAutppU7nicKdzmY5cdOQ9TR3Opvlz4HAel67Op3NrDI3DZmZFZwDgZlZwTkQmJkVnAOBmVnBORCYmRWcA4GZWcE5EJiZFZwDgXXc0IrVzFs0zNCK1d3OipnhB8qswzyJnFnv8R2BdZQnkTPrPQ4E1lGeRM6s97hpyDqq0Unk/DIas85xILCOqzeJnPsRzDrLTUPWc9yPYNZZDgTWc9yPYNZZbhqynuOX0Zh1lgOB9SS/jMasc9w0ZC3xU8Jm/c93BDZm7R7d4yGjZt3hQGBjVml0z1grcA8ZNeseNw3ZmLVzdI+HjJp1T653BJJmA18GJgIXRcT5Zfv/HjgTWAesAt4TESvyzJO1TztH95SCytp1ox4yatZhioh8TixNBH4LHAGMAEuAkyNiWSbNYcCvIuJZSX8HHBoRJ9Y678DAQAwODuaSZ6uuE+337iMwy4+koYgYqLQvzzuCg4DhiFieZuJK4FhgQyCIiEWZ9IuB03LMj41Rp9rvPWTUrDvy7CPYGViZWR9Jt1VzBnBDpR2SzpI0KGlw1apVbczi+NTuIZ1uvzcb33pi1JCk04AB4HWV9kfEfGA+JE1DHcxa38nj6r0d7fdu9jHrXXkGgoeAGZn16em2jUg6HPgE8LqIeD7H/BRCO4d0lrTaKeyhoWa9Lc9AsATYXdKuJAHgJOCUbAJJ+wHfAGZHxGM55qUw2jn6pvwqfqyVdx7ByczaJ7dAEBHrJJ0D3EgyfPTiiFgq6TxgMCIWAP8P2Br4niSAByPimLzyVATtGtLZzqt4Dw0162259hFExEJgYdm2OZnlw/P8/KJqx+ibWlfxzbb3ezZRs97WE53F1nuqXcWP9U7BQ0PNepcDgVVU7Sre7f1m448DgVVV6Sre7f1m448DgTXF7f1m448DgTXN7f1m44unoba28dvKzPqT7wisLfz0sFn/8h2BtYUnpjPrXw4E1hbtfFuZmXWWm4bGuU7N+unRRGb9y4FgHBtLu30rgcOjicz6kwPBONbsU8Du8DUrJvcR9KB2DcNstt3eHb5mxeQ7gh7TzqvyZtvtPX2EWTE5EPSYdk/q1ky7vTt8zYrJgaDHdPuq3B2+ZsXjQNBjfFVuZp3mQNCDfFVuZp3kUUPjRLMjjTxBnJmV+I6gi5p9eKs8fWl92pTJnHf90oZHGvl5ATPLciDokmYr4/L0c96y94bKf4LEaETdkUalwPHwU8/5dZNmtoEDQZc0O0y0PP0Ndz+yYZ0IJkwQIqqONMoGkkkTxKSJE1i/3s8LmJkDQdc0O0y0PP1R++zIkgee3LA+5y17s/rZNVWbmbKBZP1ocOJBM9h5my09MsnMHAi6pXyYKMC8RcNVK+ZKw0r33GHqmJ8aPn7/6Q4AZgaAIqLbeWjKwMBADA4OdjsbbdWpzttOTUltZr1H0lBEDFTa5zuCHtDuaSWq8fMJZlaJnyPoAX67l5l1k+8IWtSO5pZuTyvhJiOzYnMgaEG7p4zuRiXsh8vMzE1DLWj0RS69PJ2DX0ZjZr4jqKFak0l2aofskMxpUyZvMgS00hPBtcb7d1q3p702s+7LNRBImg18GZgIXBQR55ft3xz4NnAA8ARwYkQ8kEdexjKvT6Umk2oVe/l8P6Xt2ekc1qwdZc4P72Y0oiMvk29Et/snzKz7cgsEkiYC84AjgBFgiaQFEbEsk+wMYHVE7CbpJODzwIntzkutq3Kg4kRu5fPxXHv7SMXtq59dw9mH7ca8RcMVK/zsdA5qcE6gavnOq/3ew0rNii3PO4KDgOGIWA4g6UrgWCAbCI4F5qbL1wAXSFK0+Sm3bDt4eSWNxLr1m07klq3AJ04Q1wyNsG599Xl6sk0s2Qo/O51D6a6h0WaYTj1fYGbFlmcg2BlYmVkfAQ6uliYi1kn6A7Ad8Hg2kaSzgLMAZs6c2XRGqlXSa9cHEASbTuSWrcAffuo5vvufD9acpyfbxFJe4Wenc2hlWgi335tZHvqiszgi5gPzIZliotnjq1XSE9M7gtLVfflEbqUKfGjFaq69faTuPD3ZJpZqFb5fJm9mvSbPQPAQMCOzPj3dVinNiKRJwItJOo3brlolDdSdyG0sFXK72t3dfm9mectt0rm0Yv8t8AaSCn8JcEpELM2kORt4ZUS8P+0sPi4i3l7rvONx0jkzs7x1ZdK5tM3/HOBGkuGjF0fEUknnAYMRsQD4JnCZpGHgSeCkvPJjZmaV5dpHEBELgYVl2+Zklv8MvC3PPJiZWW2eYsLMrOAcCMzMCs6BwMys4BwIzMwKru/eWSxpFbBijIdvT9lTywXgMheDy1wMrZR5l4h4SaUdfRcIWiFpsNo42vHKZS4Gl7kY8iqzm4bMzArOgcDMrOCKFgjmdzsDXeAyF4PLXAy5lLlQfQRmZrapot0RmJlZGQcCM7OCGzeBQNJsSfdKGpb0sRrpjpcUkgYy2z6eHnevpDd2JsetG2uZJR0haUjSb9J/X9+5XLemld9zun2mpGckfST/3Lauxb/rV0m6TdLS9He9RWdy3ZoW/q43k3RpWtZ7JH28c7luTb0ySzpd0ipJd6Y/Z2b2vUvS79Kfd40pAxHR9z8k01zfB7wMmAz8GtirQrqpwK3AYmAg3bZXmn5zYNf0PBO7Xaacy7wfsFO6vA/wULfLk3eZM/uuAb4HfKTb5cn5dzwJuAv4q3R9uwL8XZ8CXJkuTwEeAGZ1u0ztKDNwOnBBhWO3BZan/05Ll6c1m4fxckdwEDAcEcsjYg1wJXBshXSfAT4P/Dmz7ViSP57nI+J+YDg9X68bc5kj4o6IeDhdXQpsKWnzvDPcBq38npH0t8D9JGXuB62U90jgroj4NUBEPBER6/POcBu0UuYAtkpfirUlsAb4Y875bYdGy1zJG4GfRcSTEbEa+Bkwu9kMjJdAsDOwMrM+km7bQNL+wIyI+HGzx/aoVsqcdTxwe0Q83/4stt2Yyyxpa+CjwKfzzmQbtfI73gMISTdKul3SuflmtW1aKfM1wJ+AR4AHgS9ExJM55rVdGq2Djpd0l6RrJJVeA9yW+qsvXl7fKkkTgC+S3F4VQiNllrQ3yVXVkR3KVq7qlHku8KWIeEZSJ7OVmzrlnQS8FjgQeBb49/RVhf/euRy2X50yHwSsB3YiaSb5uaSbImJ553KYmx8B342I5yW9D7gUaFvf3ngJBA8BMzLr09NtJVNJ2sJvTiuBHYAFko5p4NheNeYyR8SgpOnAD4B3RsR9Hcpzq1r5PR8MnCDpn4FtgFFJf46ICzqS87FppbwjwK0R8TiApIXA/kCvB4JWynwK8JOIWAs8JumXwABJu3kvq1sHRcQTmdWLgH/OHHto2bE3N52DbneUtKmzZRLJL3tXXuhs2btG+pt5oYNpbzbuLF5Of3SqtVLmbdL0x3W7HJ0qc9n2ufRHZ3Erv+NpwO0knaaTgJuAN3e7TDmX+aPAt9LlrYBlwKu6XaZ2lBnYMbP8VmBxurwtSaHJHHAAAAMWSURBVL/XtPTnfmDbZvMwLvoIImIdcA5wI3APcHVELJV0XnqlUOvYpcDVJH80PwHOjj7oVGulzOlxuwFzMsPRXppzllvWYpn7Tot/16tJmlCWAHeS9APV6ivqCS3+jucBW0taSlLub0XEXfnmuHUNlvmD6TDgXwMfJG0ai6QP5DMk5V0CnBdj6BfxFBNmZgU3Lu4IzMxs7BwIzMwKzoHAzKzgHAjMzArOgcDMrOAcCKwwJM2SdHeTx5wuaacxfNaHJb0zXX5bOvRvtHw21HT/kKQ70mG8D5bNMjlL0k2SpjWbB7NGORCY1XY6yZQFDUsnPXsP8J10093AcSSzZZan3ZVk9tf9ImJfYA5wVUTsm/48AFwGfGDMJTCrw4HAimaSpCvS+eqvkTQFQNIBkm5Jr85vlLSjpBNIpii4Ir0631LSHElLJN0tab4qT1z0epIHuNYBRMQ9EXFvlfzMJnmQsZYFwMljK65ZfQ4EVjR7Al+LiFeQTFH8AUmbAV8FToiIA4CLgX+KiGuAQeDU9Or8OZI54Q+MiH1Ipjp+S4XPeA0w1GB+6gaC9CnhzSVt1+A5zZriQGBFszIifpkuX04yQ+eeJBOZ/UzSncAnSSbvquQwSb+S9BuSK/+9K6TZEVhVLyOSJgPTo7HZMR+jySYqs0aNl9lHzRpVPqdKAAKWRsSrax2o5FWPXyOZ5GylpLlApdc/Pldle7m/Bn7RQDrS8z3XYFqzpviOwIpmpqRShX8KSUV8L/CS0nYl774tXek/TTL1MbxQuT+evujmhCqfcQ/JpH71zAZuqJco7YfYgeTVi2Zt50BgRXMvcLake0im7f23SF4PeALw+XR2xzuB/5GmvwT4etpk9DxwIckooBtJZnus5Abgb0orkt4qaQR4NfBjSTemuw4FbmkgzweQTDu8rtFCmjXDs4+a5UDSD4BzI+J3VfZPBy6MiKMaONeXgQXR528Xs97lQGCWA0l7An8REZs8OzCGc703Ii5sQ7bMKnIgMDMrOPcRmJkVnAOBmVnBORCYmRWcA4GZWcE5EJiZFdx/A9MBJ5Vegt+tAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# import matplotlib.pyplot as plt\n",
        "# from statistics import mean\n",
        "\n",
        "# # print(history)\n",
        "# # plt.plot(history)\n",
        "\n",
        "# print(history)\n",
        "\n",
        "# predict = []\n",
        "\n",
        "\n",
        "\n",
        "# # for i in range():\n",
        "\n",
        "\n",
        "# for i in range(len(history)):\n",
        "#   predict.append(history[i][1])\n",
        "\n",
        "# # print(predict)\n",
        "\n",
        "# # print(mean(predict[0:9]))\n",
        "\n",
        "# result = []\n",
        "\n",
        "# for i in range(50):\n",
        "#   result.append(mean(predict[10*i:10*i+9]))\n",
        "\n",
        "\n",
        "\n",
        "# # print(result)\n",
        "\n",
        "\n",
        "\n",
        "# betas=np.linspace(0.4, 0.5, 50).tolist()\n",
        "\n",
        "\n",
        "# fig, ax = plt.subplots()\n",
        "# ax.errorbar(betas, result, capsize=4, marker='.')\n",
        "# plt.show()"
      ],
      "metadata": {
        "id": "nygoSU91YRx8"
      },
      "execution_count": 48,
      "outputs": []
    }
  ]
}