Tasks

sergeeva/Linear regression.py

@@ -0,0 +1,58 @@
+import numpy as np
+import scipy as sc
+import matplotlib.pyplot as pl
+from sklearn.utils import shuffle
+from sklearn import linear_model
+
+# Generate data
+x = np.linspace(10, 30, 1000)
+y = 0.75 * x + 1.35
+
+# Add noise
+noise = np.random.normal(0,0.5, y.size)
+y_noise = y + noise * 5
+
+# Make plot with noise
+pl.plot(x, y_noise, ',')
+pl.plot(x, y, 'k--', label ='Input')
+pl.legend(loc='best')
+
+
+# Train and test sets
+x = x.reshape((x.shape[0],-1))
+x, y_noise = shuffle(x, y_noise, random_state=1)
+x_train = x[:600]
+x_test = x[600:]
+y_train = y_noise[:600]
+y_test = y_noise[600:]
+
+print x_test.shape
+
+# Linear regression
+regr = linear_model.LinearRegression()
+regr.fit(x_train, y_train)
+
+print 'Coefficients: ', regr.coef_, regr.intercept_
+print "Residual sum of squares, train: ", np.mean((regr.predict(x_train) - y_train) ** 2)
+print "Residual sum of squares, test: ", np.mean((regr.predict(x_test) - y_test) ** 2)
+print 'R^2:', regr.score(x,y_noise)
+
+
+# Plot linear regression
+pl.scatter(x_train, y_train,  color='grey', label='Train')
+pl.scatter(x_test, y_test,  color='red', label='Test')
+pl.plot(x_test, regr.predict(x_test),'b-', label='Predict')
+y = 0.75 * x + 1.35
+pl.plot(x, y, 'k--', label='Input')
+pl.xlabel('X')
+pl.ylabel('Y')
+pl.legend(loc='best')
+
+
+# Second plot (to be continued...)
+pl.scatter(x, y_noise,  color='grey')
+pl.plot(x_test, regr.predict(x_test),'b-', label='Predict')
+pl.legend(loc='best')
+
+
+

sergeeva/classifier_KNN_and_RF.py

@@ -0,0 +1,81 @@
+import numpy as np
+import matplotlib.pyplot as pl
+from sklearn.utils import shuffle
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.ensemble import RandomForestClassifier
+
+#Import dataset
+red = np.loadtxt("./red.txt")
+blue = np.loadtxt("./blue.txt")
+
+#Plot data
+pl.prism()
+plt.xlim(-1.2, 1.2)
+plt.ylim(-1.2, 1.2)
+pl.scatter(red[:, 0], red[:, 1], c='red')
+pl.scatter(blue[:, 0], blue[:, 1], c='blue')
+
+#Prepare data for analysis
+reds = np.hstack ((red, [[1]] * len (red) ))
+blues = np.hstack  ((blue, [[0]] * len (blue) ))
+dots = np.concatenate((reds, blues), axis=0)
+x = dots[:, :-1]
+y = dots[:, 2]
+
+#Train and test sets
+x, y = shuffle(x, y, random_state=1)
+size=dots.shape[0] * 0.8
+x_train = x[:size]
+y_train = y[:size]
+x_test = x[size:]
+y_test = y[size:]
+
+#Build clussifier (KNN)
+knn = KNeighborsClassifier(n_neighbors=5)
+knn.fit(x_train, y_train)
+print 'Accuracy of KNN train set:', knn.score(x_train, y_train)
+print 'Accuracy of KNN test set:', knn.score(x_test, y_test)
+
+#Plot KNN
+y_pred_test_KNN = knn.predict(x_test)
+plt.xlim(-1.2, 1.2)
+plt.ylim(-1.2, 1.2)
+plt.scatter(x_test[:, 0], x_test[:, 1], c=y_pred_test_KNN, marker='^')
+plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)
+
+#Build clussifier (Random forest)
+rf = RandomForestClassifier(n_estimators=10)
+rf.fit(x_train, y_train)
+print 'Accuracy of Random Forest train set:', rf.score(x_train, y_train)
+print 'Accuracy of Random Forest test set:', rf.score(x_test, y_test)
+
+#Plot RF
+y_pred_test_RF = rf.predict(x_test)
+plt.xlim(-1.2, 1.2)
+plt.ylim(-1.2, 1.2)
+plt.scatter(x_test[:, 0], x_test[:, 1], c=y_pred_test+RF, marker='^')
+plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train)
+
+#Predict color
+def predict_KNN(a,b):
+    if knn.predict([a, b]) == 0:
+        return 'blue'
+    else:
+        return 'red'
+
+def predict_RF(a,b):
+    if rf.predict([a, b]) == 0:
+        return 'blue'
+    else:
+        return 'red'
+
+a = raw_input()
+b = raw_input()
+print 'Predict color KNN:', predict_KNN(a,b)
+print 'Predict color RF:', predict_RF(a,b)
+
+print 'Best model is:'
+if rf.score(x_test, y_test) >= knn.score(x_test, y_test):
+    print 'Random forest'
+else:
+    print 'K-Nearest Neighbors'

