def __init__(self, seed, dist=None):
if seed <= 0:
self._rng = mt.RandomState()
elif seed > 0:
self._rng = mt.RandomState(seed)
if dist is None:
dist = default_distribution
if not isinstance(dist, Distribution):
raise error, "Not a distribution object"
self._dist = dist
def f():
randomstate = mtrand.RandomState(seed=42)
rand0 = randomstate.rand()
rand1 = randomstate.rand()
rand2 = randomstate.rand()
return (rand0, rand1, rand2)
def forward(self, inputs):
if self.args.is_variable_block_len:
block_len = inputs.shape[1]
# reset interleaver
if self.args.is_interleave != 0: # fixed interleaver.
seed = np.random.randint(0, self.args.is_interleave)
rand_gen = mtrand.RandomState(seed)
p_array = rand_gen.permutation(arange(block_len))
self.set_interleaver(p_array)
inputs = 2.0 * inputs - 1.0
x_sys = self.enc_cnn_1(inputs)
x_sys = self.enc_act(self.enc_linear_1(x_sys))
x_p1 = self.enc_cnn_2(inputs)
x_p1 = self.enc_act(self.enc_linear_2(x_p1))
x_sys_int = self.interleaver(inputs)
x_p2 = self.enc_cnn_3(x_sys_int)
x_p2 = self.enc_act(self.enc_linear_3(x_p2))
x_tx = torch.cat([x_sys, x_p1, x_p2], dim=2)
codes = self.power_constraint(x_tx)
return codes
def __init__(self, args, p_array):
# turbofy only for code rate 1/3
super(ENC_interCNN2Int, self).__init__(args)
self.args = args
# Encoder
self.enc_cnn_1 = SameShapeConv1d(num_layer=args.enc_num_layer, in_channels=args.code_rate_k,
out_channels= args.enc_num_unit, kernel_size = args.dec_kernel_size)
self.enc_linear_1 = torch.nn.Linear(args.enc_num_unit, 1)
self.enc_cnn_2 = SameShapeConv1d(num_layer=args.enc_num_layer, in_channels=args.code_rate_k,
out_channels= args.enc_num_unit, kernel_size = args.dec_kernel_size)
self.enc_linear_2 = torch.nn.Linear(args.enc_num_unit, 1)
self.enc_cnn_3 = SameShapeConv1d(num_layer=args.enc_num_layer, in_channels=args.code_rate_k,
out_channels= args.enc_num_unit, kernel_size = args.dec_kernel_size)
self.enc_linear_3 = torch.nn.Linear(args.enc_num_unit, 1)
self.interleaver1 = Interleaver(args, p_array)
seed2 = 1000
rand_gen2 = mtrand.RandomState(seed2)
p_array2 = rand_gen2.permutation(arange(args.block_len))
print('p_array1', p_array)
print('p_array2', p_array2)
self.interleaver2 = Interleaver(args, p_array2)
def f():
rng = mtrand.RandomState(seed=250015)
x = rng.uniform(size=1000000)
res = sorted(x)
return all(
[res[ix] <= res[ix + 1]
for ix in xrange(len(res) - 1)]
)
def test_call_within_randomstate(self):
# Check that custom RandomState does not call into global state
m = random.RandomState()
res = np.array([0, 8, 7, 2, 1, 9, 4, 7, 0, 3])
for i in range(3):
random.seed(i)
m.seed(4321)
# If m.state is not honored, the result will change
assert_array_equal(m.choice(10, size=10, p=np.ones(10) / 10.), res)
def __init__(self, args, p_array):
super(DEC_LargeCNN2Int, self).__init__()
self.args = args
use_cuda = not args.no_cuda and torch.cuda.is_available()
self.this_device = torch.device("cuda" if use_cuda else "cpu")
self.interleaver1 = Interleaver(args, p_array)
self.deinterleaver1 = DeInterleaver(args, p_array)
seed2 = 1000
rand_gen2 = mtrand.RandomState(seed2)
p_array2 = rand_gen2.permutation(arange(args.block_len))
print('p_array1 dec', p_array)
print('p_array2 dec', p_array2)
self.interleaver2 = Interleaver(args, p_array2)
self.deinterleaver2 = DeInterleaver(args, p_array2)
self.dec1_cnns = torch.nn.ModuleList()
self.dec2_cnns = torch.nn.ModuleList()
self.dec1_outputs = torch.nn.ModuleList()
self.dec2_outputs = torch.nn.ModuleList()
for idx in range(args.num_iteration):
self.dec1_cnns.append(
SameShapeConv1d(num_layer=args.dec_num_layer,
in_channels=2 + args.num_iter_ft,
out_channels=args.dec_num_unit,
kernel_size=args.dec_kernel_size))
self.dec2_cnns.append(
SameShapeConv1d(num_layer=args.dec_num_layer,
in_channels=2 + args.num_iter_ft,
out_channels=args.dec_num_unit,
kernel_size=args.dec_kernel_size))
self.dec1_outputs.append(
torch.nn.Linear(args.dec_num_unit, args.num_iter_ft))
if idx == args.num_iteration - 1:
self.dec2_outputs.append(torch.nn.Linear(args.dec_num_unit, 1))
else:
self.dec2_outputs.append(
torch.nn.Linear(args.dec_num_unit, args.num_iter_ft))
sys.stdout = Logger('./logs/ftae'+identity+'_log.txt', sys.stdout)
args = get_args()
print(args)
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
#################################################
# Setup Channel AE: Encoder, Decoder, Channel
#################################################
# setup interleaver.
if args.is_interleave == 1:
seed = np.random.randint(0, 1)
rand_gen = mtrand.RandomState(seed)
p_array = rand_gen.permutation(arange(args.block_len))
elif args.is_interleave == 0:
p_array = range(args.block_len)
else:
seed = np.random.randint(0, args.is_interleave)
rand_gen = mtrand.RandomState(seed)
p_array = rand_gen.permutation(arange(args.block_len))
if args.codec not in ['deepcode_cnn', 'deepcode_rnn']:
print('using random interleaver', p_array)
if args.send_error_back:
model = Channel_Active_Block_Feedback(args, p_array).to(device)
else:
def __init__(self, length, seed):
rand_gen = mtrand.RandomState(seed)
self.p_array = rand_gen.permutation(arange(length))
def forward(self, received):
if self.args.is_variable_block_len:
block_len = received.shape[1]
# reset interleaver
if self.args.is_interleave != 0: # fixed interleaver.
seed = np.random.randint(0, self.args.is_interleave)
rand_gen = mtrand.RandomState(seed)
p_array = rand_gen.permutation(arange(block_len))
self.set_interleaver(p_array)
else:
block_len = self.args.block_len
received = received.type(torch.FloatTensor).to(self.this_device)
# Turbo Decoder
r_sys = received[:,:,0].view((self.args.batch_size, block_len, 1))
r_sys_int = self.interleaver(r_sys)
r_par1 = received[:,:,1].view((self.args.batch_size, block_len, 1))
r_par2 = received[:,:,2].view((self.args.batch_size, block_len, 1))
#num_iteration,
prior = torch.zeros((self.args.batch_size, block_len, self.args.num_iter_ft)).to(self.this_device)
for idx in range(self.args.num_iteration - 1):
x_this_dec = torch.cat([r_sys, r_par1, prior], dim = 2)
x_dec = self.dec1_cnns[idx](x_this_dec)
x_plr = self.dec1_outputs[idx](x_dec)
if self.args.extrinsic:
x_plr = x_plr - prior
x_plr_int = self.interleaver(x_plr)
x_this_dec = torch.cat([r_sys_int, r_par2, x_plr_int ], dim = 2)
x_dec = self.dec2_cnns[idx](x_this_dec)
x_plr = self.dec2_outputs[idx](x_dec)
if self.args.extrinsic:
x_plr = x_plr - x_plr_int
prior = self.deinterleaver(x_plr)
# last round
x_this_dec = torch.cat([r_sys,r_par1, prior], dim = 2)
x_dec = self.dec1_cnns[self.args.num_iteration - 1](x_this_dec)
x_plr = self.dec1_outputs[self.args.num_iteration - 1](x_dec)
if self.args.extrinsic:
x_plr = x_plr - prior
x_plr_int = self.interleaver(x_plr)
x_this_dec = torch.cat([r_sys_int, r_par2, x_plr_int ], dim = 2)
x_dec = self.dec2_cnns[self.args.num_iteration - 1](x_this_dec)
x_plr = self.dec2_outputs[self.args.num_iteration - 1](x_dec)
final = torch.sigmoid(self.deinterleaver(x_plr))
return final
def f():
rng = mtrand.RandomState(seed=42)
f = rng.rand(4)
p = rng.rand()
return p + f[0]
def f():
randomstate = mtrand.RandomState(seed=42)
randomstate.randn()
return randomstate.randn(9)
def f():
randomState = mtrand.RandomState(seed=42)
return randomState.rand(10)
def f():
randomstate = mtrand.RandomState(seed=42)
return randomstate.uniform(low=-1.0, high=1.0, size=9)
def f():
randomstate = mtrand.RandomState(seed=42)
unif = randomstate.uniform(-1, 1)
return unif