linear_regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing necessary libraries\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating some sample data\n",
    "def generate_line(p1,p2,N=8):\n",
    "    m = (p2[1] - p1[1]) / (p1[0] - p2[0])\n",
    "    b = -p1[0] * m + p1[1]\n",
    "    x = np.array([p1[0],p2[0]],dtype=np.float)\n",
    "    y = np.array([p1[1],p2[1]],dtype=np.float)\n",
    "\n",
    "    #add random points along the line\n",
    "    xr = np.linspace(p1[0],p2[0],N, endpoint=True)\n",
    "    yr = np.round(np.interp(xr, x, y),3)\n",
    "    yn = yr + np.random.normal(0, 3,yr.shape[0])\n",
    "    yn = np.round(yn,3)\n",
    "\n",
    "    return [np.array([xr,yn]),np.array([xr,yr]),np.array([x,y])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define train data generator\n",
    "def train_data_gen(sample=100):\n",
    "    while True:\n",
    "        p1 = [np.random.randint(-100,100),np.random.randint(-100,100)]\n",
    "        p2 = [p1[0] + np.random.randint(10,50), p1[1] + np.random.randint(-100,100)]\n",
    "\n",
    "        randpts = []\n",
    "        lines = []\n",
    "        pairs = []\n",
    "        \n",
    "        R,L,P = generate_line(p1,p2,sample)\n",
    "        randpts.append(R)\n",
    "        lines.append(L)\n",
    "        pairs.append(P)\n",
    "        \n",
    "        yield np.array(randpts), np.array(lines),np.array(pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot data sample\n",
    "batch_iter = train_data_gen(sample=20)\n",
    "noises,lines,points = next(batch_iter)\n",
    "\n",
    "# Plotting the results\n",
    "plt.scatter(noises[0][0], noises[0][1])\n",
    "plt.plot(lines[0][0], lines[0][1], color='red')\n",
    "\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('y')\n",
    "plt.title('Linear Regression using TensorFlow Keras')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a more complex model\n",
    "class PLRModel(tf.keras.Model):\n",
    "    def __init__(self, shape):\n",
    "        super().__init__()\n",
    "        self.atten = tf.keras.layers.MultiHeadAttention(num_heads=2, key_dim=2)\n",
    "        self.drop = tf.keras.layers.Dropout(0.01)\n",
    "        self.dense1 = tf.keras.layers.Dense(32, activation=\"linear\")\n",
    "        self.dense2 = tf.keras.layers.Dense(16, activation=\"linear\")\n",
    "        self.outputs = tf.keras.layers.Dense(2)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        x = self.atten(inputs,inputs)\n",
    "        x = self.drop(x)\n",
    "        x = self.dense1(x)\n",
    "        x = self.dense2(x)\n",
    "        return self.outputs(x)\n",
    "    \n",
    "def line_loss(y_true, y_pred):\n",
    "    p1_true,p2_true = y_true[:,0:1,:],y_true[:,1:2,:]\n",
    "    p1_pred,p2_pred = y_pred[:,0:1,:],y_pred[:,1:2,:]\n",
    "    # compute line slope\n",
    "    x_true = p1_true[:,:,0] - p2_true[:,:,0]\n",
    "    x_pred = p1_pred[:,:,0] - p2_pred[:,:,0]\n",
    "    #m_true = tf.divide((p2_true[:,:,1] - p1_true[:,:,1]), x_true)\n",
    "    #m_pred = tf.divide((p2_pred[:,:,1] - p1_pred[:,:,1]), x_pred)\n",
    "    # compute vector\n",
    "    v_true = p2_true - p1_true\n",
    "    v_pred = p2_pred - p1_pred\n",
    "    \n",
    "    #compute p1,p2 and slope loss\n",
    "    loss_p1 = tf.reduce_mean(tf.square(p1_true - p1_pred))\n",
    "    loss_p2 = tf.reduce_mean(tf.square(p2_true - p2_pred))\n",
    "    loss_v = tf.reduce_mean(tf.square(v_true - v_pred))\n",
    "    #loss_a = tf.math.angle([v_true,v_pred])\n",
    "    \n",
    "    return  loss_p1 + loss_p2 + loss_v\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 20)\n",
      "Model: \"plr_model\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "multi_head_attention (MultiH multiple                  352       \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            multiple                  0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                multiple                  672       \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              multiple                  528       \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              multiple                  34        \n",
      "=================================================================\n",
      "Total params: 1,586\n",
      "Trainable params: 1,586\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x1a3fb557fd0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# train model\n",
    "n_sample = 20\n",
    "batch_size = 32\n",
    "inp_shape = (1,noises.shape[1],n_sample)\n",
    "print(inp_shape)\n",
    "model = PLRModel(inp_shape[1::])\n",
    "\n",
    "# Compiling the model\n",
    "model.compile(loss=line_loss, optimizer=\"adam\", metrics=['accuracy'])\n",
    "model.build(input_shape=inp_shape) \n",
    "model.summary()\n",
    "\n",
    "epochs = 20\n",
    "count = 10000\n",
    "x_smaples = []\n",
    "y_samples = []\n",
    "iter = train_data_gen(sample=n_sample)\n",
    "\n",
    "for i in range(count):    \n",
    "    npts,lpts,pts = next(iter)\n",
    "    #npts = np.reshape(np.transpose(npts),(n_sample,2))\n",
    "    #pts = np.reshape(pts,(-1,4))\n",
    "\n",
    "    x_smaples.append(npts[0])\n",
    "    y_samples.append(pts[0])        \n",
    "        \n",
    "# split data into train and validation\n",
    "split = count - (count // 4)\n",
    "X_train, X_val = np.array(x_smaples[:split]), np.array(x_smaples[split:])\n",
    "y_train, y_val = np.array(y_samples[:split]), np.array(y_samples[split:])\n",
    "# train model\n",
    "model.fit(X_train,y_train, epochs=epochs, batch_size=32, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "79/79 [==============================] - 1s 7ms/step - loss: 1671.3470 - accuracy: 0.9590\n",
      "Mean Squared Error: [1671.3470458984375, 0.9589999914169312]\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the model\n",
    "mse = model.evaluate(X_val, y_val)\n",
    "print(\"Mean Squared Error:\", mse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ -9.  27.]\n",
      "  [-45. -75.]]]\n",
      "[[-10.172441  21.904642]\n",
      " [-45.090282 -71.68759 ]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Making predictions\n",
    "data_iter = train_data_gen(sample=n_sample)\n",
    "npts_test,_,pts_test = next(iter)\n",
    "line_pred = model.predict(npts_test)\n",
    "line_pred = line_pred[0]\n",
    "print(pts_test)\n",
    "print(line_pred)\n",
    "\n",
    "# Plotting the results\n",
    "plt.scatter(npts_test[0][0], npts_test[0][1])\n",
    "plt.plot(line_pred[0],line_pred[1], color='red')\n",
    "\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('y')\n",
    "plt.title('Linear Regression using TensorFlow Keras')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tfbuild",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}