In [6]:
from itertools import izip #new
from sklearn import cross_validation
kf = cross_validation.KFold(10, n_folds=2, shuffle = True)
for ((train_index, test_index),subset_no) in izip(kf,range(1,11)):
#for train_index, test_index in kf;
print("Subset:", subset_no)
print("Train index: ", train_index)
print("Test index: ", test_index)
In [2]:
score = {}
score['accuracy'] = 1
score['precision'] = 2
score['recall'] = 3
In [4]:
score.values()
Out[4]:
In [4]:
class Node:
def __init__(self, val, neighbors = None):
self.val = val
self.neighbors = neighbors
lst = [Node(1), Node(3)]
while lst:
print lst.pop().val
In [10]:
dic = {}
new = Node(1)
dic[new] = True
dic[Node(1)] = True
In [36]:
class Solution:
# @param tokens, a list of string
# @return an integer
def evalRPN(self, tokens):
if not tokens:
return None
ops = ['+', '-', '*', '/']
stack = []
for token in tokens:
if not (token in ops):
stack.append(token)
else:
print stack
op1 = int(stack.pop())
op2 = int(stack.pop())
if token == '+':
result = op1 + op2
if token == '-':
result = op2 - op1
if token == '*':
result = op2 * op1
if token == '/':
if op2 * op1 >= 0:
result = op2 / op1
else:
result = - (abs(op2) / abs(op1))
stack.append(str(result))
return int(stack[0])
In [58]:
c= Solution()
c.evalRPN(["10","6","9","3","+","-11","*","/","*","17","+","5","+"])
Out[58]:
In [31]:
eval('6/-132')
Out[31]:
In [53]:
a = {2:True}
In [54]:
a[(1,3)] = False
In [60]:
a[c]=True
In [49]:
b = [2,3]
In [76]:
class Solution:
# @param tokens, a list of string
# @return an integer
def evalRPN(self, tokens):
stack = []
for token in tokens:
if token in ['+', '-', '*', '/']:
op1 = stack.pop()
op2 = stack.pop()
if token == '+': stack.append(op1 + op2)
elif token == '-': stack.append(op1 - op2)
elif token == '*': stack.append(op1 * op2)
elif token == '/': stack.append(op1 / op2)
else:
stack.append(int(token))
In [6]:
a =3; c=4
In [3]:
4
Out[3]:
In [11]:
a = np.random.random([10,1000])
In [16]:
np.mean(a, axis=1)
Out[16]:
In [37]:
import sklearn.preprocessing
class Precessing_Scaler_0_9(sklearn.preprocessing.StandardScaler):
def __init__(self):
super(Precessing_Scaler_0_9, self).__init__(self, with_std=0.333)
def transform(self, X): # transform data to 0.1 to 0.9
new_X = super(Precessing_Scaler_0_9, self).transform(X)
new_X[new_X > 1] = 1
new_X[new_X < -1] = -1
new_X = (new_X + 1) * 0.4 + 0.1
return new_X
def fit_transform(self):
print 'Did not implement'
In [61]:
def performance_score(target_label, predicted_label, predicted_score = False, print_report = True):
""" get performance matrix for prediction
Attributes:
target_label: int 0, 1
predicted_label: 0, 1 or ranking
predicted_score: bool if False, predicted_label is from 0, 1. If Ture, predicted_label is ranked, need to get AUC score.
print_report: if True, print the perfromannce on screen
"""
import sklearn
from sklearn.metrics import roc_auc_score
score = {}
if predicted_score == False:
score['accuracy'] = sklearn.metrics.accuracy_score(target_label, predicted_label)
score['precision'] = sklearn.metrics.precision_score(target_label, predicted_label, pos_label=1)
score['recall'] = sklearn.metrics.recall_score(target_label, predicted_label, pos_label=1)
if predicted_score == True:
auc_score = roc_auc_score(target_label, predicted_label)
score['auc_score'] = auc_score
target_label = [x >= 0.5 for x in target_label]
score['accuracy'] = sklearn.metrics.accuracy_score(target_label, predicted_label)
score['precision'] = sklearn.metrics.precision_score(target_label, predicted_label, pos_label=1)
score['recall'] = sklearn.metrics.recall_score(target_label, predicted_label, pos_label=1)
if print_report == True:
for key, value in score.iteritems():
print key, '{percent:.1%}'.format(percent=value)
return score
In [62]:
scaler = PrecessingScaler(with_std=0.333)
In [77]:
performance_score([1,1,0,0], [1,0,0,0])
Out[77]:
In [78]:
a = [2,3,2,3,4]
In [83]:
Out[83]:
In [51]:
d = transform_to_1_9.transform(c)
In [52]:
Out[52]:
In [ ]:
standard_scaler = preprocessing.StandardScaler().fit(train_X_reduced)
scaled_train_X = standard_scaler.transform(train_X_reduced)
scaled_test_X = standard_scaler.transform(test_X)
In [6]:
'''
1.1 Implement an algorithm to determine if a string has all unique characters.What
if you can not use additional data structures?
'''
def demo(text):
result = 0
for i in text:
flag = (1 << ord(i))
#print "i, flag, result = ", i, flag, result
if result & flag > 0:
return False
else:
result |= flag
return True
def demo2(text):
text = ''.join(sorted(text))
for i in range(1, len(text)):
if text[i] == text[i-1]:
return False
return True
import random
import unittest
class TestSequenceFunctions(unittest.TestCase):
def setUp(self):
self.seq = range(10)
def test_shuffle(self):
# make sure the shuffled sequence does not lose any elements
random.shuffle(self.seq)
self.seq.sort()
self.assertEqual(self.seq, range(10))
# should raise an exception for an immutable sequence
self.assertRaises(TypeError, random.shuffle, (1,2,3))
def test_choice(self):
element = random.choice(self.seq)
self.assertTrue(element in self.seq)
def test_sample(self):
with self.assertRaises(ValueError):
random.sample(self.seq, 20)
for element in random.sample(self.seq, 5):
self.assertTrue(element in self.seq)
if __name__ == '__main__':
unittest.main()
In [6]:
'''
1.2 Write code to reverse a C-Style String (C-String means that "abcd" is represented as
five characters, including the null character )
'''
def demo(text):
return text[::-1]
import unittest
class MyTestCases(unittest.TestCase):
def test_mycase(self):
self.demo = demo
self.assertEqual(self.demo(""), "")
self.assertEqual(self.demo("abcd"), "dcba")
self.assertEqual(self.demo("abcdabcd"), "dcbadcba")
self.assertEqual(self.demo("1314"), "4131")
#unittest.main()
In [14]:
1<<2
Out[14]: