Add files via upload

Author: vamsee91

Diff for: ML_classifiers.py

@@ -0,0 +1,183 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import sys
+from sklearn import datasets
+from sklearn import svm
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.feature_extraction.text import TfidfTransformer
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.linear_model import SGDClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.pipeline import Pipeline
+from sklearn import metrics
+from sklearn.externals import joblib
+from nltk.stem import *
+from nltk.stem.porter import *
+
+
+if __name__ == '__main__':
+
+  #train_file = open(sys.argv[1], 'r')
+  #test_file = open(sys.argv[2], 'r')
+
+  sizes = []
+  f1_scores_nb = []
+  f1_scores_svm = []
+  f1_scores_lr = []
+  f1_scores_rf = []
+
+  train_data = datasets.load_files("Selected 20NewsGroup/Training",decode_error='ignore',encoding='utf-8',shuffle=True)
+  test_data = datasets.load_files("Selected 20NewsGroup/Test",decode_error='ignore',encoding='utf-8')
+  docs_test = test_data.data
+
+  # Removing header
+  for i in range(len(train_data.data)):
+    train_data.data[i] = "\n".join(train_data.data[i].split("\n")[3:])
+
+  # Extracting features
+  count_vect = CountVectorizer()
+  X_train_counts = count_vect.fit_transform(train_data.data)
+
+  tf_transformer = TfidfTransformer(use_idf=False).fit(X_train_counts)
+  X_train_tf = tf_transformer.transform(X_train_counts)
+  tfidf_transformer = TfidfTransformer()
+  X_train_tfidf = tfidf_transformer.fit_transform(X_train_counts)
+
+  # Stemming data
+  stemmer = PorterStemmer()
+  words = []
+  st = []
+  for i in range(len(train_data.data)):
+    words = train_data.data[i].split(" ")
+    singles = [stemmer.stem(word) for word in words]
+    st.append(' '.join(singles))
+  
+
+  # Naive Bayes
+  print("Naive Bayes")
+  print("\n")
+  text_clf_nb = Pipeline([('vect', CountVectorizer(stop_words='english')),
+                     ('tfidf', TfidfTransformer()),
+                     ('clf', MultinomialNB()),
+                    ])
+  text_clf_1 = text_clf_nb.fit(st, train_data.target)
+  predicted1 = text_clf_1.predict(docs_test)
+  print(metrics.classification_report(test_data.target, predicted1, target_names=test_data.target_names))
+
+  # SVM Classifier
+  print("SVM Classifier")
+  print("\n")
+  text_clf_svm = Pipeline([('vect', CountVectorizer(stop_words='english')),
+                      ('tfidf', TfidfTransformer()),
+                      ('clf', SGDClassifier(loss='hinge',penalty='l2'))
+                      ])
+  text_clf_2 = text_clf_svm.fit(st, train_data.target)
+  predicted2 = text_clf_2.predict(docs_test)
+  #svm.SVC(kernel='rbf')
+  print(metrics.classification_report(test_data.target, predicted2, target_names=test_data.target_names)) 
+
+  #Logistic Regression
+  print("Logistic Regression")
+  print("\n")
+  text_clf_lr = Pipeline([('vect', CountVectorizer(stop_words='english')),
+                      ('tfidf', TfidfTransformer()),
+                      ('clf', LogisticRegression()),
+                      ])
+  text_clf_3 = text_clf_lr.fit(st, train_data.target)
+  predicted3 = text_clf_3.predict(docs_test)
+  print(metrics.classification_report(test_data.target, predicted3, target_names=test_data.target_names))
+
+  #Random Forest
+  print("Random Forest")
+  print("\n")
+  text_clf_rf = Pipeline([('vect', CountVectorizer(stop_words='english')),
+                      ('tfidf', TfidfTransformer()),
+                      ('clf', RandomForestClassifier()),
+                      ])
+  text_clf_4 = text_clf_rf.fit(st, train_data.target)
+  predicted4 = text_clf_4.predict(docs_test)
+  print(metrics.classification_report(test_data.target, predicted4, target_names=test_data.target_names))
+
+
+  # Splitting Training size
+  size1 = 0.2 * len(train_data.data)
+  sizes.append(size1)
+  
+  size2 = 0.4 * len(train_data.data)
+  sizes.append(size2)
+
+  size3 = 0.6 * len(train_data.data)
+  sizes.append(size3)
+
+  size4 = 0.8 * len(train_data.data)
+  sizes.append(size4)
+
+  # Loop for different splits in training sets
+  for s in sizes:
+    
+    train = train_data.data[0:int(s)]
+    train_target = train_data.target[0:int(s)]
+    #Naive Bayes
+    text_clf_split_nb = text_clf_nb.fit(train, train_target)
+    predicted_nb = text_clf_split_nb.predict(docs_test)
+    f1_scores_nb.append(metrics.f1_score(test_data.target, predicted_nb, average='macro'))
+
+    #SVM
+    text_clf_split_svm = text_clf_svm.fit(train, train_target)
+    predicted_svm = text_clf_split_svm.predict(docs_test)
+    f1_scores_svm.append(metrics.f1_score(test_data.target, predicted_svm, average='macro'))
+
+    #Logistic Regression
+    text_clf_split_lr = text_clf_lr.fit(train, train_target)
+    predicted_lr = text_clf_split_lr.predict(docs_test)
+    f1_scores_lr.append(metrics.f1_score(test_data.target, predicted_lr, average='macro'))
+
+    #Random Forest
+    text_clf_split_rf = text_clf_rf.fit(train, train_target)
+    predicted_rf = text_clf_split_rf.predict(docs_test)
+    f1_scores_rf.append(metrics.f1_score(test_data.target, predicted_rf, average='macro'))
+
+  #plt.title("Learning curve for Naive Bayes")
+  plt.ylabel("F1-scores")
+  plt.xlabel("Training Sizes")
+  plt.plot(sizes, f1_scores_nb, label="Naive Bayes")
+
+  #plt.title("Learning curve for SVM")
+  plt.ylabel("F1-scores")
+  plt.xlabel("Training Sizes")
+  plt.plot(sizes, f1_scores_svm, label="SVM")
+
+  #plt.title("Learning curve for Logistic Regression")
+  plt.ylabel("F1-scores")
+  plt.xlabel("Training Sizes")
+  plt.plot(sizes, f1_scores_lr, label="Logistic Regression")
+
+  #plt.title("Learning curve for Random Forest")
+  plt.ylabel("F1-scores")
+  plt.xlabel("Training Sizes")
+  plt.plot(sizes, f1_scores_rf, label="Random Forest")
+
+  plt.grid(True)
+  plt.legend(loc='best')
+  plt.title("Training Size vs F1-score")
+  plt.savefig("Legend plots")
+  plt.close()
+  
+  #Code to dump and load 
+
+  #joblib.dump(text_clf_2, 'classifier.pkl')
+  #classifier = joblib.load('classifier.pkl')
+  #predicted_temp = classifier.predict(docs_test)
+  #print("Loading.........")
+  #print(metrics.classification_report(test_data.target, predicted_temp, target_names=test_data.target_names)) 
+
+
+
+
+
+
+
+
+

