def Smodel(y, t, dt, istep):
alpha = noise.gaussian(alpha_mean, alpha_var, Nensemble)
for iensemble in range(0, Nensemble):
By = y[iensemble * istride + 1]
alpha = alpha0 * alpha[iensemble]
f[iensemble * istride + 0] = imag * k * alpha * By
# f[1]=-Shear*y[0]+imag*k*alpha*y[0]-etat*k*k*y[1];
f[iensemble * istride + 1] = 0.
return f
args.gen_factor,
args.gen_test_size,
args.gen_num_neigh,
args.normalization,
args.cuda,
args.invlap_alpha,
args.gen_mesh,
args.gen_mesh_step)
### NOISE TO FEATURES ONLY USE ZERO HERE
if args.noise != "None":
features = features.numpy()
if args.noise == "gaussian":
features = gaussian(features,
mean=args.gaussian_opt[0],
std=args.gaussian_opt[1])
if args.noise == "zero_test":
idx_test = idx_test.numpy()
features = zero_idx(features, idx_test)
idx_test = torch.LongTensor(idx_test)
if args.cuda:
idx_test = idx_test.cuda()
if args.noise != "None":
features = torch.FloatTensor(features).float()
if args.cuda:
features = features.cuda()
### END NOISE TO FEATURES
# Monkey patch for Stacked Logistic Regression
def Smodel(y, t, dt, istep):
f[0] = famp * noise.gaussian(noise_mean, noise_var, 1)
return f
def main(noiseRatio):
packets = open('../data/packets.txt', 'r')
# CRC VARIABLES
crcTransmissions = 0
crcRetransmissions = 0
crcUndetectedErrors = 0
# HAMMING VARIABLES
hammingTransmissions = 0
hammingRetransmissions = 0
hammingCorrections = 0
hammingUndetectedErrors = 0
# PACKET ANALYSIS
for packet in packets:
packet = packet[:len(packet)-1] # Remove the return carriage
# CRC
success = False
crcEncodedPacket = crc.encode(packet)
while not success: # Continue until the packet is accurately received
crcNoisePacket = noise.gaussian(crcEncodedPacket, noiseRatio)
crcTransmissions += 1
success = True
if crc.decode(crcNoisePacket) == False: # If error(s) exist
crcRetransmissions += 1
success = False
elif crcEncodedPacket != crcNoisePacket: # Error occured and CRC didn't catch it
crcUndetectedErrors += 1
# HAMMING
success = False
hammingEncodedPacket = hamming.encode(packet)
while not success: # Continue until the packet is accurately received
hammingNoisePacket = noise.gaussian(hammingEncodedPacket, noiseRatio)
hammingTransmissions += 1
success = True
decodedHammingPacket = hamming.decode(hammingNoisePacket)
if not decodedHammingPacket: # Hamming decode failed - too many bit flips
hammingRetransmissions += 1
success = False
elif hammingNoisePacket != hammingEncodedPacket: # If a bit(s) was flipped & the result came back as true
hammingCorrections += 1
# SUMMARY
print "\n"
print "NOISE RATIO: %s\n" % noiseRatio
print "CRC ANALYSIS:"
print "\tTransmissions: "+str(crcTransmissions)
retransmissionRate = round(float(crcRetransmissions)/float(crcTransmissions)*100, 2)
print "\tRetransmissions: "+str(crcRetransmissions)+" ~ "+str(retransmissionRate)+"%"
print "\tUndetected Errors: "+str(crcUndetectedErrors)
print "\n"
print "HAMMING ANALYSIS"
print "\tTransmissions: "+str(hammingTransmissions)
retransmissionRate = round(float(hammingRetransmissions)/float(hammingTransmissions)*100, 2)
print "\tRetransmissions: "+str(hammingRetransmissions)+" ~ "+str(retransmissionRate)+"%"
print "\tCorrected Packets: "+str(hammingCorrections)
print "\tUndetected Errors: "+str(hammingUndetectedErrors)
print "\n"
# Write data to file
with open("../data/crcOut.txt",'a') as fout:
fout.write("(%s,%s)"%(noiseRatio,round(float(crcRetransmissions)/float(crcTransmissions)*100, 2)))
with open("../data/hammingOut.txt",'a') as fout:
fout.write("(%s,%s)"%(noiseRatio,round(float(hammingRetransmissions)/float(hammingTransmissions)*100, 2)))
set_seed(args.seed, args.cuda)
adj, features, labels, idx_train,\
idx_val, idx_test = load_citation(args.dataset,
args.normalization,
args.cuda,
args.invlap_alpha,
args.shuffle)
### NOISE TO FEATURES
if args.noise != "None":
features = features.numpy()
if args.noise == "gaussian":
features = gaussian(features,
mean=args.gaussian_opt[0],
std=args.gaussian_opt[1])
if args.noise == "gaussian_mimic":
features = gaussian_mimic(features)
if args.noise == "add_gaussian":
features = gaussian(features,
mean=args.gaussian_opt[0],
std=args.gaussian_opt[1],
add=True)
if args.noise == "add_gaussian_mimic":
features = gaussian_mimic(features, add=True)
if args.noise == "superimpose_gaussian":
features = superimpose_gaussian(features, args.superimpose_k)
if args.noise == "superimpose_gaussian_class":
labels = labels.numpy()
features = superimpose_gaussian_class(features, labels)
# plot the torus
ax.plot_surface(x,
y,
z,
rstride=5,
cstride=5,
color='k',
edgecolors='green',
alpha=0.25)
for run in range(reruns):
print('On rerun {} of {}\n'.format(run + 1, reruns))
# treat these as theta and phi
g_c = noise.gaussian(dim, const_vol, dt, T, x0)
e_c = noise.double_exponential(dim, const_vol, dt, T, x0)
g_x = (R + r * np.cos(g_c[:, 0])) * np.cos(g_c[:, 1])
g_y = (R + r * np.cos(g_c[:, 0])) * np.sin(g_c[:, 1])
g_z = r * np.sin(g_c[:, 0])
e_x = (R + r * np.cos(e_c[:, 0])) * np.cos(e_c[:, 1])
e_y = (R + r * np.cos(e_c[:, 0])) * np.sin(e_c[:, 1])
e_z = r * np.sin(e_c[:, 0])
ax.plot(g_x, g_y, g_z, '-', color='orange', alpha=0.5, linewidth=0.25)
ax.plot(e_x, e_y, e_z, '-', color='blue', alpha=0.5, linewidth=0.25)
ax.set_xlabel('$x$', fontsize=25)
ax.set_ylabel('$y$', fontsize=25)
burstRow= {}
burstRow["Noise Ratio"] = noiseRatio
numTrans = 0
numRT = 0
badReads = 0
corrections = 0
# CRC - Gaussian
with open('../data/packets.txt', 'r') as fin:
for packet in fin:
packet = packet.strip()
crcEncodedPacket = crc.encode(packet)
success = False
while not success:
crcNoisePacket = noise.gaussian(crcEncodedPacket, noiseRatio)
numTrans += 1
success = True
if crc.decode(crcNoisePacket) == False:
numRT += 1
success = False
elif crcEncodedPacket != crcNoisePacket:
badReads += 1
rowData["CRC RT G"] = round(float(numRT) / numTrans, 4)
gaussianRow["CRC T"] = numTrans
gaussianRow["CRC RT"] = numRT
print "CRC RT G\r"
print "\tNumTrans:\t" + str(numTrans)