Tf custom layers & train loops

perceptron.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train images number: 60000, images size: (28, 28), number of classes: 10\n",
      "Test images number: 10000\n"
     ]
    }
   ],
   "source": [
    "# Скачивание датасета\n",
    "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "x_train = x_train / 255.\n",
    "x_test = x_test / 255.\n",
    "\n",
    "print(f\"Train images number: {x_train.shape[0]}, \"\n",
    "      f\"images size: {x_train.shape[1:3]}, \"\n",
    "      f\"number of classes: {tf.unique(y_train)[0].shape[0]}\")\n",
    "print(f\"Test images number: {x_test.shape[0]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Формирование двух пакетов данных, шаффл, создание батчей\n",
    "BATCH_SIZE = 10\n",
    "SHUFFLE_BUFFER_SIZE = 2500\n",
    "SEED = 42\n",
    "\n",
    "train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n",
    "test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))\n",
    "\n",
    "train_dataset = train_dataset.shuffle(SHUFFLE_BUFFER_SIZE,\n",
    "                                      seed=SEED, reshuffle_each_iteration=True)\n",
    "test_dataset = test_dataset.shuffle(SHUFFLE_BUFFER_SIZE,\n",
    "                                    seed=SEED, reshuffle_each_iteration=True)\n",
    "\n",
    "train_dataset = train_dataset.batch(BATCH_SIZE, drop_remainder=True)\n",
    "test_dataset = test_dataset.batch(BATCH_SIZE, drop_remainder=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Организация слоев сети\n",
    "# Нужны полносвязные слои, а так же чтобы работали все примочки\n",
    "# Параметры оригинального денcа:\n",
    "# units, activation=None, use_bias=True, kernel_initializer='glorot_uniform',\n",
    "# bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None,\n",
    "# activity_regularizer=None, kernel_constraint=None, bias_constraint=None,\n",
    "\n",
    "\n",
    "class Dense(tf.keras.layers.Layer):\n",
    "    def __init__(self, units,\n",
    "                 activation=None,\n",
    "                 use_bias=True,\n",
    "                 kernel_initializer='glorot_uniform',\n",
    "                 bias_initializer='zeros',\n",
    "                 kernel_regularizer=None,\n",
    "                 bias_regularizer=None,\n",
    "                 activity_regularizer=None,\n",
    "                 kernel_constraint=None,\n",
    "                 bias_constraint=None,\n",
    "                 *args, **kwargs):\n",
    "        super(Dense, self).__init__(activity_regularizer=activity_regularizer, *args, **kwargs)\n",
    "        self.units = int(units) if not isinstance(units, int) else units\n",
    "        self.activation = activations.get(activation)\n",
    "        self.use_bias = use_bias\n",
    "        self.kernel_initializer = tf.keras.initializers.get(kernel_initializer)\n",
    "        self.bias_initializer = tf.keras.initializers.get(bias_initializer)\n",
    "        self.kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer)\n",
    "        self.bias_regularizer = tf.keras.regularizers.get(bias_regularizer)\n",
    "        self.kernel_constraint = tf.keras.constraints.get(kernel_constraint)\n",
    "        self.bias_constraint = tf.keras.constraints.get(bias_constraint)\n",
    "        \n",
    "    def build(self, input_shape):\n",
    "        self.kernel = self.add_weight(name='kernel',\n",
    "                                      shape=[input_shape[-1], self.units],\n",
    "                                      dtype=self.dtype,\n",
    "                                      initializer=self.kernel_initializer,\n",
    "                                      regularizer=self.kernel_regularizer,\n",
    "                                      constraint=self.kenrel_constraint,\n",
    "                                      trainable=True)\n",
    "        self.bias = None\n",
    "        if self.use_bias:\n",
    "            self.bias = self.add_weight(name='bias',\n",
    "                                        shape=[self.units,],\n",
    "                                        dtype=self.dtype,\n",
    "                                        initializer=self.bias_initializer,\n",
    "                                        regularizer=self.bias_regularizer,\n",
    "                                        constraint=self.bias_constraint,\n",
    "                                        trainable=True)\n",
    "        self.built = True\n",
    "    \n",
    "    @tf.function\n",
    "    def call(self, inputs):\n",
    "        outputs = tf.matmul(inputs, self.kernel)\n",
    "        if self.bias: outputs += self.bias\n",
    "        if self.activation: outputs = self.activation(outputs)\n",
    "        return outputs\n",
    "    \n",
    "    def get_config(self):\n",
    "        config = super(Dense, self).get_config()\n",
    "        config.update({\n",
    "            'units': self.units,\n",
    "            'activation': activations.serialize(self.activation),\n",
    "            'use_bias': self.use_bias,\n",
    "            'kernel_initializer': initializers.serialize(self.kernel_initializer),\n",
    "            'bias_initializer': initializers.serialize(self.bias_initializer),\n",
    "            'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),\n",
    "            'bias_regularizer': regularizers.serialize(self.bias_regularizer),\n",
    "            'activity_regularizer': regularizers.serialize(self.activity_regularizer),\n",
    "            'kernel_constraint': constraints.serialize(self.kernel_constraint),\n",
    "            'bias_constraint': constraints.serialize(self.bias_constraint)\n",
    "        })\n",
    "        return config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Обучение, валидация"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Тестирование"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}