sergeeva/gen_binary.py

@@ -0,0 +1,11 @@
+k = 3
+def gen_bin(a,p):
+	if p < k:
+		a[p] = 0
+		gen_bin(a, p+1)
+		a[p] = 1
+		gen_bin(a, p+1)
+	else:
+		print(a)
+
+gen_bin([0 for i in range (k)], 0)

sergeeva/generators/allvectors.py

@@ -0,0 +1,16 @@
+infile = open('allvectors.in', 'r')
+outfile = open('allvectors.out', 'w')
+n = int(infile.readline().strip())
+
+a=[0]*n
+def gen_bin(a,p):
+    if p < n:
+        a[p] = 0
+        gen_bin(a, p+1)
+        a[p] = 1
+        gen_bin(a, p+1)
+    else:
+        outfile.write(str(''.join([str(i) for i in a])) + '\n')
+gen_bin(a,0)
+infile.close()
+outfile.close()

sergeeva/generators/choose.py

@@ -0,0 +1,20 @@
+infile = open('choose.in', 'r')
+outfile = open('choose.out', 'w')
+
+n, k = [int(i) for i in infile.readline().split()]
+seq=range(1,n+1)
+
+def choose(seq, k):
+    if k == 0:
+        yield []
+    else:
+        for i, x in enumerate(seq):
+            for c in choose(seq[i+1:], k-1):
+                yield [x] +c
+
+for i in choose(seq, k):
+    outfile.write(str.join(' ', (str(j) for j in i)) + '\n')
+
+infile.close()
+outfile.close()
+

sergeeva/generators/permutations1.py

@@ -0,0 +1,22 @@
+infile = open('permutations.in', 'r')
+outfile = open('permutations.out', 'w')
+
+n = int(infile.readline().strip())
+seq=range(1,n+1)
+
+ans=[]
+
+def permutation(seq, i):
+    if i == len(seq)-1:
+        ans.append(str(''.join([str(i) for i in seq])))
+    else:
+        for j in range(i, len(seq)):
+            seq[i], seq[j] = seq[j], seq[i]
+            permutation(seq, i+1)
+            seq[i], seq[j] = seq[j], seq[i] 
+
+permutation(seq, 0)
+for i in sorted(ans):
+	outfile.write(str(' '.join([str(j) for j in i])+'\n'))
+infile.close()
+outfile.close()

sergeeva/generators/permutations2.py

@@ -0,0 +1,20 @@
+#permutations code from class work
+
+infile = open('permutations.in', 'r')
+outfile = open('permutations.out', 'w')
+
+n = int(infile.readline().strip())
+def gen_perm(a, p):
+	if p < n:
+		for i in range(1, n+1):
+			if i not in a:
+				a[p] = i
+				gen_perm(a, p+1) 
+				a[p] = 0
+	else:
+		outfile.write(str.join(' ', (str(i) for i in a))+'\n')
+
+gen_perm([0 for i in range (n)], 0)
+
+infile.close()
+outfile.close()

sergeeva/generators/vectors.py

@@ -0,0 +1,29 @@
+import re
+infile = open('vectors.in', 'r')
+outfile = open('vectors.out', 'w')
+
+n = int(infile.readline().strip())
+
+a = [0]*n
+all_bin=[]
+def gen_bin(a,p):
+	if p < n:
+		a[p] = 0
+		gen_bin(a, p+1)
+		a[p] = 1
+		gen_bin(a, p+1)
+	else:
+		all_bin.append(str(''.join([str(i) for i in a])))
+
+gen_bin(a,0)
+
+ones=[]
+for i in all_bin:
+	for match in re.findall('11', i):
+		ones.append(i)
+ans=sorted(list(set(all_bin).difference(set(ones))))
+
+outfile.write(str(len(ans))+'\n')
+outfile.write(str('\n'.join([str(i) for i in ans])))
+infile.close()
+outfile.close()

sergeeva/graphs/comp.py

@@ -0,0 +1,41 @@
+from collections import deque
+
+infile = open('components.in', 'r')
+outfile = open('components.out', 'w')
+
+n,e = [int(i) for i in infile.readline().split()] 
+
+#edgelist
+edges=[] 
+for i in range(e):
+    edges.append([int(j) for j in infile.readline().split()])
+
+#neighbours
+from collections import defaultdict
+neighbours = defaultdict(lambda: defaultdict(lambda: 0))
+for v1, v2 in edges:
+    neighbours[v1][v2] += 1
+    neighbours[v2][v1] += 1
+
+def dfs():
+    num_component ={}
+    comp = 0
+    for i in range(1, n+1):
+        if i not in num_component:
+            comp += 1
+            num_component[i] = comp
+            queue = deque([i])
+            while len(queue) > 0:
+                for v in neighbours[queue[0]]:
+                    if v not in num_component:
+                        num_component[v] = comp
+                        queue.append(v)
+                queue.popleft()
+    outfile.write(str(comp)+ '\n')
+    for i in num_component.values():
+        outfile.write(str(i)+' ')
+dfs()
+
+
+infile.close()
+outfile.close()

sergeeva/graphs/pathbge1.py

@@ -0,0 +1,44 @@
+infile = open('pathbge1.in', 'r')
+outfile = open('pathbge1.out', 'w')
+
+n,e = [int(i) for i in infile.readline().split()] 
+
+#edgelist
+edges=[] 
+for i in range(e):
+    edges.append([int(j) for j in infile.readline().split()])
+
+#linking edges
+def link(u, v):
+    if u not in graph:
+        graph[u] = {}
+    (graph[u])[v] = 1
+    if v not in graph:
+        graph[v] = {}
+    (graph[v])[u] = 1
+    return graph
+
+graph = {}
+for (x,y) in edges: 
+    link(x,y)
+dist = {} #distance
+
+def bfs (s, v):
+    q = [s] #queue
+    dist[s] = 0
+    while len(q) > 0:
+        current = q.pop(0)
+        for i in graph[current].keys():
+            if i not in dist:
+                dist[i] = dist[current] + 1
+                if i == v:
+                    return dist[v]
+                q.append(i)
+    return dist
+
+bfs(1,n+1)
+for j in dist.values():
+    outfile.write(str(j) + ' ')
+
+infile.close()
+outfile.close()

sergeeva/graphs/pathmgep.py

@@ -0,0 +1,35 @@
+infile = open('pathmgep.in', 'r')
+outfile = open('pathmgep.out', 'w')
+
+n, S, F = [int(i) for i in infile.readline().split()] 
+
+dist = []
+
+sum=0
+for line in infile.read().splitlines():
+    values = [int(i) for i in line.split()]
+    dist.append(values)
+    for i in values:
+    	if i>0:
+    		sum+=i
+
+for i in range(n):
+    for j in range(n):
+       	if dist[i][j] == -1:
+       		dist[i][j] = sum +1
+
+def floyd(dist): 
+    for k in range(n):
+        for i in range(n):
+            for j in range(n):
+                dist[i][j] = min(dist[i][j], (dist[i][k] + dist[k][j]))
+
+
+floyd(dist)
+
+if dist[S-1][F-1]>=sum:
+	dist[S-1][F-1]=-1
+
+outfile.write(str(dist[S-1][F-1]))
+infile.close()
+outfile.close()