adaboost semi-supervised learning

Author: akul-goyal

.DS_Store

@@ -0,0 +1 @@
+Subproject commit 78091cd847f7da20ddae85d1e2480ad2d9e99766

Adaboosting-Yang-Liu

@@ -0,0 +1,190 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf\n",
+    "import pandas as pd\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define an empty list\n",
+    "x_train = []\n",
+    "\n",
+    "# open file and read the content in a list\n",
+    "with open('listfile.txt', 'r') as filehandle:\n",
+    "    for line in filehandle:\n",
+    "        # remove linebreak which is the last character of the string\n",
+    "        currentPlace = line[:-1]\n",
+    "\n",
+    "        # add item to the list\n",
+    "        x_train.append(currentPlace)\n",
+    "# define an empty list\n",
+    "y_train = []\n",
+    "\n",
+    "# open file and read the content in a list\n",
+    "with open('listfile1.txt', 'r') as filehandle:\n",
+    "    for line in filehandle:\n",
+    "        # remove linebreak which is the last character of the string\n",
+    "        currentPlace = line[:-1]\n",
+    "\n",
+    "        # add item to the list\n",
+    "        y_train.append(currentPlace)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ast\n",
+    "temp1=[]\n",
+    "for x in x_train:\n",
+    "    temp1.append(ast.literal_eval(x))\n",
+    "x_train=temp1\n",
+    "x_train = np.asarray(x_train)\n",
+    "import ast\n",
+    "temp2=[]\n",
+    "for x in y_train:\n",
+    "    temp2.append(ast.literal_eval(x))\n",
+    "y_train=temp2\n",
+    "y_train = np.asarray(y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/3\n",
+      "693/693 [==============================] - 0s 637us/step - loss: 9.9925 - acc: 0.1400\n",
+      "Epoch 2/3\n",
+      "693/693 [==============================] - 0s 54us/step - loss: 3.5667 - acc: 0.1674\n",
+      "Epoch 3/3\n",
+      "693/693 [==============================] - 0s 61us/step - loss: 3.1353 - acc: 0.1674\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Using Keras Sequentail Model, this is bound to change\n",
+    "model = tf.keras.models.Sequential()\n",
+    "#Using 3 hidden layers with 128 nodes relu activation function, bound to change\n",
+    "model.add(tf.keras.layers.Flatten())\n",
+    "model.add(tf.keras.layers.Dense(128,kernel_initializer='normal', activation=tf.nn.relu))\n",
+    "model.add(tf.keras.layers.Dense(128,kernel_initializer='normal', activation=tf.nn.relu))\n",
+    "model.add(tf.keras.layers.Dense(128,kernel_initializer='normal', activation=tf.nn.relu))\n",
+    "#Using a single output with linear activation for Off Rtg or Def Rtg, definietly might change\n",
+    "model.add(tf.keras.layers.Dense(1, kernel_initializer='normal', activation='linear'))\n",
+    "#using adam optimizer, and MSE\n",
+    "model.compile(optimizer='adam',loss='mean_squared_error', metrics=['accuracy'])\n",
+    "#training model for 3 epochs, will increase for better accuracy\n",
+    "history = model.fit(x_train,y_train,epochs=3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3.0361745791001753, 0.1673881674150454]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# define an empty list\n",
+    "x_test = []\n",
+    "\n",
+    "# open file and read the content in a list\n",
+    "with open('listfile.txt', 'r') as filehandle:\n",
+    "    for line in filehandle:\n",
+    "        # remove linebreak which is the last character of the string\n",
+    "        currentPlace = line[:-1]\n",
+    "\n",
+    "        # add item to the list\n",
+    "        x_test.append(currentPlace)\n",
+    "# define an empty list\n",
+    "y_test = []\n",
+    "\n",
+    "# open file and read the content in a list\n",
+    "with open('listfile1.txt', 'r') as filehandle:\n",
+    "    for line in filehandle:\n",
+    "        # remove linebreak which is the last character of the string\n",
+    "        currentPlace = line[:-1]\n",
+    "\n",
+    "        # add item to the list\n",
+    "        y_test.append(currentPlace)\n",
+    "        \n",
+    "import ast\n",
+    "temp1=[]\n",
+    "for x in x_test:\n",
+    "    temp1.append(ast.literal_eval(x))\n",
+    "x_test=temp1\n",
+    "x_test = np.asarray(x_test)\n",
+    "import ast\n",
+    "temp2=[]\n",
+    "for x in y_test:\n",
+    "    temp2.append(ast.literal_eval(x))\n",
+    "y_test=temp2\n",
+    "y_test = np.asarray(y_test)\n",
+    "\n",
+    "\n",
+    "#validate model\n",
+    "acc = model.evaluate(x_test,y_test,verbose=0)\n",
+    "print(acc)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

