def cross_over(self):
self.sons = []
for i in range(self.pop_size): # create empty sons
ind = Individual(nvar=self.n_var,
nbits=self.bits_per_variable,
ncal=self.n_cal)
self.sons.append(deep_copy(ind))
for i in range(0, self.pop_size,
2): # cross over and fill their binary code
for j in range(self.n_var):
r = random.randint(1, self.bits_per_variable)
gray_code_father_1 = gc.bin_to_gray(
self.fathers[i].binary_code[j])
gray_code_father_2 = gc.bin_to_gray(
self.fathers[i + 1].binary_code[j])
gray_code_son_1 = [
gray_code_father_1[0:r], gray_code_father_2[r:]
]
gray_code_son_1 = ''.join(gray_code_son_1)
gray_code_son_2 = [
gray_code_father_2[0:r], gray_code_father_1[r:]
]
gray_code_son_2 = ''.join(gray_code_son_2)
self.sons[i].binary_code.append(
gc.gray_to_bin(gray_code_son_1))
self.sons[i + 1].binary_code.append(
gc.gray_to_bin(gray_code_son_2))
def test_graycode():
g = GrayCode(2)
got = []
for i in g.generate_gray():
if i.startswith('0'):
g.skip()
got.append(i)
assert got == '00 11 10'.split()
a = GrayCode(6)
assert a.current == '0'*6
assert a.rank == 0
assert len(list(a.generate_gray())) == 64
codes = ['011001', '011011', '011010',
'011110', '011111', '011101', '011100', '010100', '010101', '010111',
'010110', '010010', '010011', '010001', '010000', '110000', '110001',
'110011', '110010', '110110', '110111', '110101', '110100', '111100',
'111101', '111111', '111110', '111010', '111011', '111001', '111000',
'101000', '101001', '101011', '101010', '101110', '101111', '101101',
'101100', '100100', '100101', '100111', '100110', '100010', '100011',
'100001', '100000']
assert list(a.generate_gray(start='011001')) == codes
assert list(
a.generate_gray(rank=GrayCode(6, start='011001').rank)) == codes
assert a.next().current == '000001'
assert a.next(2).current == '000011'
assert a.next(-1).current == '100000'
a = GrayCode(5, start='10010')
assert a.rank == 28
a = GrayCode(6, start='101000')
assert a.rank == 48
assert GrayCode(6, rank=4).current == '000110'
assert GrayCode(6, rank=4).rank == 4
assert [GrayCode(4, start=s).rank for s in
GrayCode(4).generate_gray()] == [0, 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15]
a = GrayCode(15, rank=15)
assert a.current == '000000000001000'
assert bin_to_gray('111') == '100'
a = random_bitstring(5)
assert type(a) is str
assert len(a) == 5
assert all(i in ['0', '1'] for i in a)
assert get_subset_from_bitstring(
['a', 'b', 'c', 'd'], '0011') == ['c', 'd']
assert get_subset_from_bitstring('abcd', '1001') == ['a', 'd']
assert list(graycode_subsets(['a', 'b', 'c'])) == \
[[], ['c'], ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'],
['a', 'c'], ['a']]
raises(ValueError, lambda: GrayCode(0))
raises(ValueError, lambda: GrayCode(2.2))
raises(ValueError, lambda: GrayCode(2, start=[1, 1, 0]))
raises(ValueError, lambda: GrayCode(2, rank=2.5))
raises(ValueError, lambda: get_subset_from_bitstring(['c', 'a', 'c'], '1100'))
raises(ValueError, lambda: list(GrayCode(3).generate_gray(start="1111")))
def test_graycode():
g = GrayCode(2)
got = []
for i in g.generate_gray():
if i.startswith('0'):
g.skip()
got.append(i)
assert got == '00 11 10'.split()
a = GrayCode(6)
assert a.current == '0'*6
assert a.rank == 0
assert len(list(a.generate_gray())) == 64
codes = ['011001', '011011', '011010',
'011110', '011111', '011101', '011100', '010100', '010101', '010111',
'010110', '010010', '010011', '010001', '010000', '110000', '110001',
'110011', '110010', '110110', '110111', '110101', '110100', '111100',
'111101', '111111', '111110', '111010', '111011', '111001', '111000',
'101000', '101001', '101011', '101010', '101110', '101111', '101101',
'101100', '100100', '100101', '100111', '100110', '100010', '100011',
'100001', '100000']
assert list(a.generate_gray(start='011001')) == codes
assert list(
a.generate_gray(rank=GrayCode(6, start='011001').rank)) == codes
assert a.next().current == '000001'
assert a.next(2).current == '000011'
assert a.next(-1).current == '100000'
a = GrayCode(5, start='10010')
assert a.rank == 28
a = GrayCode(6, start='101000')
assert a.rank == 48
assert GrayCode(6, rank=4).current == '000110'
assert GrayCode(6, rank=4).rank == 4
assert [GrayCode(4, start=s).rank for s in
GrayCode(4).generate_gray()] == [0, 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15]
a = GrayCode(15, rank=15)
assert a.current == '000000000001000'
assert bin_to_gray('111') == '100'
a = random_bitstring(5)
assert type(a) is str
assert len(a) == 5
assert all(i in ['0', '1'] for i in a)
assert get_subset_from_bitstring(
['a', 'b', 'c', 'd'], '0011') == ['c', 'd']
assert get_subset_from_bitstring('abcd', '1001') == ['a', 'd']
assert list(graycode_subsets(['a', 'b', 'c'])) == \
[[], ['c'], ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'],
['a', 'c'], ['a']]
def encode(f, dim=None, coding=None):
if dim == None:
dim = parameters.ndim
if coding == None:
coding = parameters.coding
if coding == 'bin':
return double_to_bin(f)
elif coding == 'gray':
return bin_to_gray(double_to_bin(f))
else:
raise ValueError("Unknown number coding {}".format(coding))
def mutation(self):
for i in range(self.pop_size):
for j in range(self.n_var):
for k in range(self.bits_per_variable):
r = random.random()
if r <= self.mutation_rate:
gray_code_son = gc.bin_to_gray(self.sons[i].binary_code[j])
if gray_code_son[k] == '1':
gray_code_son = list(gray_code_son)
gray_code_son[k] = '0'
gray_code_son = ''.join(gray_code_son)
else:
gray_code_son = list(gray_code_son)
gray_code_son[k] = '1'
gray_code_son = ''.join(gray_code_son)
self.sons[i].binary_code[j] = gc.gray_to_bin(gray_code_son)
def test_graycode():
a = GrayCode(6)
assert a.current == '0' * 6
assert a.rank == 0
assert len(list(a.generate_gray())) == 64
codes = [
'011001', '011011', '011010', '011110', '011111', '011101', '011100',
'010100', '010101', '010111', '010110', '010010', '010011', '010001',
'010000', '110000', '110001', '110011', '110010', '110110', '110111',
'110101', '110100', '111100', '111101', '111111', '111110', '111010',
'111011', '111001', '111000', '101000', '101001', '101011', '101010',
'101110', '101111', '101101', '101100', '100100', '100101', '100111',
'100110', '100010', '100011', '100001', '100000'
]
assert list(a.generate_gray(start='011001')) == codes
assert list(
a.generate_gray(rank=GrayCode(6, start='011001').rank)) == codes
assert a.next().current == '000001'
assert a.next(2).current == '000011'
assert a.next(-1).current == '100000'
a = GrayCode(5, start='10010')
assert a.rank == 28
a = GrayCode(6, start='101000')
assert a.rank == 48
assert GrayCode(6, rank=4).current == '000110'
assert GrayCode(6, rank=4).rank == 4
assert [GrayCode(4, start=s).rank for s in \
GrayCode(4).generate_gray()] == [0, 1, 2, 3, 4, 5, 6, 7, 8, \
9, 10, 11, 12, 13, 14, 15]
a = GrayCode(15, rank=15)
assert a.current == '000000000001000'
assert bin_to_gray('111') == '100'
a = random_bitstring(5)
assert type(a) is str
assert len(a) == 5
assert all(i in ['0', '1'] for i in a)
assert get_subset_from_bitstring(['a', 'b', 'c', 'd'],
'0011') == ['c', 'd']
assert get_subset_from_bitstring('abcd', '1001') == ['a', 'd']
assert list(graycode_subsets(['a','b','c'])) == \
[[], ['c'], ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'], \
['a', 'c'], ['a']]
def test_graycode():
a = GrayCode(6)
assert a.current == '0'*6
assert a.rank == 0
assert len(list(a.generate_gray())) == 64
codes = ['011001', '011011', '011010',
'011110', '011111', '011101', '011100', '010100', '010101', '010111',
'010110', '010010', '010011', '010001', '010000', '110000', '110001',
'110011', '110010', '110110', '110111', '110101', '110100', '111100',
'111101', '111111', '111110', '111010', '111011', '111001', '111000',
'101000', '101001', '101011', '101010', '101110', '101111', '101101',
'101100', '100100', '100101', '100111', '100110', '100010', '100011',
'100001', '100000']
assert list(a.generate_gray(start='011001')) == codes
assert list(a.generate_gray(rank=GrayCode(6, start='011001').rank)) == codes
assert a.next().current == '000001'
assert a.next(2).current == '000011'
assert a.next(-1).current == '100000'
a = GrayCode(5, start='10010')
assert a.rank == 28
a = GrayCode(6, start='101000')
assert a.rank == 48
assert GrayCode(6, rank=4).current == '000110'
assert GrayCode(6, rank=4).rank == 4
assert [GrayCode(4, start=s).rank for s in \
GrayCode(4).generate_gray()] == [0, 1, 2, 3, 4, 5, 6, 7, 8, \
9, 10, 11, 12, 13, 14, 15]
a = GrayCode(15, rank=15)
assert a.current == '000000000001000'
assert bin_to_gray('111') == '100'
random.seed(0)
assert [random_bitstring(5) for i in range(3)] == ['11001', '01001', '11011']
assert get_subset_from_bitstring(['a','b','c','d'], '0011') == ['c', 'd']
assert get_subset_from_bitstring('abcd','1001') == ['a', 'd']
assert list(graycode_subsets(['a','b','c'])) == \
[[], ['c'], ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'], \
['a', 'c'], ['a']]
def __init__(self,
dim_percept,
n_action_units,
dim_hidden_=[32],
dropout_rate_=[0.]):
super(DEBN, self).__init__()
self.all_actions = [
torch.from_numpy(
np.array([
float(digit)
for digit in bin_to_gray(bin(i)[2:].zfill(n_action_units))
])).float() for i in range(2**n_action_units)
]
#initialisation
init_kaiman = True
#input layer
self.visible = nn.Linear(dim_percept + n_action_units, dim_hidden_[0])
self.visible.apply(self._init_weights) if init_kaiman else None
self.b_input = nn.Linear(dim_percept + n_action_units, 1)
nn.init.constant_(self.b_input.bias, 0.)
self.b_input.bias.requires_grad = False
#hidden layers
self.hidden = nn.ModuleList()
for l in range(len(dim_hidden_) - 1):
self.hidden.append(nn.Linear(dim_hidden_[l], dim_hidden_[l + 1]))
for l in range(1, len(dim_hidden_) - 1):
self.hidden[l].apply(self._init_weights) if init_kaiman else None
#output layer
self.output = nn.Linear(dim_hidden_[-1] + 1, 1)
def test_gray_to_uint(self):
gray_code = bin_to_gray(Bits(uint=23, length=13).bin)
self.assertEqual(gray_to_uint(gray_code), 23)
def test_live_issue_117():
assert bin_to_gray('0100') == '0110'
assert bin_to_gray('0101') == '0111'
for bits in ('0100', '0101'):
assert gray_to_bin(bin_to_gray(bits)) == bits
debn.parameters()),
lr=learning_rate,
amsgrad=True)
optimizer_dqn = optim.Adam(filter(lambda p: p.requires_grad,
dqn.parameters()),
lr=learning_rate,
amsgrad=True)
if not (dqn_only):
full_losses_debn = []
full_losses_dqn = []
for j in range(5001):
percepts = np.random.choice(num_percepts, size=batch_size)
batch_percepts = torch.from_numpy(
np.array([[
float(digit)
for digit in bin_to_gray(bin(i)[2:].zfill(dim_percept))
] for i in percepts])).float()
target_m_values = torch.from_numpy(m_values[percepts]).float()
m_values_dqn = dqn(batch_percepts)
if not (dqn_only):
m_values_debn = debn(batch_percepts)
if sampling:
sample_dqn = sample(m_values_dqn)
if not (dqn_only):
sample_debn = sample(m_values_debn)
loss_dqn = F.smooth_l1_loss(
select(m_values_dqn, sample_dqn, num_actions),
select(target_m_values, sample_dqn, num_actions))
if not (dqn_only):
loss_debn = F.smooth_l1_loss(
select(m_values_debn, sample_dqn, num_actions),
def test_live_issue_117():
assert bin_to_gray('0100') == '0110'
assert bin_to_gray('0101') == '0111'
for bits in ('0100', '0101'):
assert gray_to_bin(bin_to_gray(bits)) == bits
def test_live_issue_117():
assert bin_to_gray("0100") == "0110"
assert bin_to_gray("0101") == "0111"
for bits in ("0100", "0101"):
assert gray_to_bin(bin_to_gray(bits)) == bits
def test_graycode():
g = GrayCode(2)
got = []
for i in g.generate_gray():
if i.startswith("0"):
g.skip()
got.append(i)
assert got == "00 11 10".split()
a = GrayCode(6)
assert a.current == "0" * 6
assert a.rank == 0
assert len(list(a.generate_gray())) == 64
codes = [
"011001",
"011011",
"011010",
"011110",
"011111",
"011101",
"011100",
"010100",
"010101",
"010111",
"010110",
"010010",
"010011",
"010001",
"010000",
"110000",
"110001",
"110011",
"110010",
"110110",
"110111",
"110101",
"110100",
"111100",
"111101",
"111111",
"111110",
"111010",
"111011",
"111001",
"111000",
"101000",
"101001",
"101011",
"101010",
"101110",
"101111",
"101101",
"101100",
"100100",
"100101",
"100111",
"100110",
"100010",
"100011",
"100001",
"100000",
]
assert list(a.generate_gray(start="011001")) == codes
assert list(
a.generate_gray(rank=GrayCode(6, start="011001").rank)) == codes
assert a.next().current == "000001"
assert a.next(2).current == "000011"
assert a.next(-1).current == "100000"
a = GrayCode(5, start="10010")
assert a.rank == 28
a = GrayCode(6, start="101000")
assert a.rank == 48
assert GrayCode(6, rank=4).current == "000110"
assert GrayCode(6, rank=4).rank == 4
assert [GrayCode(4, start=s).rank
for s in GrayCode(4).generate_gray()] == [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
]
a = GrayCode(15, rank=15)
assert a.current == "000000000001000"
assert bin_to_gray("111") == "100"
a = random_bitstring(5)
assert type(a) is str
assert len(a) == 5
assert all(i in ["0", "1"] for i in a)
assert get_subset_from_bitstring(["a", "b", "c", "d"],
"0011") == ["c", "d"]
assert get_subset_from_bitstring("abcd", "1001") == ["a", "d"]
assert list(graycode_subsets(["a", "b", "c"])) == [
[],
["c"],
["b", "c"],
["b"],
["a", "b"],
["a", "b", "c"],
["a", "c"],
["a"],
]
raises(ValueError, lambda: GrayCode(0))
raises(ValueError, lambda: GrayCode(2.2))
raises(ValueError, lambda: GrayCode(2, start=[1, 1, 0]))
raises(ValueError, lambda: GrayCode(2, rank=2.5))
raises(ValueError,
lambda: get_subset_from_bitstring(["c", "a", "c"], "1100"))
raises(ValueError, lambda: list(GrayCode(3).generate_gray(start="1111")))
