sess.run(init)
xaxis = []
yaxis = []
ctime = []
accu = []
missing_rates = [0.5, 0.6, 0.7, 0.8, 0.9]
#[0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95]
for mr in missing_rates:
for i in range(2000):
# batch_xs, batch_ys = mnist.train.next_batch(100)
offset = i % 100
batch_xs = np.array(mrsrp[offset, :]).reshape(1, 1600)
MASK = gen_mask(1, 1600, prob_masked=0.9)
batch_ys = np.array(mrsrp_sky[offset, :]).reshape(1, 1600)
batch_ys = batch_ys * MASK
_, accuracy, predict = sess.run(
[train_step, cross_entropy, prediction],
feed_dict={
xs: batch_ys,
ys: batch_xs,
keep_prob: 0.5
})
if i % 400 == 0:
print("base height:", bs, "uav:", uav, "miss rate", mr,
"epoch:", i, "accuracy", accuracy)
# print("epoch:", i," mean square error", accuracy)
print("the output is :", predict)
plot_image(np.reshape(predict, [40, 40]))
# d2=np.square((i-m)*50)+np.square((j-n)*50)+np.square(height)
## power=const*sky[i][j]/d2
# power=sky[i][j]*1.01
# weight= 1/d2
# powers.append(power)
# weights.append(weight)
res = 0
for k in range(len(powers)):
res += powers[k] * (weights[k] / sum(weights))
return res, sum(weights)
sampling_rate = [0.5, 0.45, 0.4, 0.35, 0.3, 0.25, 0.2, 0.15, 0.1, 0.05]
for sr in sampling_rate:
mask = gen_mask(40, 40, prob_masked=1 - sr)
rsrp = head * mask
rsrp[rsrp == 0] = np.NaN
X_filled_nnm = NuclearNormMinimization().fit_transform(rsrp)
print('sampling rate ', sr)
plot_image(X_filled_nnm)
error = mean_absolute_error(head, X_filled_nnm)
print(error)
#%%
out = open('data/mcmae.csv', 'a', newline='')
out2 = open('data/mctime.csv', 'a', newline='')
errors = np.linspace(0, 0, 10)
total_time = []
for sr in sampling_rate:
step = sr / 10
print('fdfa')
# preprocessing
stand_means = preprocessing.MinMaxScaler()
mat_rsrp = stand_means.fit_transform(mat_rsrp)
stand_means = preprocessing.MinMaxScaler()
matsky_rsrp = stand_means.fit_transform(matsky_rsrp)
# generate a maskmatrix
m = mat_rsrp.shape[0]
n = mat_rsrp.shape[1]
missing_rate = 0.75
missing_sky = 0.8
#random_mat = np.random.uniform(size=[])
mask = gen_mask(m, n, missing_rate)
mask_sky = gen_mask(m, n, missing_sky)
sample_data = mat_rsrp * mask
sample_sky = matsky_rsrp * mask_sky # sample data in the sky
idx = np.argwhere(sample_sky != 0)
sample_sky = np.array(sample_sky)
sample_sky = stand_means.fit_transform(sample_sky)
# def neural_network():
size = 40
X = tf.placeholder(tf.float32, shape=[None, size])
Y = tf.placeholder(tf.float32, shape=[None, size])
kernel = tf.random_normal(shape=[2, 2, 3, 1]) #正向卷积的kernel的模样
output_shape = [1, 5, 5, 3]
def show():
time_slots = 100
data_path = "../data/DlRsrpSinrStats.txt"
#data_set = np.loadtxt(data_path,delimiter=' ',skiprows=1);
data_set = pd.read_table(data_path, delimiter='\t')
print(data_set.shape)
df = pd.DataFrame(data_set)
rsrp = []
#construct matrix with location and timeslot
bias = 3200 * 149
for i in range(time_slots):
temp = np.array((df.loc[bias + i * 3200:bias + (i + 1) * 3200 -
1].sort_values('IMSI'))['rsrp'])
temp = temp[0:1600]
row = np.array(temp)
rsrp.append(row)
#rsrp = np.array((df.loc[0:time_slots*total_num-1].sort_values('IMSI'))['rsrp'])
#print('rsrp shape:',rsrp.shape)
#print(rsrp.shape)
mrsrp = []
for power in rsrp:
temp_power = 10 * np.log10(power) + 30
mrsrp.append(temp_power)
mrsrp = np.array(mrsrp)
# mrsrp = scale(mrsrp)
print('mrsrp', mrsrp.shape)
# generate a maskmatrix
m = 40
n = 40
missing_rates = [0.75]
#[0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95]
#random_mat = np.random.uniform(size=[])
xaxis = []
knnxaxis = []
knnyaxis = []
# iiyaxis=[]
nnmxaxis = []
nnmyaxis = []
micexaxis = []
miceyaxis = []
knntime = []
nnmtime = []
micetime = []
for missing_rate in missing_rates:
knny = []
# iiy=[]
nny = []
micey = []
nnmy = []
ktime = 0
ntime = 0
mtime = 0
for mat_rsrp in mrsrp:
mat_rsrp = np.array(mat_rsrp).reshape(40, 40)
mask = gen_mask(m, n, missing_rate)
# mask = gen_mask2().reshape(40,40)
print(mask)
sample_data = mat_rsrp * mask
print('origin_data')
plot_image(mat_rsrp)
print('the sample_data')
plot_image(sample_data)
try:
t1 = time.time()
sample_data[sample_data == 0] = np.nan
knn_recover = fast_knn(sample_data, k=3)
print('knn')
plot_image(knn_recover)
error_knn = mean_absolute_error(mat_rsrp, knn_recover)
print(error_knn)
knny.append(error_knn)
t2 = time.time()
ktime = ktime + (t2 - t1)
except ValueError:
knny.append(2)
t2 = time.time()
ktime = ktime + 600 * (1 + missing_rate)
try:
t1 = time.time()
mice_data = mice(sample_data)
print('mice')
plot_image(mice_data)
error_mice = mean_absolute_error(mat_rsrp, mice_data)
micey.append(error_mice)
t2 = time.time()
mtime = mtime + (t2 - t1)
except ValueError:
micey.append(2)
t2 = time.time()
mtime = mtime + 600 * (1 + missing_rate)
try:
t1 = time.time()
X_filled_nnm = SoftImpute().fit_transform(sample_data)
print('NuclearNormMinimization')
plot_image(X_filled_nnm)
error_nuclear = mean_absolute_error(mat_rsrp, X_filled_nnm)
nnmy.append(error_nuclear)
t2 = time.time()
ntime = ntime + (t2 - t1)
except:
nnmy.append(2)
t2 = time.time()
ntime = ntime + 600 * (1 + missing_rate)
break
# print("\tknn:",error_knn,"\tmice:",error_mice,"\titer:",error_iter,"\tnuclear",error_nuclear)
knntime.append(ktime)
nnmtime.append(ntime)
micetime.append(mtime)
knnyaxis.append(np.mean(np.array(knny)))
miceyaxis.append(np.mean(np.array(micey)))
# iiyaxis.append(np.mean(np.array(iiy)))
nnmyaxis.append(np.mean(np.array(nnmy)))
xaxis.append(missing_rate)
# plt.plot(xaxis,iiy,c='red',label='iter')
# plt.plot(xaxis,knny,c='blue',label='knn')
# plt.plot(xaxis,nnmy,c='orange',label='nnm')
# plt.plot(xaxis,micey,c='black',label='mice')
#
# plt.xlabel("missing rate")
# plt.ylabel("mae")
# plt.legend()
# plt.show()
res = np.array(
[xaxis, knnyaxis, nnmyaxis, miceyaxis, knntime, nnmtime, micetime])
return res
# d2=np.square((i-m)*50)+np.square((j-n)*50)+np.square(height)
## power=const*sky[i][j]/d2
# power=sky[i][j]*1.01
# weight= 1/d2
# powers.append(power)
# weights.append(weight)
res = 0
for k in range(len(powers)):
res += powers[k] * (weights[k] / sum(weights))
return res, sum(weights)
sampling_rate = [0.1, 0.2, 0.3, 0.4, 0.5]
for sr in sampling_rate:
mask = gen_mask(40, 40, prob_masked=1 - sr)
rsrp = head * mask
rsrp[rsrp == 0] = np.NaN
X_filled_nnm = NuclearNormMinimization().fit_transform(rsrp)
print('sampling rate ', sr)
plot_image(X_filled_nnm)
error = mean_absolute_error(head, X_filled_nnm)
print(error)
#%%
for sr in sampling_rate:
step = sr / 10
mae = []
for rsrp in mrsrp:
rsrp = np.reshape(rsrp, [40, 40])
errors = np.linspace(0, 0, 10)