BasicNeuralNetwork.ipynb

@@ -0,0 +1,92 @@
+import numpy as np
+from numpy import linalg
+import cvxopt
+import cvxopt.solvers
+
+
+def linear_kernel(x1, x2):
+    return np.dot(x1, x2)
+
+
+def polynomial_kernel(x, y, p=3):
+    return (1 + np.dot(x, y)) ** p
+
+
+def gaussian_kernel(x, y, sigma=5.0):
+    return np.exp(-linalg.norm(x - y) ** 2 / (2 * (sigma ** 2)))
+
+
+class SVM(object):
+    def __init__(self, kernel=linear_kernel, C=None):
+        self.kernel = kernel
+        self.C = C
+        if self.C is not None: self.C = float(self.C)
+
+    def fit(self, X, y):
+        n_samples, n_features = X.shape
+
+        # Gram matrix
+        K = np.zeros((n_samples, n_samples))
+        for i in range(n_samples):
+            for j in range(n_samples):
+                K[i, j] = self.kernel(X[i], X[j])
+
+        P = cvxopt.matrix(np.outer(y, y) * K)
+        q = cvxopt.matrix(np.ones(n_samples) * -1)
+        A = cvxopt.matrix(y, (1, n_samples), 'd')
+        b = cvxopt.matrix(0.0)
+
+        if self.C is None:
+            G = cvxopt.matrix(np.diag(np.ones(n_samples) * -1))
+            h = cvxopt.matrix(np.zeros(n_samples))
+        else:
+            tmp1 = np.diag(np.ones(n_samples) * -1)
+            tmp2 = np.identity(n_samples)
+            G = cvxopt.matrix(np.vstack((tmp1, tmp2)))
+            tmp1 = np.zeros(n_samples)
+            tmp2 = np.ones(n_samples) * self.C
+            h = cvxopt.matrix(np.hstack((tmp1, tmp2)))
+        #A = A.astype(double)
+        # solve QP problem
+        solution = cvxopt.solvers.qp(P, q, G, h, A, b)
+
+        # Lagrange multipliers
+        a = np.ravel(solution['x'])
+
+        # Support vectors have non zero lagrange multipliers
+        sv = a > 1e-5
+        ind = np.arange(len(a))[sv]
+        self.a = a[sv]
+        self.sv = X[sv]
+        self.sv_y = y[sv]
+        print("%d support vectors out of %d points" % (len(self.a), n_samples))
+
+        # Intercept
+        self.b = 0
+        for n in range(len(self.a)):
+            self.b += self.sv_y[n]
+            self.b -= np.sum(self.a * self.sv_y * K[ind[n], sv])
+        self.b /= len(self.a)
+
+        # Weight vector
+        if self.kernel == linear_kernel:
+            self.w = np.zeros(n_features)
+            for n in range(len(self.a)):
+                self.w += self.a[n] * self.sv_y[n] * self.sv[n]
+        else:
+            self.w = None
+
+    def project(self, X):
+        if self.w is not None:
+            return np.dot(X, self.w) + self.b
+        else:
+            y_predict = np.zeros(len(X))
+            for i in range(len(X)):
+                s = 0
+                for a, sv_y, sv in zip(self.a, self.sv_y, self.sv):
+                    s += a * sv_y * self.kernel(X[i], sv)
+                y_predict[i] = s
+            return y_predict + self.b
+
+    def predict(self, X):
+        return np.sign(self.project(X))