In [110]:
import pprocess
# Define a function to parallelize:
def process_one_ddi(ddi):
"""A function to waste CPU cycles"""
one_ddi_family = LOO_out_performance_for_one_ddi(ddi)
one_ddi_family.get_LOO_perfermance('FisherM1', '')
# Parallel computation:
def parallel_process(function, ddis, nproc = 2):
# maximum number of simultaneous processes desired
results = pprocess.Map(limit=nproc, reuse=1)
parallel_function = results.manage(pprocess.MakeReusable(function))
[parallel_function(ddi) for ddi in ddis]; # Start computing things
return results[:]
In [114]:
res = parallel_process(test, [1,2,3,4,5])
In [115]:
res
Out[115]:
In [113]:
def test(x)
print x
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 [2]:
arrayofTuples = [('a',1,5),('b',2,4),('c',7,8)]
def breakTuples(t):
newList = list()
for item in t:
x = item[0]
y = item[1]
z = item[2]
a = tuple([x,y])
b = tuple([x,z])
newList.append(a)
newList.append(b)
newList.sort(key=lambda x:x[1])
return newList
print(breakTuples(arrayofTuples))
In [9]:
import numpy as np
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)
print
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]: