From d64ef761d1ef9b115c135bfc15d619fe227632bb Mon Sep 17 00:00:00 2001
From: srivastava9 <krishu4626@gmail.com>
Date: Fri, 18 Oct 2019 19:01:31 +0530
Subject: [PATCH] Added some machine learning scripts like svm,kernels and CNN
 using Tensorflow

---
 .../src.py                                    |  81 ++++++
 .../result_of_svm_code.png.png                | Bin 0 -> 25579 bytes
 .../svm.py                                    | 165 ++++++++++++
 .../kernels and Soft svm using python/src.py  | 246 ++++++++++++++++++
 4 files changed, 492 insertions(+)
 create mode 100644 Machine_Learning/src/Convolution Neural Network with Tensorflow/src.py
 create mode 100644 Machine_Learning/src/Support Vector Machine using Python/result_of_svm_code.png.png
 create mode 100644 Machine_Learning/src/Support Vector Machine using Python/svm.py
 create mode 100644 Machine_Learning/src/kernels and Soft svm using python/src.py

diff --git a/Machine_Learning/src/Convolution Neural Network with Tensorflow/src.py b/Machine_Learning/src/Convolution Neural Network with Tensorflow/src.py
new file mode 100644
index 00000000..1042d9b3
--- /dev/null
+++ b/Machine_Learning/src/Convolution Neural Network with Tensorflow/src.py	
@@ -0,0 +1,81 @@
+import tensorflow as tf
+from tensorflow.examples.tutorials.mnist import input_data
+
+mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
+
+n_classes = 10
+batch_size = 128
+
+x = tf.placeholder("float", [None, 784])
+y = tf.placeholder("float")
+
+keep_rate = 0.8
+keep_prob = tf.placeholder(tf.float32)
+
+
+def conv2d(x, W):
+    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding="SAME")
+
+
+def maxpool2d(x):
+    #                        size of window         movement of window
+    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")
+
+
+def convolutional_neural_network(x):
+    weights = {
+        "W_conv1": tf.Variable(tf.random_normal([5, 5, 1, 32])),
+        "W_conv2": tf.Variable(tf.random_normal([5, 5, 32, 64])),
+        "W_fc": tf.Variable(tf.random_normal([7 * 7 * 64, 1024])),
+        "out": tf.Variable(tf.random_normal([1024, n_classes])),
+    }
+
+    biases = {
+        "b_conv1": tf.Variable(tf.random_normal([32])),
+        "b_conv2": tf.Variable(tf.random_normal([64])),
+        "b_fc": tf.Variable(tf.random_normal([1024])),
+        "out": tf.Variable(tf.random_normal([n_classes])),
+    }
+
+    x = tf.reshape(x, shape=[-1, 28, 28, 1])
+
+    conv1 = tf.nn.relu(conv2d(x, weights["W_conv1"]) + biases["b_conv1"])
+    conv1 = maxpool2d(conv1)
+
+    conv2 = tf.nn.relu(conv2d(conv1, weights["W_conv2"]) + biases["b_conv2"])
+    conv2 = maxpool2d(conv2)
+
+    fc = tf.reshape(conv2, [-1, 7 * 7 * 64])
+    fc = tf.nn.relu(tf.matmul(fc, weights["W_fc"]) + biases["b_fc"])
+    fc = tf.nn.dropout(fc, keep_rate)
+
+    output = tf.matmul(fc, weights["out"]) + biases["out"]
+
+    return output
+
+
+def train_neural_network(x):
+    prediction = convolutional_neural_network(x)
+    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(prediction, y))
+    optimizer = tf.train.AdamOptimizer().minimize(cost)
+
+    hm_epochs = 10
+    with tf.Session() as sess:
+        sess.run(tf.initialize_all_variables())
+
+        for epoch in range(hm_epochs):
+            epoch_loss = 0
+            for _ in range(int(mnist.train.num_examples / batch_size)):
+                epoch_x, epoch_y = mnist.train.next_batch(batch_size)
+                _, c = sess.run([optimizer, cost], feed_dict={x: epoch_x, y: epoch_y})
+                epoch_loss += c
+
+            print("Epoch", epoch, "completed out of", hm_epochs, "loss:", epoch_loss)
+
+        correct = tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1))
+
+        accuracy = tf.reduce_mean(tf.cast(correct, "float"))
+        print("Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))
+
+
+train_neural_network(x)
diff --git a/Machine_Learning/src/Support Vector Machine using Python/result_of_svm_code.png.png b/Machine_Learning/src/Support Vector Machine using Python/result_of_svm_code.png.png
new file mode 100644
index 0000000000000000000000000000000000000000..18682533fd2dca0198ec90dd0e4610bb1f4b5fa7
GIT binary patch
literal 25579
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

literal 0
HcmV?d00001

diff --git a/Machine_Learning/src/Support Vector Machine using Python/svm.py b/Machine_Learning/src/Support Vector Machine using Python/svm.py
new file mode 100644
index 00000000..ad45e768
--- /dev/null
+++ b/Machine_Learning/src/Support Vector Machine using Python/svm.py	
@@ -0,0 +1,165 @@
+import matplotlib.pyplot as plt
+from matplotlib import style
+import numpy as np
+
+style.use("ggplot")
+
+
+class Support_Vector_Machine:
+    def __init__(self, visualization=True):
+        self.visualization = visualization
+        self.colors = {1: "r", -1: "b"}
+        if self.visualization:
+            self.fig = plt.figure()
+            self.ax = self.fig.add_subplot(1, 1, 1)
+
+    # train
+    def fit(self, data):
+        self.data = data
+        # { ||w||: [w,b] }
+        opt_dict = {}
+
+        transforms = [[1, 1], [-1, 1], [-1, -1], [1, -1]]
+
+        all_data = []
+        for yi in self.data:
+            for featureset in self.data[yi]:
+                for feature in featureset:
+                    all_data.append(feature)
+
+        self.max_feature_value = max(all_data)
+        self.min_feature_value = min(all_data)
+        all_data = None
+
+        # support vectors yi(xi.w+b) = 1
+
+        step_sizes = [
+            self.max_feature_value * 0.1,
+            self.max_feature_value * 0.01,
+            # point of expense:
+            self.max_feature_value * 0.001,
+        ]
+
+        # extremely expensive
+        b_range_multiple = 2
+        # we dont need to take as small of steps
+        # with b as we do w
+        b_multiple = 5
+        latest_optimum = self.max_feature_value * 10
+
+        for step in step_sizes:
+            w = np.array([latest_optimum, latest_optimum])
+            # we can do this because convex
+            optimized = False
+            while not optimized:
+                for b in np.arange(
+                    -1 * (self.max_feature_value * b_range_multiple),
+                    self.max_feature_value * b_range_multiple,
+                    step * b_multiple,
+                ):
+                    for transformation in transforms:
+                        w_t = w * transformation
+                        found_option = True
+                        # weakest link in the SVM fundamentally
+                        # SMO attempts to fix this a bit
+                        # yi(xi.w+b) >= 1
+                        #
+                        # #### add a break here later..
+                        for i in self.data:
+                            for xi in self.data[i]:
+                                yi = i
+                                if not yi * (np.dot(w_t, xi) + b) >= 1:
+                                    found_option = False
+                                    # print(xi,':',yi*(np.dot(w_t,xi)+b))
+
+                        if found_option:
+                            opt_dict[np.linalg.norm(w_t)] = [w_t, b]
+
+                if w[0] < 0:
+                    optimized = True
+                    print("Optimized a step.")
+                else:
+                    w = w - step
+
+            norms = sorted([n for n in opt_dict])
+            # ||w|| : [w,b]
+            opt_choice = opt_dict[norms[0]]
+            self.w = opt_choice[0]
+            self.b = opt_choice[1]
+            latest_optimum = opt_choice[0][0] + step * 2
+
+        for i in self.data:
+            for xi in self.data[i]:
+                yi = i
+                print(xi, ":", yi * (np.dot(self.w, xi) + self.b))
+
+    def predict(self, features):
+        # sign( x.w+b )
+        classification = np.sign(np.dot(np.array(features), self.w) + self.b)
+        if classification != 0 and self.visualization:
+            self.ax.scatter(
+                features[0],
+                features[1],
+                s=200,
+                marker="*",
+                c=self.colors[classification],
+            )
+        return classification
+
+    def visualize(self):
+        [
+            [
+                self.ax.scatter(x[0], x[1], s=100, color=self.colors[i])
+                for x in data_dict[i]
+            ]
+            for i in data_dict
+        ]
+
+        # hyperplane = x.w+b
+        # v = x.w+b
+        # psv = 1
+        # nsv = -1
+        # dec = 0
+        def hyperplane(x, w, b, v):
+            return (-w[0] * x - b + v) / w[1]
+
+        datarange = (self.min_feature_value * 0.9, self.max_feature_value * 1.1)
+        hyp_x_min = datarange[0]
+        hyp_x_max = datarange[1]
+
+        # (w.x+b) = 1
+        # positive support vector hyperplane
+        psv1 = hyperplane(hyp_x_min, self.w, self.b, 1)
+        psv2 = hyperplane(hyp_x_max, self.w, self.b, 1)
+        self.ax.plot([hyp_x_min, hyp_x_max], [psv1, psv2], "k")
+
+        # (w.x+b) = -1
+        # negative support vector hyperplane
+        nsv1 = hyperplane(hyp_x_min, self.w, self.b, -1)
+        nsv2 = hyperplane(hyp_x_max, self.w, self.b, -1)
+        self.ax.plot([hyp_x_min, hyp_x_max], [nsv1, nsv2], "k")
+
+        # (w.x+b) = 0
+        # positive support vector hyperplane
+        db1 = hyperplane(hyp_x_min, self.w, self.b, 0)
+        db2 = hyperplane(hyp_x_max, self.w, self.b, 0)
+        self.ax.plot([hyp_x_min, hyp_x_max], [db1, db2], "y--")
+
+        plt.show()
+
+
+data_dict = {
+    -1: np.array([[1, 7], [2, 8], [3, 8]]),
+    1: np.array([[5, 1], [6, -1], [7, 3]]),
+}
+
+svm = Support_Vector_Machine()
+svm.fit(data=data_dict)
+
+predict_us = [[0, 10], [1, 3], [3, 4], [3, 5], [5, 5], [5, 6], [6, -5], [5, 8]]
+
+for p in predict_us:
+    svm.predict(p)
+
+svm.visualize()
+# result of this code is attached in file
diff --git a/Machine_Learning/src/kernels and Soft svm using python/src.py b/Machine_Learning/src/kernels and Soft svm using python/src.py
new file mode 100644
index 00000000..9bcea5d2
--- /dev/null
+++ b/Machine_Learning/src/kernels and Soft svm using python/src.py	
@@ -0,0 +1,246 @@
+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))
+        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)))
+
+        # 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))
+
+
+if __name__ == "__main__":
+    import pylab as pl
+
+    def gen_lin_separable_data():
+        # generate training data in the 2-d case
+        mean1 = np.array([0, 2])
+        mean2 = np.array([2, 0])
+        cov = np.array([[0.8, 0.6], [0.6, 0.8]])
+        X1 = np.random.multivariate_normal(mean1, cov, 100)
+        y1 = np.ones(len(X1))
+        X2 = np.random.multivariate_normal(mean2, cov, 100)
+        y2 = np.ones(len(X2)) * -1
+        return X1, y1, X2, y2
+
+    def gen_non_lin_separable_data():
+        mean1 = [-1, 2]
+        mean2 = [1, -1]
+        mean3 = [4, -4]
+        mean4 = [-4, 4]
+        cov = [[1.0, 0.8], [0.8, 1.0]]
+        X1 = np.random.multivariate_normal(mean1, cov, 50)
+        X1 = np.vstack((X1, np.random.multivariate_normal(mean3, cov, 50)))
+        y1 = np.ones(len(X1))
+        X2 = np.random.multivariate_normal(mean2, cov, 50)
+        X2 = np.vstack((X2, np.random.multivariate_normal(mean4, cov, 50)))
+        y2 = np.ones(len(X2)) * -1
+        return X1, y1, X2, y2
+
+    def gen_lin_separable_overlap_data():
+        # generate training data in the 2-d case
+        mean1 = np.array([0, 2])
+        mean2 = np.array([2, 0])
+        cov = np.array([[1.5, 1.0], [1.0, 1.5]])
+        X1 = np.random.multivariate_normal(mean1, cov, 100)
+        y1 = np.ones(len(X1))
+        X2 = np.random.multivariate_normal(mean2, cov, 100)
+        y2 = np.ones(len(X2)) * -1
+        return X1, y1, X2, y2
+
+    def split_train(X1, y1, X2, y2):
+        X1_train = X1[:90]
+        y1_train = y1[:90]
+        X2_train = X2[:90]
+        y2_train = y2[:90]
+        X_train = np.vstack((X1_train, X2_train))
+        y_train = np.hstack((y1_train, y2_train))
+        return X_train, y_train
+
+    def split_test(X1, y1, X2, y2):
+        X1_test = X1[90:]
+        y1_test = y1[90:]
+        X2_test = X2[90:]
+        y2_test = y2[90:]
+        X_test = np.vstack((X1_test, X2_test))
+        y_test = np.hstack((y1_test, y2_test))
+        return X_test, y_test
+
+    def plot_margin(X1_train, X2_train, clf):
+        def f(x, w, b, c=0):
+            # given x, return y such that [x,y] in on the line
+            # w.x + b = c
+            return (-w[0] * x - b + c) / w[1]
+
+        pl.plot(X1_train[:, 0], X1_train[:, 1], "ro")
+        pl.plot(X2_train[:, 0], X2_train[:, 1], "bo")
+        pl.scatter(clf.sv[:, 0], clf.sv[:, 1], s=100, c="g")
+
+        # w.x + b = 0
+        a0 = -4
+        a1 = f(a0, clf.w, clf.b)
+        b0 = 4
+        b1 = f(b0, clf.w, clf.b)
+        pl.plot([a0, b0], [a1, b1], "k")
+
+        # w.x + b = 1
+        a0 = -4
+        a1 = f(a0, clf.w, clf.b, 1)
+        b0 = 4
+        b1 = f(b0, clf.w, clf.b, 1)
+        pl.plot([a0, b0], [a1, b1], "k--")
+
+        # w.x + b = -1
+        a0 = -4
+        a1 = f(a0, clf.w, clf.b, -1)
+        b0 = 4
+        b1 = f(b0, clf.w, clf.b, -1)
+        pl.plot([a0, b0], [a1, b1], "k--")
+
+        pl.axis("tight")
+        pl.show()
+
+    def plot_contour(X1_train, X2_train, clf):
+        pl.plot(X1_train[:, 0], X1_train[:, 1], "ro")
+        pl.plot(X2_train[:, 0], X2_train[:, 1], "bo")
+        pl.scatter(clf.sv[:, 0], clf.sv[:, 1], s=100, c="g")
+
+        X1, X2 = np.meshgrid(np.linspace(-6, 6, 50), np.linspace(-6, 6, 50))
+        X = np.array([[x1, x2] for x1, x2 in zip(np.ravel(X1), np.ravel(X2))])
+        Z = clf.project(X).reshape(X1.shape)
+        pl.contour(X1, X2, Z, [0.0], colors="k", linewidths=1, origin="lower")
+        pl.contour(X1, X2, Z + 1, [0.0], colors="grey", linewidths=1, origin="lower")
+        pl.contour(X1, X2, Z - 1, [0.0], colors="grey", linewidths=1, origin="lower")
+
+        pl.axis("tight")
+        pl.show()
+
+    def test_linear():
+        X1, y1, X2, y2 = gen_lin_separable_data()
+        X_train, y_train = split_train(X1, y1, X2, y2)
+        X_test, y_test = split_test(X1, y1, X2, y2)
+
+        clf = SVM()
+        clf.fit(X_train, y_train)
+
+        y_predict = clf.predict(X_test)
+        correct = np.sum(y_predict == y_test)
+        print("%d out of %d predictions correct" % (correct, len(y_predict)))
+
+        plot_margin(X_train[y_train == 1], X_train[y_train == -1], clf)
+
+    def test_non_linear():
+        X1, y1, X2, y2 = gen_non_lin_separable_data()
+        X_train, y_train = split_train(X1, y1, X2, y2)
+        X_test, y_test = split_test(X1, y1, X2, y2)
+
+        clf = SVM(polynomial_kernel)
+        clf.fit(X_train, y_train)
+
+        y_predict = clf.predict(X_test)
+        correct = np.sum(y_predict == y_test)
+        print("%d out of %d predictions correct" % (correct, len(y_predict)))
+
+        plot_contour(X_train[y_train == 1], X_train[y_train == -1], clf)
+
+    def test_soft():
+        X1, y1, X2, y2 = gen_lin_separable_overlap_data()
+        X_train, y_train = split_train(X1, y1, X2, y2)
+        X_test, y_test = split_test(X1, y1, X2, y2)
+
+        clf = SVM(C=1000.1)
+        clf.fit(X_train, y_train)
+
+        y_predict = clf.predict(X_test)
+        correct = np.sum(y_predict == y_test)
+        print("%d out of %d predictions correct" % (correct, len(y_predict)))
+
+        plot_contour(X_train[y_train == 1], X_train[y_train == -1], clf)
+
+    # test_linear()
+    # test_non_linear()
+    test_soft()