幅度分布 - 分类器(无线信道模型)
遇到问题:
1, 瑞丽信道和莱斯信道重合度较高
2, 对数正态信道的波形失真严重
一, 平坦分布(经检验正确)
方法一: 理论合成
- mean = np.random.uniform(0.5, 2, 1)
- data = np.random.normal(mean, 0.001, sampleNo)
二, 瑞利分布(三种方法任选其一即可)
- # 方法一: 理论合成
- delta = 2
- data0 = np.random.normal(0, delta, 20000)
- data1 = np.random.normal(0, delta, 20000)
- data = (data0**2+data1**2)**0.5
方法二: 反函数构建
- data0 = np.random.random(20000)
- data = 2 * np.sqrt(-2 * np.log(data0))
方法三: numpy 自带库
- scale = np.random.normal(loc=0.0, scale=20)
- d0 = np.random.rayleigh(abs(scale), 40000)
三, 莱斯分布
方法一: 理论合成(经确认, 这个理论是正确的)
- data0 = np.random.normal(loc=0.0, scale=1, size=length)
- data1 = np.random.normal(loc=0.0, scale=1, size=length)
- data = np.sqrt((data0 + a) ** 2 + data1 ** 2)
方法二: 反函数(这个方法问题很大)(经检验这个是属于对数正态分布的推导)
- data0 = np.random.normal(loc=0.0, scale=abs(delta), size=length)
- data = np.exp(u + delta * data0)
四, 对数正态分布
方法一: 理论合成(与瑞利信道的反函数雷同!!!)(经检验完全正确)
- data1 = np.random.normal(0, 1, sampleNo )
- data = np.exp(u+delta*data1)
方法二: 公式法(和理想差距较大, 原因: 数据量没有达到一定程度. 舍弃)
- for i in range(len(x)):
- if Y[i] <= lognormal(x[i],u,delta):
- data.append(x[i])
方法三: numpy 自带库(numpy 自带库和理论合成效果相同)
d0 = np.random.lognormal(mean, sigma, 40000)
五, Suzuki 分布(确认正确)
方法一: 理论合成
- data0 = np.random.normal(0, 1, sampleNo)
- data1 = np.random.normal(0, 1, sampleNo)
- data3 = np.random.normal(0, 1, sampleNo)
- u = np.sqrt(data0**2+data1**2)
- v = np.exp(m+s*data3)
- data = u*v
六, 引入数据预处理
均值: 一阶中心矩
方差: 二阶中心矩
中位数: 数值从大到小 (或者反序) 最中间的数值
众数: 出现频次最高的数值(这两个数据需要额外处理)
偏度: 统计数据分布非对称程度的数字特征
峰度: 表征概率密度分布曲线在平均值处峰值高低的特征数
平均绝对误差: 所有单个观测值与算术平均值的偏差的绝对值的平均
与此同时遇到了一个新的问题:
这些数据处理方法使用原始数据还是统计数据!
个人更倾向于统计数据, 因为原始数据太过庞大并且数据格式不固定得出来的样值不具有代表性(打脸, 统计数据无法使用)
统计数据无法使用的原因: 因为上面的数据预处理本身就是一个统计的过程, 如果使用统计数据那就相当于 原始数据→统计 1→统计 2, 统计两次!
原始数据的改进: 1, 样本量的减小(但是分布函数依旧);2, 将原始数据的预处理数据进行打包减少数据量; 3, 数据格式直接使用全局的统计即可(这个有可能会出现问题)
实际计算过程中的错误: 众数无法使用; 原因: 这个是 float64 精度的几乎没有相等的两个数值
数据预处理:(列为样本序号, 横轴依次为均值, 标准差, 中位数, 偏度, 峰度, 平均绝对误差)
- # local1 全连接层 1 [6,128]
- # local2 全连接层 2 [128,512]
- # local3 全连接层 3 [512,128]
- # softmax 全连接层 4 [128,5]
- BATCH_SIZE = 256
- CAPACITY = 128
- learn_rate = 0.0010485759
- step_damp = 100
- rate_damp = 0.9
- MAX_STEP = 160000
- # coding=utf-8
- # coded by Mufasa 2018.12.10
- # 数据生成程序
- # 程序说明: 整个体系的数据来源 version3.1
- #
- """
- 改进:
- 1 将所有的数据进行, 再次的验证, 舍弃不合理的, 提取正确的数据
- 2 将与处理数据引入, 例如: 均值, 方差, 中位数, 众数, 峰度, 偏度, 平均绝对误差
- 3 数据打包测试完成
- 输出:
- d1_batch [BATCH_SIZE,6]
- np.array(d2_batch) [BATCH_SIZE]
- """
- import numpy as np
- class data_deal:
- def d_mean(self, data): # 均值
- return np.mean(data)
- def d_var(self, data): # 方差
- return np.var(data)
- def d_med(self, data): # 中位数
- return np.median(data)
- def d_mod(self, data): # 众数
- counts = np.bincount(data)
- return np.argmax(counts)
- def d_kur(self, data): # 峰度
- n = len(data)
- mean = np.mean(data)
- sigma = np.var(data)
- niu4_u = sum((data - mean) ** 4) / n
- return niu4_u / (sigma ** 2) - 3
- def d_par(self, data): # 偏度
- n = len(data)
- mean = np.mean(data)
- sigma = np.cov(data)
- niu3_0 = data ** 3 / n
- return (niu3_0 - 3 * mean * sigma ** 2 - mean ** 3) / (sigma ** 3)
- def d_mea_abs_err(self, data): # 平均绝对误差
- n = len(data)
- mean = np.mean(data)
- return sum(abs(data - mean)) / n
- def out_all(self, data):
- n = len(data)
- niu = sum(data) / n # 均值
- niu2 = sum(data ** 2) / n
- niu3 = sum(data ** 3) / n # 三阶原点矩
- sigma2 = niu2 - niu * niu # 方差
- sigma = np.sqrt(sigma2) # 标准差
- median = np.median(data) # 中位数
- skewness = (niu3 - 3 * niu * sigma2 - niu ** 3) / (sigma ** 3) # 偏度
- niu4_u = sum((data - niu) ** 4) / n # 四阶中心矩
- kurtosis = niu4_u / (sigma ** 2) - 3 # 峰度
- mea_abs_err = sum(abs(data - niu)) / n # 平均绝对误差
- return [niu, sigma, median, skewness, kurtosis, mea_abs_err]
- # 整合 5 种数据生成, 数据标签, 数据保存
- class data_origin:
- def __init__(self, sampleNo):
- self.sampleNo = sampleNo # 随机幅度样本个数
- # self.bins = bins # 样本统计切片个数
- self.fun = {
- 0: self.impulse,
- 1: self.rayleigh,
- 2: self.rice,
- 3: self.lognormal,
- 4: self.suzuki}
- def data_sum(self, num):
- d2_batch = []
- for i in range(num):
- select = np.random.randint(0, 5)
- fun_now = self.fun[select]
- data, d2 = fun_now()
- d1 = data_deal.out_all(self, data)
- d2_batch.append(d2)
- if i == 0:
- d1_batch = d1
- else:
- d1_batch = np.vstack((d1_batch, d1))
- return d1_batch, np.array(d2_batch)
- # 第一个 冲激分布 [1 0 0 0 0] 理论上完全正确
- def impulse(self): # 测试正确
- mean = np.random.uniform(0.5, 2, 1)
- data = np.random.normal(mean, 0.001, self.sampleNo)
- data = data / max(data) # 数据归一化处理
- d2 = 0
- return data, d2
- # 第二个 瑞利分布 [0 1 0 0 0]
- def rayleigh(self): # 使用理论生成数据(双高斯信号), 测试正确
- sigma = np.random.normal(2, 1, 1)[0]
- data0 = np.random.normal(loc=0.0, scale=abs(sigma), size=self.sampleNo)
- data1 = np.random.normal(loc=0.0, scale=abs(sigma), size=self.sampleNo)
- data = np.sqrt((data0 ** 2 + data1 ** 2))
- data = data / max(data) # 数据归一化处理
- d2 = 1
- return data, d2
- # 第三个 莱斯分布 [0 0 1 0 0]
- def rice(self): # 测试正确
- k = np.random.uniform(0, 15)
- mean = np.sqrt(2 * k)
- data0 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
- data1 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
- data = np.sqrt((data0 + mean) ** 2 + data1 ** 2)
- data = data / max(data) # 数据归一化处理
- d2 = 2
- return data, d2
- # 第四个 对数正态分布 [0 0 0 1 0]
- def lognormal(self):
- u = 0 # 这里的 u 值可以通过归一化清除
- delta = np.random.uniform(1 / 2, 1) # delta 的取值才是对数正态的核心
- data0 = np.random.normal(loc=0.0, scale=delta, size=self.sampleNo)
- data = np.exp(u + delta * data0)
- data = data / max(data)
- d2 = 3
- return data, d2
- # 第五个 Suzuki 分布 [0 0 0 0 1]
- def suzuki(self):
- m = np.random.normal(0, 1, 1)[0] # 这里的 sigma 数值需要查数据, 看看 sigma 的取值规律
- s = np.random.uniform(0.3, 0.8) # 这里的 sigma 数值需要查数据, 看看 sigma 的取值规律
- data0 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
- data1 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
- data2 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
- u = np.sqrt(data0 ** 2 + data1 ** 2)
- v = np.exp(m + s * data2)
- data = u * v
- data = data / max(data)
- d2 = 4
- return data, d2
- # 测试
- # obj = data_origin(700, 1000)
- # d1, d2 = obj.data_sum(20)
- # d1, d2 = obj.impulse()
- # print(d1)
- # print(d1[19, 1]) # [batch_size,num]
- # print(d2)
- # show_ = show()
- # print(d1)
- # show_.broken_line(np.array(range(0, 1000)), d1)
- # pass
- # coding=utf-8
- # local1 全连接层 1 [6,128]
- # local2 全连接层 2 [128,512]
- # local3 全连接层 3 [512,128]
- # softmax 全连接层 4 [128,5]
- import tensorflow as tf
- def inference(images, batch_size, n_classes):
- with tf.variable_scope('local1') as scope:
- # reshape = tf.reshape(images, shape=[batch_size, -1])
- # dim = reshape.get_shape()[1].value
- # print(dim)
- weights = tf.get_variable('weights',
- shape=[6, 128],
- dtype=tf.float32,
- initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
- biases = tf.get_variable('biases',
- shape=[128],
- dtype=tf.float32,
- initializer=tf.constant_initializer(0.1))
- local1 = tf.nn.relu(tf.matmul(images, weights) + biases, name=scope.name)
- # local2
- with tf.variable_scope('local2') as scope:
- weights = tf.get_variable('weights',
- shape=[128, 512],
- dtype=tf.float32,
- initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
- biases = tf.get_variable('biases',
- shape=[512],
- dtype=tf.float32,
- initializer=tf.constant_initializer(0.1))
- local2 = tf.nn.relu(tf.matmul(local1, weights) + biases, name='local4')
- # local3
- with tf.variable_scope('local3') as scope:
- weights = tf.get_variable('weights',
- shape=[512, 128],
- dtype=tf.float32,
- initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
- biases = tf.get_variable('biases',
- shape=[128],
- dtype=tf.float32,
- initializer=tf.constant_initializer(0.1))
- local3 = tf.nn.relu(tf.matmul(local2, weights) + biases, name='local4')
- # softmax
- with tf.variable_scope('softmax_linear') as scope:
- weights = tf.get_variable('softmax_linear',
- shape=[128, n_classes],
- dtype=tf.float32,
- initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
- biases = tf.get_variable('biases',
- shape=[n_classes],
- dtype=tf.float32,
- initializer=tf.constant_initializer(0.1))
- softmax_linear = tf.add(tf.matmul(local3, weights), biases, name='softmax_linear')
- return softmax_linear
- def losses(logits, labels):
- with tf.variable_scope('loss') as scope:
- cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits \
- (logits=logits, labels=labels, name='xentropy_per_example')
- loss = tf.reduce_mean(cross_entropy, name='loss')
- tf.summary.scalar(scope.name + '/loss', loss)
- return loss
- def trainning(loss, learning_rate, global_step):
- # with tf.name_scope('optimizer'):
- with tf.variable_scope('optimizer') as scope:
- optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
- # global_step = tf.Variable(0, name='global_step', trainable=False)
- train_op = optimizer.minimize(loss, global_step=global_step)
- return train_op
- def evaluation(logits, labels):
- with tf.variable_scope('accuracy') as scope:
- correct = tf.nn.in_top_k(logits, labels, 1)
- correct = tf.cast(correct, tf.float16)
- accuracy = tf.reduce_mean(correct)
- tf.summary.scalar(scope.name + '/accuracy', accuracy)
- return accuracy
- # coding=utf-8
- # 产生数据 - 训练 - 评估 - 结束标准
- # 这里使用的数据是随机生成的, 理论上是穷举数据集, 评估和训练本质上一致的
- '''
- 改进:
- 1 将保存的训练参数使用相对路径
- '''
- import input
- import model
- import numpy as np
- import os
- import tensorflow as tf
- bins = 6
- sum_num = 1000
- n_classes = 5
- BATCH_SIZE = 256
- CAPACITY = 128
- learn_rate = 0.0010485759
- step_damp = 100
- rate_damp = 0.9
- MAX_STEP = 160000
- root_folder = os.path.dirname(os.path.realpath(__file__))
- os.chdir(root_folder) # 返回上一级文件夹
- # print(root_folder)
- # print(os.path.dirname(root_folder))
- folder = "model2//" # 使用相对路径
- obj = input.data_origin(sum_num)
- '''
- DNN 配置
- ''' os.environ["CUDA_VISIBLE_DEVICES"] ='0' # 指定第一块 GPU 可用
- config = tf.ConfigProto(allow_soft_placement=True)
- config.gpu_options.per_process_gpu_memory_fraction = 0.85 # 程序最多只能占用指定 gpu 70% 的显存
- config.gpu_options.allow_growth = True # 程序按需申请内存
- with tf.Session(config=config) as sess:
- global_step = tf.Variable(0, name='global_step', trainable=False) # 有变更, 需要注意
- learning_rate = tf.train.exponential_decay(learn_rate, global_step, step_damp, rate_damp, staircase=False)
- data_batch = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, bins], name='data')
- label_batch = tf.placeholder(dtype=tf.int32, shape=[BATCH_SIZE], name='label')
- train_logits = model.inference(data_batch, BATCH_SIZE, n_classes)
- train_loss = model.losses(train_logits, label_batch)
- train_op = model.trainning(train_loss, learning_rate, global_step)
- train__acc = model.evaluation(train_logits, label_batch)
- summary_op = tf.summary.merge_all()
- train_writer = tf.summary.FileWriter(folder, sess.graph)
- saver = tf.train.Saver()
- sess.run(tf.global_variables_initializer())
- for step in np.arange(MAX_STEP):
- data, label = obj.data_sum(BATCH_SIZE)
- _ = sess.run(train_op, {data_batch: data, label_batch: label})
- if step % step_damp == 0:
- step_now, tra_loss, learn_rate, accuracy_now = sess.run(
- [global_step, train_loss, learning_rate, train__acc], {data_batch: data, label_batch: label})
- print('Step %d, train_loss = %f ,accuracy = %f ,learn_rate = %.10f' % (
- step_now, tra_loss, accuracy_now, learn_rate))
- if (step % 10000 == 0) or ((step + 1) == MAX_STEP):
- checkpoint_path = os.path.join(folder, 'model.ckpt')
- saver.save(sess, checkpoint_path, global_step=step)
- # coding=utf-8
- # 产生数据 - 训练 - 评估 - 结束标准
- # 这里使用的数据是随机生成的, 理论上是穷举数据集, 评估和训练本质上一致的
- """
- 改进:
- 1 将保存的训练参数使用相对路径
- """
- import input
- import model
- import numpy as np
- import os
- import tensorflow as tf
- bins = 6
- sum_num = 1000
- n_classes = 5
- BATCH_SIZE = 2048
- CAPACITY = 128
- step = 10
- root_folder = os.path.dirname(os.path.realpath(__file__))
- os.chdir(root_folder) # 返回上一级文件夹
- logs_train_dir = "model2" # 使用相对路径
- obj = input.data_origin(sum_num)
- def evaluate(logs_train_dir, BATCH_SIZE):
- # GPU 计算资源参数
- os.environ["CUDA_VISIBLE_DEVICES"] = '0' # 指定第一块 GPU 可用
- config = tf.ConfigProto(allow_soft_placement=True)
- config.gpu_options.per_process_gpu_memory_fraction = 0.85 # 程序最多只能占用指定 gpu 70% 的显存
- config.gpu_options.allow_growth = True # 程序按需申请内存
- with tf.Session(config=config) as sess:
- data_batch = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, bins], name='data')
- label_batch = tf.placeholder(dtype=tf.int32, shape=[BATCH_SIZE], name='label')
- train_logits = model.inference(data_batch, BATCH_SIZE, n_classes)
- # evaluate_logits = tf.nn.softmax(train_logits)
- evaluate_logits = tf.argmax(train_logits, 1)
- train__acc = model.evaluation(train_logits, label_batch)
- # 计算图保存参数
- # summary_op = tf.summary.merge_all()
- # train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
- saver = tf.train.Saver()
- sess.run(tf.global_variables_initializer())
- # coord = tf.train.Coordinator()
- # threads = tf.train.start_queue_runners(sess=sess, coord=coord)
- # 加载训练后的参数
- ckpt = tf.train.get_checkpoint_state(logs_train_dir)
- if ckpt and ckpt.model_checkpoint_path:
- global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
- saver.restore(sess, ckpt.model_checkpoint_path)
- print('模型加载成功, 训练的步数为 %s' % global_step)
- else:
- print('模型加载失败,,, 文件没有找到')
- # 写入预测数据前期设置
- try:
- for i in np.arange(step):
- data, label = obj.data_sum(BATCH_SIZE)
- # if coord.should_stop():
- # break
- # accuracy_now, prediction = sess.run([train__acc, evaluate_logits],
- # {data_batch: data, label_batch: label})
- # print('accuracy = %f' % (accuracy_now), 'label is', label, 'prediction is', prediction)
- accuracy_now = sess.run(train__acc,{data_batch: data, label_batch: label})
- print('accuracy = %f' % accuracy_now)
- except tf.errors.OutOfRangeError:
- print('Done training -- epoch limit reached')
- # finally:
- # coord.request_stop()
- # coord.join(threads)
- # print("正常预测第", circle, "个数据", label[circle])
- sess.close()
- evaluate(logs_train_dir, BATCH_SIZE)
来源: https://www.cnblogs.com/Mufasa/p/10131509.html