Diff for: dsfb.py

@@ -0,0 +1,200 @@
+import sys
+import heapq
+from itertools import count
+import time
+
+
+class PriorityQueue:
+    def __init__(self):
+        self._queue = []
+        self.counter = count()
+
+    def put(self, item, priority):
+        heapq.heappush(self._queue, (priority, next(self.counter), item))
+
+    def get(self):
+        return heapq.heappop(self._queue)[2]
+
+    def empty(self):
+        return len(self._queue) == 0
+
+    def __str__(self):
+        return str(self._queue)
+
+
+class GraphColor:
+
+    def __init__(self, graph, values):
+
+        self.graph = graph
+        self.values = values
+        self.variables = list(self.graph.keys())
+        self.domains = {var: list(self.values) for var in self.variables}
+        self.curr_domains = None
+        self.search = 0
+        self.pruning = 0
+
+    # Checking consistency
+    def isConsistent(self, var, color):
+        self.load_domain()
+        for neigh in self.graph[var]:
+            if color == self.curr_domains[neigh]:
+                return False
+        return True
+
+    def isConsistentPlain(self, var, color, assign):
+        for neigh in self.graph[var]:
+            if neigh in assign:
+                if color == assign[neigh]:
+                    return False
+        return True
+
+    # Checking constraint satisfaction for arc consistency
+    def isconstraint(self, X, x, Y, y):
+        return x != y
+
+    def select_unassign_variable(self, assign):
+        if len(assign) == 0:
+            return self.variables[0]
+        for i in self.variables:
+            if i not in assign:
+                return i
+
+    # Minimum remaining variable
+    def select_unassigned_variable(self, assign):
+        self.load_domain()
+        unassign = [v for v in self.variables if v not in assign]
+        min = 9999999
+        for key in unassign:
+            if min > len(self.curr_domains[key]):
+                min = len(self.curr_domains[key])
+                v = key
+        return v
+
+    # Least constraining values
+    def order_domain_values(self, assign, var):
+        self.load_domain()
+        lis = []
+        res = []
+        queue = PriorityQueue()
+        for neigh in self.graph[var]:
+            lis.append(self.curr_domains[neigh])
+        k = sum([], lis)
+        for val in self.curr_domains[var]:
+            c = 0
+            for i in k:
+                if val == i:
+                    c += 1
+            queue.put(val, c)
+        while not queue.empty():
+            res.append(queue.get())
+        return res
+
+    def load_domain(self):
+        if self.curr_domains is None:
+            self.curr_domains = {v: list(self.domains[v]) for v in self.variables}
+
+    # List to maintain the (variable, value) that are removed for a specific variable
+    def remove(self, var, value):
+        self.load_domain()
+        rem = [(var, a) for a in self.curr_domains[var] if a != value]
+        self.curr_domains[var] = [value]
+        return rem
+
+    # Restore the removal list 
+    def restore(self, rem):
+        for var, color in rem:
+            self.curr_domains[var].append(color)
+
+    # Removing arc inconsistencies
+    def remove_inconsistent_values(self, xi, xj, rem):
+        removed = False
+        for x in self.curr_domains[xi]:
+            if all(not self.isconstraint(xi, x, xj, y) for y in self.curr_domains[xj]):
+                self.curr_domains[xi].remove(x)
+                if rem is not None:
+                    rem.append((xi, x))
+                removed = True
+        return removed
+
+    # Arc consistency code
+    def ac3(self, rem):
+        queue = [(a, b) for a in self.variables for b in self.graph[a]]
+        while len(queue) != 0:
+            (xi, xj) = queue.pop()
+            if self.remove_inconsistent_values(xi, xj, rem):
+                self.pruning += 1
+                for xk in self.graph[xi]:
+                    queue.append((xk, xi))
+
+    # DSFB code                
+    def dsfb_plain(self, assign):
+        if len(assign) == len(self.variables):
+            return assign
+        var = self.select_unassign_variable(assign)
+        for color in self.domains[var]:
+            if self.isConsistentPlain(var, color, assign):
+                assign[var] = color
+                res = self.dsfb_plain(assign)
+                if res != "fail":
+                    return res
+                del assign[var]
+        return "fail"
+
+    # DSFB++ code
+    def dsfb_improved(self, assign):
+        self.search += 1
+        if len(assign) == len(self.variables):
+            print("Search calls are {}".format(self.search))
+            print("Arc pruning calls are {}".format(self.pruning))
+            return assign
+        var = self.select_unassigned_variable(assign)
+        for color in self.order_domain_values(assign, var):
+            if self.isConsistent(var, color):
+                assign[var] = color
+                rem = self.remove(var, color)
+                self.ac3(rem)
+                res = self.dsfb_improved(assign)
+                if res != "fail":
+                    return res
+                self.restore(rem)
+                del assign[var]
+        return "fail"
+
+if __name__ == '__main__':
+
+    in_file = open(sys.argv[1], 'r')
+    out_file = open(sys.argv[2], 'w')
+    mode = sys.argv[3]
+    lis = []
+    adj = []
+    graph = {}
+    for line in in_file.readlines():
+        lis.append(line.rstrip().split())
+
+    for i in range(0,int(lis[0][0])):
+        graph[i] = []
+
+    # Constructing adjacency list of the given input
+    for edge in lis[1:]:
+        graph[int(edge[0])].append(int(edge[1]))
+        graph[int(edge[1])].append(int(edge[0]))
+
+    val = range(int(lis[0][2]))
+    assignment = {}
+    g = GraphColor(graph, val)
+    if mode == '0':
+        t = time.time()
+        asgn = g.dsfb_plain(assignment)
+        print("Time taken: {} ms".format((time.time() - t)*1000))
+    else:
+        t = time.time()
+        asgn = g.dsfb_improved(assignment)
+        print("Time taken: {} ms".format((time.time() - t)*1000))
+
+    if asgn == "fail":
+        print("No Answer")
+        out_file.write("No Answer")
+    else:
+        for i in list(asgn.values()):
+            out_file.write(str(i) + "\n")