def test_collapse(self):
names = np.array([
'r', '2', '3', None, '4', None, '5', '6', None, None, None, '7',
None, '8', '9', '10', None, '11', None, None, None, None
])
lengths = np.array([
0, 1, 2, 0, 3, 0, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9, 0, 10, 0, 0, 0, 0
],
dtype=np.double)
self.BP.set_names(names)
self.BP.set_lengths(lengths)
exp = np.array([1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0],
dtype=np.uint8)
exp_n = [
'r', '2', '3', None, '4', None, '6', None, None, '7', None, '9',
'10', None, '11', None, None, None
]
exp_l = [0, 1, 2, 0, 3, 0, 9, 0, 0, 6, 0, 15, 9, 0, 10, 0, 0, 0]
obs = self.BP.collapse()
npt.assert_equal(obs.B, exp)
for i in range(len(obs.B)):
self.assertEqual(obs.name(i), exp_n[i])
self.assertEqual(obs.length(i), exp_l[i])
bp = BP(np.array([1, 1, 1, 0, 0, 1, 0, 0], dtype=np.uint8))
exp = np.array([1, 1, 0, 1, 0, 0])
obs = bp.collapse().B
npt.assert_equal(obs, exp)
def test_bp_to_bpc(self):
print("##################test from bp -> bpc####################")
responses.add(responses.POST,
HOST + '/v1/chain/get_producers',
json=fake_json_1,
status=200)
responses.add(responses.POST,
HOST + '/v1/chain/get_table_rows',
json=fake_table_data,
status=200)
bp = BP("eoslemonscom", True)
bp_monitor = BPMonitor(bp)
bp_monitor.check_is_top21()
self.assertTrue(bp.is_top21)
self.assertFalse(bp.is_new_top21)
responses.remove(responses.POST, HOST + '/v1/chain/get_producers')
responses.add(responses.POST,
HOST + '/v1/chain/get_producers',
json=fake_json,
status=200)
responses.add(responses.POST,
HOST + '/v1/chain/get_table_rows',
json=fake_table_data,
status=200)
# be the bpc
bp_monitor.check_is_top21()
self.assertFalse(bp.is_top21)
self.assertFalse(bp.is_new_top21)
print("##################test from bp -> bpc####################\n")
print("\n")
def test_not_in_top21_list(self):
print("###################test not in top 21 #####################")
responses.add(responses.POST, HOST + '/v1/chain/get_producers',
json=fake_json, status=200)
responses.add(responses.POST, HOST + '/v1/chain/get_table_rows',
json=fake_table_data, status=200)
bp = BP("eoslemonscom", False)
bp_monitor = BPMonitor(bp)
bp_monitor.check_is_top21()
self.assertFalse(bp.is_top21)
self.assertFalse(bp.is_new_top21)
print("###################test not in top 21 #####################\n")
print("\n")
def test_check_is_producing(self):
print("##################test check is producing####################")
responses.add(responses.GET, HOST + '/v1/chain/get_info',
json=fake_info, status=200)
responses.add(responses.POST, HOST + '/v1/chain/get_table_rows',
json=fake_table_data, status=200)
bp = BP('eoslaomaocom', True)
bp_monitor = BPMonitor(bp)
self.assertTrue(bp_monitor.check_is_producing())
self.assertTrue(bp.is_top21)
print("##################test check is producing####################\n")
print("\n")
def test_collapse(self):
names = np.array(['r', '2', '3', None, '4', None, '5', '6', None, None, None, '7', None, '8', '9', '10', None,
'11', None, None, None, None])
lengths = np.array([0, 1, 2, 0, 3, 0, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9, 0, 10, 0, 0, 0, 0], dtype=np.double)
self.BP.set_names(names)
self.BP.set_lengths(lengths)
exp = np.array([1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0],
dtype=np.uint8)
exp_n = ['r', '2', '3', None, '4', None, '6', None, None, '7', None, '9', '10', None, '11', None, None, None]
exp_l = [0, 1, 2, 0, 3, 0, 9, 0, 0, 6, 0, 15, 9, 0, 10, 0, 0, 0]
obs = self.BP.collapse()
npt.assert_equal(obs.B, exp)
for i in range(len(obs.B)):
self.assertEqual(obs.name(i), exp_n[i])
self.assertEqual(obs.length(i), exp_l[i])
bp = BP(np.array([1, 1, 1, 0, 0, 1, 0, 0], dtype=np.uint8))
exp = np.array([1, 1, 0, 1, 0, 0])
obs = bp.collapse().B
npt.assert_equal(obs, exp)
def setUp(self):
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
self.fig1_B = np.array(
[1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0],
dtype=np.uint8)
self.BP = BP(self.fig1_B)
class BPTests(TestCase):
def setUp(self):
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
self.fig1_B = np.array(
[1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0],
dtype=np.uint8)
self.BP = BP(self.fig1_B)
def test_rmq(self):
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
#excess 1 2 3 2 3 2 3 4 3 2 1 2 1 2 3 4 3 4 3 2 1 0
#i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
exp = [[
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21
],
[
1, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 21
],
[
2, 3, 3, 3, 3, 3, 3, 3, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 21
],
[
3, 3, 3, 3, 3, 3, 3, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 21
],
[
4, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 21
],
[5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[6, 6, 6, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[7, 8, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[8, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 21],
[12, 12, 12, 12, 12, 12, 12, 12, 12, 21],
[13, 13, 13, 13, 13, 13, 13, 20, 21],
[14, 14, 14, 14, 14, 19, 20, 21], [15, 16, 16, 16, 19, 20, 21],
[16, 16, 16, 19, 20, 21], [17, 18, 19, 20, 21],
[18, 19, 20, 21], [19, 20, 21], [20, 21], [21]]
for i in range(len(self.fig1_B)):
for j in range(i + 1, len(self.fig1_B)):
self.assertEqual(self.BP.rmq(i, j), exp[i][j - i])
def test_rMq(self):
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
#excess 1 2 3 2 3 2 3 4 3 2 1 2 1 2 3 4 3 4 3 2 1 0
#i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
exp = [[
0, 1, 2, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
], [1, 2, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[2, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[3, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[8, 8, 8, 8, 8, 8, 8, 15, 15, 15, 15, 15, 15, 15],
[9, 9, 9, 9, 9, 14, 15, 15, 15, 15, 15, 15, 15],
[10, 11, 11, 11, 14, 15, 15, 15, 15, 15, 15, 15],
[11, 11, 11, 14, 15, 15, 15, 15, 15, 15, 15],
[12, 13, 14, 15, 15, 15, 15, 15, 15, 15],
[13, 14, 15, 15, 15, 15, 15, 15, 15],
[14, 15, 15, 15, 15, 15, 15, 15], [15, 15, 15, 15, 15, 15, 15],
[16, 17, 17, 17, 17, 17], [17, 17, 17, 17, 17],
[18, 18, 18, 18], [19, 19, 19], [20, 20], [21]]
for i in range(len(self.fig1_B)):
for j in range(i + 1, len(self.fig1_B)):
self.assertEqual(self.BP.rMq(i, j), exp[i][j - i])
def test_mincount(self):
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
#i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
#excess 1 2 3 2 3 2 3 4 3 2 1 2 1 2 3 4 3 4 3 2 1 0
exp = [[
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 1
], [1, 1, 2, 2, 3, 3, 3, 3, 4, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 2, 2, 2, 2, 3, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 2, 2, 2, 2, 3, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 2, 1], [1, 1, 1, 1, 1, 1, 2, 1, 1],
[1, 1, 2, 2, 3, 1, 1, 1], [1, 1, 1, 2, 1, 1, 1],
[1, 1, 2, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1],
[1, 1], [1]]
for i in range(len(self.fig1_B)):
for j in range(i + 1, len(self.fig1_B)):
self.assertEqual(self.BP.mincount(i, j), exp[i][j - i])
def test_minselect(self):
"""position of the qth minimum in excess(i), excess(i + 1), . . . , excess(j)."""
exp = {
(0, 20, 1): 0,
(0, 21, 1): 21,
(0, 20, 2): 10,
(0, 21, 2): None,
(0, 20, 3): 12,
(0, 20, 4): 20,
(8, 15, 1): 10,
(8, 15, 2): 12,
(6, 9, 1): 9
}
for (i, j, q), e in exp.items():
self.assertEqual(self.BP.minselect(i, j, q), e)
def test_preorder(self):
exp = [
1, 2, 3, 3, 4, 4, 5, 6, 6, 5, 2, 7, 7, 8, 9, 10, 10, 11, 11, 9, 8,
1
]
for i, e in enumerate(exp):
self.assertEqual(self.BP.preorder(i), e)
def test_preorderselect(self):
exp = [0, 1, 2, 4, 6, 7, 11, 13, 14, 15, 17]
for k, e in enumerate(exp):
self.assertEqual(self.BP.preorderselect(k), e)
def test_postorder(self):
exp = [
11, 5, 1, 1, 2, 2, 4, 3, 3, 4, 5, 6, 6, 10, 9, 7, 7, 8, 8, 9, 10,
11
]
for i, e in enumerate(exp):
self.assertEqual(self.BP.postorder(i), e)
def test_postorderselect(self):
exp = [2, 4, 7, 6, 1, 11, 15, 17, 14, 13, 0]
for k, e in enumerate(exp):
self.assertEqual(self.BP.postorderselect(k + 1), e)
def test_isancestor(self):
exp = {
(0, 0): False, # identity test
(2, 1): False, # tip test
(1, 2): True, # open test
(1, 3): True, # close test
(0, 7): True, # nested test
(1, 7): True
} # nested test
for (i, j), e in exp.items():
self.assertEqual(self.BP.isancestor(i, j), e)
def test_subtree(self):
exp = [
11, 5, 1, 1, 1, 1, 2, 1, 1, 2, 5, 1, 1, 4, 3, 1, 1, 1, 1, 3, 4, 11
]
for i, e in enumerate(exp):
self.assertEqual(self.BP.subtree(i), e)
def test_levelancestor(self):
exp = {
(2, 1): 1, # first tip to its parent
(2, 2): 0, # first tip to root
(4, 1): 1, # second tip to its parent
(5, 1): 1, # second tip, closing, to its parent
(7, 1): 6, # deep tip to its parent
(7, 2): 1, # deep tip to its grandparent
(7, 3): 0, # deep tip to its great grand parent
(7, 9999): 0, # max out at the root
(10, 0): -1
} # can't be an ancestor of yourself
for (i, d), e in exp.items():
self.assertEqual(self.BP.levelancestor(i, d), e)
def _testinator(self, exp, f, verbose=False):
self.assertEqual(len(exp), len(self.fig1_B))
for i, e in enumerate(exp):
if verbose:
print(i, e)
self.assertEqual(f(i), e)
def test_levelnext(self):
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
exp = [
-1, 11, 4, 4, 6, 6, 14, 15, 15, 14, 11, 13, 13, -1, -1, 17, 17, -1,
-1, -1, -1, -1
]
self.assertEqual(len(exp), len(self.fig1_B))
for i, e in enumerate(exp):
self.assertEqual(self.BP.levelnext(i), e)
def test_close(self):
exp = [21, 10, 3, 5, 9, 8, 12, 20, 19, 16, 18]
for i, e in zip(np.argwhere(self.BP.B == 1).squeeze(), exp):
npt.assert_equal(self.BP.close(i), e)
def test_lca(self):
# lca(i, j) = parent(rmq(i, j) + 1)
# unless isancestor(i, j)
# (so lca(i, j) = i) or isancestor(j, i) (so lca(i, j) = j),
nodes = [self.BP.preorderselect(k) for k in range(self.fig1_B.sum())]
exp = {
(nodes[2], nodes[3]): nodes[1],
(nodes[2], nodes[5]): nodes[1],
(nodes[2], nodes[9]): nodes[0],
(nodes[9], nodes[10]): nodes[8],
(nodes[1], nodes[8]): nodes[0]
}
for (i, j), e in exp.items():
self.assertEqual(self.BP.lca(i, j), e)
def test_deepestnode(self):
# deepestnode(i) = rMq(i, close(i)),
exp = [
7, 7, 2, 2, 4, 4, 7, 7, 7, 7, 7, 11, 11, 15, 15, 15, 15, 17, 17,
15, 15, 7
]
self._testinator(exp, self.BP.deepestnode)
def test_height(self):
# height(i) = excess(deepestnode(i)) − excess(i).
exp = [
3, 2, 0, 0, 0, 0, 1, 0, 0, 1, 2, 0, 0, 2, 1, 0, 0, 0, 0, 1, 2, 3
]
self._testinator(exp, self.BP.height)
def test_ntips(self):
exp = 6
obs = self.BP.ntips()
self.assertEqual(obs, exp)
def test_shear(self):
# r 2 3 4 5 6 7 8 9 10 11
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
#i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
names = np.array([
'r', '2', '3', None, '4', None, '5', '6', None, None, None, '7',
None, '8', '9', '10', None, '11', None, None, None, None
])
lengths = np.array([
0, 1, 2, 0, 3, 0, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9, 0, 10, 0, 0, 0, 0
],
dtype=np.double)
self.BP.set_names(names)
self.BP.set_lengths(lengths)
in_ = {'4', '6', '7', '10', '11'}
exp = np.array(
[1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0],
dtype=np.uint32)
exp_n = np.array([
'r', '2', '4', None, '5', '6', None, None, None, '7', None, '8',
'9', '10', None, '11', None, None, None, None
])
exp_l = np.array(
[0, 1, 3, 0, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9, 0, 10, 0, 0, 0, 0],
dtype=np.double)
obs = self.BP.shear(in_)
npt.assert_equal(exp, obs.B)
for i in range(len(obs.B)):
self.assertEqual(obs.name(i), exp_n[i])
self.assertEqual(obs.length(i), exp_l[i])
in_ = {'10', '11'}
exp = np.array([1, 1, 1, 1, 0, 1, 0, 0, 0, 0], dtype=np.uint32)
obs = self.BP.shear(in_).B
npt.assert_equal(obs, exp)
def test_shear_raise_tree_is_empty(self):
names = np.array([
'r', '2', '3', None, '4', None, '5', '6', None, None, None, '7',
None, '8', '9', '10', None, '11', None, None, None, None
])
lengths = np.array([
0, 1, 2, 0, 3, 0, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9, 0, 10, 0, 0, 0, 0
],
dtype=np.double)
self.BP.set_names(names)
with self.assertRaises(ValueError):
self.BP.shear({'not', 'in', 'tree'})
def test_collapse(self):
names = np.array([
'r', '2', '3', None, '4', None, '5', '6', None, None, None, '7',
None, '8', '9', '10', None, '11', None, None, None, None
])
lengths = np.array([
0, 1, 2, 0, 3, 0, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9, 0, 10, 0, 0, 0, 0
],
dtype=np.double)
self.BP.set_names(names)
self.BP.set_lengths(lengths)
exp = np.array([1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0],
dtype=np.uint8)
exp_n = [
'r', '2', '3', None, '4', None, '6', None, None, '7', None, '9',
'10', None, '11', None, None, None
]
exp_l = [0, 1, 2, 0, 3, 0, 9, 0, 0, 6, 0, 15, 9, 0, 10, 0, 0, 0]
obs = self.BP.collapse()
npt.assert_equal(obs.B, exp)
for i in range(len(obs.B)):
self.assertEqual(obs.name(i), exp_n[i])
self.assertEqual(obs.length(i), exp_l[i])
bp = BP(np.array([1, 1, 1, 0, 0, 1, 0, 0], dtype=np.uint8))
exp = np.array([1, 1, 0, 1, 0, 0])
obs = bp.collapse().B
npt.assert_equal(obs, exp)
def test_name_unset(self):
for i in range(self.BP.B.size):
self.assertEqual(self.BP.name(i), None)
def test_length_unset(self):
for i in range(self.BP.B.size):
self.assertEqual(self.BP.length(i), 0.0)
def test_name_length_set(self):
names = np.full(self.BP.B.size, None, dtype=object)
lengths = np.zeros(self.BP.B.size, dtype=np.double)
names[0] = 'root'
names[self.BP.preorderselect(7)] = 'other'
lengths[1] = 1.23
lengths[self.BP.preorderselect(5)] = 5.43
self.BP.set_names(names)
self.BP.set_lengths(lengths)
self.assertEqual(self.BP.name(0), 'root')
self.assertEqual(self.BP.name(1), None)
self.assertEqual(self.BP.name(13), 'other')
self.assertEqual(self.BP.length(1), 1.23)
self.assertEqual(self.BP.length(5), 0.0)
self.assertEqual(self.BP.length(7), 5.43)
import argparse
def open_dev(usbcontext=None):
if usbcontext is None:
usbcontext = usb1.USBContext()
print 'Scanning for devices...'
for udev in usbcontext.getDeviceList(skip_on_error=True):
vid = udev.getVendorID()
pid = udev.getProductID()
if (vid, pid) == (0x14b9, 0x0001):
print
print
print 'Found device'
print 'Bus %03i Device %03i: ID %04x:%04x' % (
udev.getBusNumber(), udev.getDeviceAddress(), vid, pid)
return udev.open()
raise Exception("Failed to find a device")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Replay captured USB packets')
args = parser.parse_args()
usbcontext = usb1.USBContext()
dev = open_dev(usbcontext)
print 'opened device'
bp = BP(usbcontext, dev)
print binascii.hexlify(bp.eeprom_r(0, 32))
plt.axis([-10, 10, -10, 10])
outname = "./save/{}.png".format(title)
plt.savefig(outname)
plt.show()
def show_loss(loss):
plt.cla()
print(len(loss))
plt.plot(np.arange(len(loss)), loss)
plt.title('loss')
# plt.axis([-10,10,-10,10])
outname = "./save/loss.png"
plt.savefig(outname)
plt.show()
if __name__ == '__main__':
train = loadDataset('train.txt')
test = loadDataset('test.txt')
train_X = train[:, :2]
train_y = train[:, 2]
test_X = test[:, :2]
net = BP([2, 4, 1])
loss = net.train(train_X, train_y)
show_loss(loss)
show_data(train[:, :2], train[:, 2], 'train')
pre_y = net.predict(test_X)
show_data(test_X, pre_y, 'test')
datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
#normalize,
])),
batch_size=20,
shuffle=True,
num_workers=2,
pin_memory=True,
worker_init_fn=worker_init_fn)
DEVICE = torch.device('cuda:0' if (torch.cuda.is_available()) else 'cpu')
attacker = BP(steps=20, device=DEVICE)
inception = models.inception_v3(pretrained=True)
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
preprocess_layer = Preprocessing_Layer(mean, std)
model = nn.Sequential(preprocess_layer, inception)
model.cuda()
model.eval()
top1 = AverageMeter('Acc@1', ':6.2f')
adv1 = AverageMeter('Adv@1', ':6.2f')
Norml2 = AverageMeter('Pnorml2@1', ':6.2f')
progress = ProgressMeter(len(val_loader), [top1, adv1, Norml2],
prefix='Test: ')
begin = time.time()
for i, (images, target) in enumerate(val_loader):
parser.add_argument('--workers', default=2, type=int, help='number of data loading workers')
parser.add_argument('--cpu', dest='cpu', action='store_true', help='force training on cpu')
args = parser.parse_args()
print(args)
DEVICE = torch.device('cuda:0' if (torch.cuda.is_available() and not args.cpu) else 'cpu')
transform = transforms.ToTensor()
test_set = MNIST(args.data, train=False, transform=transform, download=True)
test_loader = data.DataLoader(test_set, batch_size=1000, shuffle=False, num_workers=args.workers, pin_memory=True)
model = SmallCNN().to(DEVICE)
model_dict = model.load_state_dict(torch.load('model/adv_mnist.pth'))
attacker = BP(steps=100, device=DEVICE)
#attacker = DDN(steps=1000, device=DEVICE)
ori_image = []
ori_label = []
adv_image = []
adv_preds = []
requires_grad_(model, False)
model.eval()
for i, (images, labels) in enumerate(tqdm.tqdm(test_loader, ncols=80)):
t_images, t_labels = images.to(DEVICE), labels.to(DEVICE)
cadv,adv = attacker.attack(model, t_images, t_labels)
adv_pred = model(adv).argmax(1)
import schedule
import time
from monitor import BPMonitor
from config import BP_NAME, IS_TOP_21
from bp import BP
from api import get_info
is_top21 = False
if IS_TOP_21 == "True":
is_top21 = True
print("is_top_21", is_top21)
bp = BP(BP_NAME, is_top21)
bp_monitor = BPMonitor(bp)
schedule.every(2).seconds.do(bp_monitor.monitor)
while True:
schedule.run_pending()
# time.sleep(1)
class BPTests(TestCase):
def setUp(self):
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
self.fig1_B = np.array([1, 1, 1, 0, 1, 0, 1, 1 ,0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0], dtype=np.uint8)
self.BP = BP(self.fig1_B)
def test_rmq(self):
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
#excess 1 2 3 2 3 2 3 4 3 2 1 2 1 2 3 4 3 4 3 2 1 0
#i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
exp = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[2, 3, 3, 3, 3, 3, 3, 3, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[3, 3, 3, 3, 3, 3, 3, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[4, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[6, 6, 6, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[7, 8, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[8, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21],
[11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 21],
[12, 12, 12, 12, 12, 12, 12, 12, 12, 21],
[13, 13, 13, 13, 13, 13, 13, 20, 21],
[14, 14, 14, 14, 14, 19, 20, 21],
[15, 16, 16, 16, 19, 20, 21],
[16, 16, 16, 19, 20, 21],
[17, 18, 19, 20, 21],
[18, 19, 20, 21],
[19, 20, 21],
[20, 21],
[21]]
for i in range(len(self.fig1_B)):
for j in range(i+1, len(self.fig1_B)):
self.assertEqual(self.BP.rmq(i, j), exp[i][j - i])
def test_rMq(self):
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
#excess 1 2 3 2 3 2 3 4 3 2 1 2 1 2 3 4 3 4 3 2 1 0
#i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
exp = [[0, 1, 2, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[1, 2, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[2, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[3, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
[8, 8, 8, 8, 8, 8, 8, 15, 15, 15, 15, 15, 15, 15],
[9, 9, 9, 9, 9, 14, 15, 15, 15, 15, 15, 15, 15],
[10, 11, 11, 11, 14, 15, 15, 15, 15, 15, 15, 15],
[11, 11, 11, 14, 15, 15, 15, 15, 15, 15, 15],
[12, 13, 14, 15, 15, 15, 15, 15, 15, 15],
[13, 14, 15, 15, 15, 15, 15, 15, 15],
[14, 15, 15, 15, 15, 15, 15, 15],
[15, 15, 15, 15, 15, 15, 15],
[16, 17, 17, 17, 17, 17],
[17, 17, 17, 17, 17],
[18, 18, 18, 18],
[19, 19, 19],
[20, 20],
[21]]
for i in range(len(self.fig1_B)):
for j in range(i+1, len(self.fig1_B)):
self.assertEqual(self.BP.rMq(i, j), exp[i][j - i])
def test_mincount(self):
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
#i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
#excess 1 2 3 2 3 2 3 4 3 2 1 2 1 2 3 4 3 4 3 2 1 0
exp = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 1],
[1, 1, 2, 2, 3, 3, 3, 3, 4, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 2, 2, 2, 2, 3, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 2, 2, 2, 2, 3, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 2, 1],
[1, 1, 1, 1, 1, 1, 2, 1, 1],
[1, 1, 2, 2, 3, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 2, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1],
[1, 1],
[1]]
for i in range(len(self.fig1_B)):
for j in range(i+1, len(self.fig1_B)):
self.assertEqual(self.BP.mincount(i, j), exp[i][j - i])
def test_minselect(self):
"""position of the qth minimum in excess(i), excess(i + 1), . . . , excess(j)."""
exp = {(0, 20, 1): 0,
(0, 21, 1): 21,
(0, 20, 2): 10,
(0, 21, 2): None,
(0, 20, 3): 12,
(0, 20, 4): 20,
(8, 15, 1): 10,
(8, 15, 2): 12,
(6, 9, 1): 9}
for (i, j, q), e in exp.items():
self.assertEqual(self.BP.minselect(i, j, q), e)
def test_preorder(self):
exp = [1, 2, 3, 3, 4, 4, 5, 6, 6, 5, 2, 7, 7, 8, 9, 10, 10, 11, 11, 9, 8, 1]
for i, e in enumerate(exp):
self.assertEqual(self.BP.preorder(i), e)
def test_preorderselect(self):
exp = [0, 1, 2, 4, 6, 7, 11, 13, 14, 15, 17]
for k, e in enumerate(exp):
self.assertEqual(self.BP.preorderselect(k), e)
def test_postorder(self):
exp = [11, 5, 1, 1, 2, 2, 4, 3, 3, 4, 5, 6, 6, 10, 9, 7, 7, 8, 8, 9, 10, 11]
for i, e in enumerate(exp):
self.assertEqual(self.BP.postorder(i), e)
def test_postorderselect(self):
exp = [2, 4, 7, 6, 1, 11, 15, 17, 14, 13, 0]
for k, e in enumerate(exp):
self.assertEqual(self.BP.postorderselect(k + 1), e)
def test_isancestor(self):
exp = {(0, 0): False, # identity test
(2, 1): False, # tip test
(1, 2): True, # open test
(1, 3): True, # close test
(0, 7): True, # nested test
(1, 7): True} # nested test
for (i, j), e in exp.items():
self.assertEqual(self.BP.isancestor(i, j), e)
def test_subtree(self):
exp = [11, 5, 1, 1, 1, 1, 2, 1, 1, 2, 5, 1, 1, 4, 3, 1, 1, 1, 1, 3, 4, 11]
for i, e in enumerate(exp):
self.assertEqual(self.BP.subtree(i), e)
def test_levelancestor(self):
exp = {(2, 1): 1, # first tip to its parent
(2, 2): 0, # first tip to root
(4, 1): 1, # second tip to its parent
(5, 1): 1, # second tip, closing, to its parent
(7, 1): 6, # deep tip to its parent
(7, 2): 1, # deep tip to its grandparent
(7, 3): 0, # deep tip to its great grand parent
(7, 9999): 0, # max out at the root
(10, 0): -1} # can't be an ancestor of yourself
for (i, d), e in exp.items():
self.assertEqual(self.BP.levelancestor(i, d), e)
def _testinator(self, exp, f, verbose=False):
self.assertEqual(len(exp), len(self.fig1_B))
for i, e in enumerate(exp):
if verbose:
print(i, e)
self.assertEqual(f(i), e)
def test_levelnext(self):
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
exp = [-1, 11, 4, 4, 6, 6, 14, 15, 15, 14, 11, 13, 13, -1, -1, 17, 17, -1, -1, -1, -1, -1]
self.assertEqual(len(exp), len(self.fig1_B))
for i, e in enumerate(exp):
self.assertEqual(self.BP.levelnext(i), e)
def test_lca(self):
# lca(i, j) = parent(rmq(i, j) + 1)
# unless isancestor(i, j)
# (so lca(i, j) = i) or isancestor(j, i) (so lca(i, j) = j),
nodes = [self.BP.preorderselect(k) for k in range(self.fig1_B.sum())]
exp = {(nodes[2], nodes[3]): nodes[1],
(nodes[2], nodes[5]): nodes[1],
(nodes[2], nodes[9]): nodes[0],
(nodes[9], nodes[10]): nodes[8],
(nodes[1], nodes[8]): nodes[0]}
for (i, j), e in exp.items():
self.assertEqual(self.BP.lca(i, j), e)
def test_deepestnode(self):
# deepestnode(i) = rMq(i, close(i)),
exp = [7, 7, 2, 2, 4, 4, 7, 7, 7, 7, 7, 11, 11, 15, 15, 15, 15, 17, 17, 15, 15, 7]
self._testinator(exp, self.BP.deepestnode)
def test_height(self):
# height(i) = excess(deepestnode(i)) − excess(i).
exp = [3, 2, 0, 0, 0, 0, 1, 0, 0, 1, 2, 0, 0, 2, 1, 0, 0, 0, 0, 1, 2, 3]
self._testinator(exp, self.BP.height)
def test_ntips(self):
exp = 6
obs = self.BP.ntips()
self.assertEqual(obs, exp)
def test_shear(self):
# r 2 3 4 5 6 7 8 9 10 11
# ( ( ( ) ( ) ( ( ) ) ) ( ) ( ( ( ) ( ) ) ) )
#i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
names = np.array(['r', '2', '3', None, '4', None, '5', '6', None, None, None, '7', None, '8', '9', '10', None,
'11', None, None, None, None])
lengths = np.array([0, 1, 2, 0, 3, 0, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9, 0, 10, 0, 0, 0, 0], dtype=np.double)
self.BP.set_names(names)
self.BP.set_lengths(lengths)
in_ = {'4', '6', '7', '10', '11'}
exp = np.array([1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0,
0, 0], dtype=np.uint32)
exp_n = np.array(['r', '2', '4', None, '5', '6', None, None, None, '7', None, '8', '9', '10', None, '11', None,
None, None, None])
exp_l = np.array([0, 1, 3, 0, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9, 0, 10, 0, 0, 0, 0], dtype=np.double)
obs = self.BP.shear(in_)
npt.assert_equal(exp, obs.B)
for i in range(len(obs.B)):
self.assertEqual(obs.name(i), exp_n[i])
self.assertEqual(obs.length(i), exp_l[i])
in_ = {'10', '11'}
exp = np.array([1, 1, 1, 1, 0, 1, 0, 0, 0, 0], dtype=np.uint32)
obs = self.BP.shear(in_).B
npt.assert_equal(obs, exp)
def test_collapse(self):
names = np.array(['r', '2', '3', None, '4', None, '5', '6', None, None, None, '7', None, '8', '9', '10', None,
'11', None, None, None, None])
lengths = np.array([0, 1, 2, 0, 3, 0, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9, 0, 10, 0, 0, 0, 0], dtype=np.double)
self.BP.set_names(names)
self.BP.set_lengths(lengths)
exp = np.array([1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0],
dtype=np.uint8)
exp_n = ['r', '2', '3', None, '4', None, '6', None, None, '7', None, '9', '10', None, '11', None, None, None]
exp_l = [0, 1, 2, 0, 3, 0, 9, 0, 0, 6, 0, 15, 9, 0, 10, 0, 0, 0]
obs = self.BP.collapse()
npt.assert_equal(obs.B, exp)
for i in range(len(obs.B)):
self.assertEqual(obs.name(i), exp_n[i])
self.assertEqual(obs.length(i), exp_l[i])
bp = BP(np.array([1, 1, 1, 0, 0, 1, 0, 0], dtype=np.uint8))
exp = np.array([1, 1, 0, 1, 0, 0])
obs = bp.collapse().B
npt.assert_equal(obs, exp)
def test_name_unset(self):
for i in range(self.BP.B.size):
self.assertEqual(self.BP.name(i), None)
def test_length_unset(self):
for i in range(self.BP.B.size):
self.assertEqual(self.BP.length(i), 0.0)
def test_name_length_set(self):
names = np.full(self.BP.B.size, None, dtype=object)
lengths = np.zeros(self.BP.B.size, dtype=np.double)
names[0] = 'root'
names[self.BP.preorderselect(7)] = 'other'
lengths[1] = 1.23
lengths[self.BP.preorderselect(5)] = 5.43
self.BP.set_names(names)
self.BP.set_lengths(lengths)
self.assertEqual(self.BP.name(0), 'root')
self.assertEqual(self.BP.name(1), None)
self.assertEqual(self.BP.name(13), 'other')
self.assertEqual(self.BP.length(1), 1.23)
self.assertEqual(self.BP.length(5), 0.0)
self.assertEqual(self.BP.length(7), 5.43)
def setUp(self):
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
self.fig1_B = np.array([1, 1, 1, 0, 1, 0, 1, 1 ,0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0], dtype=np.uint8)
self.BP = BP(self.fig1_B)
###############################################################################
# SCHEDULER
##########
# You shall modify speedCoeff only
###############################################################################
scheduler = Scheduler(speedCoeff=1)
###############################################################################
# REGISTERS
##########
# Add registers like that : reg = Register("NAME")
###############################################################################
###############################################################################
# ECUS
##########
# You should always add registers in same order. Else there is an overlap.
# TODO I want to find out how to add registers with no order constraint
###############################################################################
allEcus = [
Ecu("../examples/viper2/App-GBF/trampoline", scheduler, [
Timer("TIMER0", 1, type=timer.AUTO, delay=10),
DAC("DAC0", 2, position=[0, 0]),
LCD("LCD1", 3, position=[360, 0]),
LCD("LCD2", 4, position=[360, 120]),
BP("BPPlus", 10, position=[360, 240], picture="pictures/BPPlus"),
BP("BPMinus", 11, position=[460, 240], picture="pictures/BPMinus"),
Power("POWER", 9),
])
]
def open_dev(usbcontext=None):
if usbcontext is None:
usbcontext = usb1.USBContext()
print 'Scanning for devices...'
for udev in usbcontext.getDeviceList(skip_on_error=True):
vid = udev.getVendorID()
pid = udev.getProductID()
if (vid, pid) == (0x14b9, 0x0001):
print
print
print 'Found device'
print 'Bus %03i Device %03i: ID %04x:%04x' % (
udev.getBusNumber(),
udev.getDeviceAddress(),
vid,
pid)
return udev.open()
raise Exception("Failed to find a device")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Replay captured USB packets')
args = parser.parse_args()
usbcontext = usb1.USBContext()
dev = open_dev(usbcontext)
print 'opened device'
bp = BP(usbcontext, dev)
print binascii.hexlify(bp.eeprom_r(0, 32))
batch_size=50,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
m = wide_resnet(num_classes=10, depth=28, widen_factor=10)
model = NormalizedModel(model=m, mean=image_mean, std=image_std).to(DEVICE)
model_dict = model.load_state_dict(torch.load('./model/cifar10_wrn.pth'))
if torch.cuda.device_count() > 1:
model = torch.nn.DataParallel(model)
#attacker = FGSM(eps=0.3, device=DEVICE)
#attacker = IFGSM(steps=20,eps=0.3,eps_iter=0.1, device=DEVICE)
#attacker = PGD(steps=20,eps=4,eps_iter=3, device=DEVICE)
attacker = BP(steps=100, device=DEVICE)
#attacker = DDN(steps=100, device=DEVICE)
requires_grad_(model, True)
model.eval()
ori_image = np.zeros((10000, 3, 32, 32))
ori_label = np.zeros((10000, 1))
adv_image = np.zeros((10000, 3, 32, 32))
adv_label = np.zeros((10000, 1))
#requires_grad_(model, False)
for i, (images, labels) in enumerate(tqdm.tqdm(test_loader, ncols=80)):
images, labels = images.to(DEVICE), labels.to(DEVICE)
#best_x = attacker.attack(model, images, labels)
adv, best_x = attacker.attack(model, images, labels)
# PYGAME WIDGETS
##########
# Add Pygame widgets if needed (for example, a screen which displays several
# information coming from several application
###############################################################################
display_server = Server("SERVER") # uses pygame
###############################################################################
# ECUS
##########
# You should always add registers in same order. Else there is an overlap.
###############################################################################
allEcus = [
Ecu("../examples/viper2/App-RobotPC/trampoline", scheduler, [
Network(network_master, "NET0", 0),
BP("BPFaster", 5, position=[100, 400], text="/\\"),
BP("BPSlower", 6, position=[100, 480], text="\\/"),
BP("BPLeft", 7, position=[0, 480], text="<"),
BP("BPRight", 8, position=[200, 480], text=">"),
Power("POWER", 9),
]),
Ecu("../examples/viper2/App-Robot1/trampoline", scheduler, [
Network(network_master, "NET1_1", 0),
Timer("TIMER0", 1, type=timer.AUTO, delay=100),
DisplayServer("LCD1", 2, display_server),
Motor("MOTOR1_1", 3),
Motor("MOTOR1_2", 4),
Network(network_slave, "NET1_2", 5),
Power("POWER", 9),
]),
Ecu("../examples/viper2/App-Robot2/trampoline", scheduler, [
transform = transforms.Compose([transforms.ToTensor()])
test_set = MNIST(args.data, train=False, transform=transform, download=True)
test_loader = data.DataLoader(test_set,
batch_size=100,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
model = SmallCNN().to(DEVICE)
model_dict = model.load_state_dict(torch.load('./model/mnist.pth'))
#attacker = FGSM(eps=0.3, device=DEVICE)
#attacker = IFGSM(steps=20,eps=0.3,eps_iter=0.1, device=DEVICE)
#attacker = PGD(steps=20,eps=4,eps_iter=3, device=DEVICE)
attacker = BP(steps=20, device=DEVICE, gamma=0.7)
#attacker = DDN(steps=100, device=DEVICE)
requires_grad_(model, True)
model.eval()
ori_image = np.zeros((10000, 1, 28, 28))
ori_label = np.zeros((10000, 1))
adv_image = np.zeros((10000, 1, 28, 28))
adv_label = np.zeros((10000, 1))
#requires_grad_(model, False)
for i, (images, labels) in enumerate(tqdm.tqdm(test_loader, ncols=80)):
images, labels = images.to(DEVICE), labels.to(DEVICE)
#best_x = attacker.attack(model, images, labels)
adv, best_x = attacker.attack(model, images, labels)
