• 幅度分布-分类器(无线信道模型)(原创)


     

    幅度分布-分类器(无线信道模型)

    遇到问题:

    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精度的几乎没有相等的两个数值

    数据预处理:(列为样本序号,横轴依次为均值、标准差、中位数、偏度、峰度、平均绝对误差)

     

    原始数据标签:(列为样本序号,横轴依次为平坦分布、瑞利分布、莱斯分布、对数正态分布、suzuki分布)

     

     

    七,分类器设计

     

    由之前做FashionAI的服饰标签属性时设计的CNN训练模型,现在直接拿来改版一下当幅度分布分类器的训练模型(改成DNN网络即可)

     

    1,DNN结构

     

    # 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

     

    2,训练效果

     

     

    通过上图可知正确率在91%左右,其中为什么不能达到100%的原因,这个是因为:

    莱斯分布在主径分量接近零的时候会退化瑞利分布

    suzuki分布和对数正态的相似性较大;

     

    模拟数据验证1:(Batch_size=64

     

    模拟数据验证2:(Batch_size=1024

     

     

    3,实测数据检验

     

     

    八,总结

    其实这个 幅度分布-分类器 更难设计

    难点:

    ①这个是对个分布函数的随机数数据

    ②处理数据比较麻烦,直接把随机数的输出输入分类器效果基本为0,这个思路问题很大,并且计算量还大

    ③统计数据后进行数据预处理,在这里也出现了相关的问题,比如上文说的统计两次的错误

    ④分类器模型设计,之前都是使用图像处理的卷积网络,由于惯性的缘故。刚开始也想使用一维卷积网络,但是效果一般

     

    附录代码:input.pyw

      1 # coding=utf-8
      2 # coded by Mufasa 2018.12.10
      3 # 数据生成程序
      4 # 程序说明:整个体系的数据来源 version3.1
      5 #
      6 """
      7 改进:
      8 ① 将所有的数据进行,再次的验证,舍弃不合理的,提取正确的数据
      9 ② 将与处理数据引入,例如:均值、方差、中位数、众数、峰度、偏度、平均绝对误差
     10 ③ 数据打包测试完成
     11 输出:
     12 d1_batch                [BATCH_SIZE,6]
     13 np.array(d2_batch)      [BATCH_SIZE]
     14 """
     15 
     16 import numpy as np
     17 
     18 
     19 class data_deal:
     20     def d_mean(self, data):  # 均值
     21         return np.mean(data)
     22 
     23     def d_var(self, data):  # 方差
     24         return np.var(data)
     25 
     26     def d_med(self, data):  # 中位数
     27         return np.median(data)
     28 
     29     def d_mod(self, data):  # 众数
     30         counts = np.bincount(data)
     31         return np.argmax(counts)
     32 
     33     def d_kur(self, data):  # 峰度
     34         n = len(data)
     35         mean = np.mean(data)
     36         sigma = np.var(data)
     37         niu4_u = sum((data - mean) ** 4) / n
     38         return niu4_u / (sigma ** 2) - 3
     39 
     40     def d_par(self, data):  # 偏度
     41         n = len(data)
     42         mean = np.mean(data)
     43         sigma = np.cov(data)
     44         niu3_0 = data ** 3 / n
     45         return (niu3_0 - 3 * mean * sigma ** 2 - mean ** 3) / (sigma ** 3)
     46 
     47     def d_mea_abs_err(self, data):  # 平均绝对误差
     48         n = len(data)
     49         mean = np.mean(data)
     50         return sum(abs(data - mean)) / n
     51 
     52     def out_all(self, data):
     53         n = len(data)
     54         niu = sum(data) / n  # 均值
     55         niu2 = sum(data ** 2) / n
     56         niu3 = sum(data ** 3) / n  # 三阶原点矩
     57 
     58         sigma2 = niu2 - niu * niu  # 方差
     59         sigma = np.sqrt(sigma2)  # 标准差
     60         median = np.median(data)  # 中位数
     61 
     62         skewness = (niu3 - 3 * niu * sigma2 - niu ** 3) / (sigma ** 3)  # 偏度
     63         niu4_u = sum((data - niu) ** 4) / n  # 四阶中心矩
     64         kurtosis = niu4_u / (sigma ** 2) - 3  # 峰度
     65         mea_abs_err = sum(abs(data - niu)) / n  # 平均绝对误差
     66         return [niu, sigma, median, skewness, kurtosis, mea_abs_err]
     67 
     68 
     69 # 整合 5种数据生成、数据标签、数据保存
     70 class data_origin:
     71     def __init__(self, sampleNo):
     72         self.sampleNo = sampleNo  # 随机幅度样本个数
     73         # self.bins = bins  # 样本统计切片个数
     74         self.fun = {
     75             0: self.impulse,
     76             1: self.rayleigh,
     77             2: self.rice,
     78             3: self.lognormal,
     79             4: self.suzuki}
     80 
     81     def data_sum(self, num):
     82         d2_batch = []
     83         for i in range(num):
     84             select = np.random.randint(0, 5)
     85             fun_now = self.fun[select]
     86             data, d2 = fun_now()
     87             d1 = data_deal.out_all(self, data)
     88             d2_batch.append(d2)
     89             if i == 0:
     90                 d1_batch = d1
     91             else:
     92                 d1_batch = np.vstack((d1_batch, d1))
     93         return d1_batch, np.array(d2_batch)
     94 
     95     # 第一个 冲激分布  [1 0 0 0 0] 理论上完全正确
     96     def impulse(self):  # 测试正确
     97         mean = np.random.uniform(0.5, 2, 1)
     98 
     99         data = np.random.normal(mean, 0.001, self.sampleNo)
    100         data = data / max(data)  # 数据归一化处理
    101 
    102         d2 = 0
    103         return data, d2
    104 
    105     # 第二个 瑞利分布  [0 1 0 0 0]
    106     def rayleigh(self):  # 使用理论生成数据(双高斯信号),测试正确
    107         sigma = np.random.normal(2, 1, 1)[0]
    108 
    109         data0 = np.random.normal(loc=0.0, scale=abs(sigma), size=self.sampleNo)
    110         data1 = np.random.normal(loc=0.0, scale=abs(sigma), size=self.sampleNo)
    111         data = np.sqrt((data0 ** 2 + data1 ** 2))
    112         data = data / max(data)  # 数据归一化处理
    113 
    114         d2 = 1
    115         return data, d2
    116 
    117     # 第三个 莱斯分布  [0 0 1 0 0]
    118     def rice(self):  # 测试正确
    119         k = np.random.uniform(0, 15)
    120         mean = np.sqrt(2 * k)
    121 
    122         data0 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
    123         data1 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
    124 
    125         data = np.sqrt((data0 + mean) ** 2 + data1 ** 2)
    126         data = data / max(data)  # 数据归一化处理
    127 
    128         d2 = 2
    129         return data, d2
    130 
    131     # 第四个 对数正态分布  [0 0 0 1 0]
    132     def lognormal(self):
    133         u = 0  # 这里的u值可以通过归一化清除
    134         delta = np.random.uniform(1 / 2, 1)  # delta的取值才是对数正态的核心
    135 
    136         data0 = np.random.normal(loc=0.0, scale=delta, size=self.sampleNo)
    137         data = np.exp(u + delta * data0)
    138         data = data / max(data)
    139 
    140         d2 = 3
    141         return data, d2
    142 
    143     # 第五个 Suzuki分布  [0 0 0 0 1]
    144     def suzuki(self):
    145         m = np.random.normal(0, 1, 1)[0]  # 这里的sigma数值需要查数据,看看sigma的取值规律
    146         s = np.random.uniform(0.3, 0.8)  # 这里的sigma数值需要查数据,看看sigma的取值规律
    147 
    148         data0 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
    149         data1 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
    150         data2 = np.random.normal(loc=0.0, scale=1, size=self.sampleNo)
    151         u = np.sqrt(data0 ** 2 + data1 ** 2)
    152         v = np.exp(m + s * data2)
    153         data = u * v
    154         data = data / max(data)
    155 
    156         d2 = 4
    157         return data, d2
    158 
    159 
    160 # 测试
    161 # obj = data_origin(700, 1000)
    162 # d1, d2 = obj.data_sum(20)
    163 # d1, d2 = obj.impulse()
    164 # print(d1)
    165 # print(d1[19, 1])  # [batch_size,num]
    166 # print(d2)
    167 # show_ = show()
    168 # print(d1)
    169 # show_.broken_line(np.array(range(0, 1000)), d1)
    170 # pass

    附录代码:model.pyw

     1 # coding=utf-8
     2 
     3 
     4 # local1 全连接层 1     [6,128]
     5 # local2 全连接层 2     [128,512]
     6 # local3 全连接层 3     [512,128]
     7 # softmax 全连接层 4    [128,5]
     8 
     9 
    10 import tensorflow as tf
    11 
    12 
    13 def inference(images, batch_size, n_classes):
    14     with tf.variable_scope('local1') as scope:
    15         # reshape = tf.reshape(images, shape=[batch_size, -1])
    16         # dim = reshape.get_shape()[1].value
    17         # print(dim)
    18         weights = tf.get_variable('weights',
    19                                   shape=[6, 128],
    20                                   dtype=tf.float32,
    21                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
    22         biases = tf.get_variable('biases',
    23                                  shape=[128],
    24                                  dtype=tf.float32,
    25                                  initializer=tf.constant_initializer(0.1))
    26     local1 = tf.nn.relu(tf.matmul(images, weights) + biases, name=scope.name)
    27 
    28     # local2
    29     with tf.variable_scope('local2') as scope:
    30         weights = tf.get_variable('weights',
    31                                   shape=[128, 512],
    32                                   dtype=tf.float32,
    33                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
    34         biases = tf.get_variable('biases',
    35                                  shape=[512],
    36                                  dtype=tf.float32,
    37                                  initializer=tf.constant_initializer(0.1))
    38         local2 = tf.nn.relu(tf.matmul(local1, weights) + biases, name='local4')
    39 
    40     # local3
    41     with tf.variable_scope('local3') as scope:
    42         weights = tf.get_variable('weights',
    43                                   shape=[512, 128],
    44                                   dtype=tf.float32,
    45                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
    46         biases = tf.get_variable('biases',
    47                                   shape=[128],
    48                                   dtype=tf.float32,
    49                                   initializer=tf.constant_initializer(0.1))
    50         local3 = tf.nn.relu(tf.matmul(local2, weights) + biases, name='local4')
    51 
    52         # softmax
    53     with tf.variable_scope('softmax_linear') as scope:
    54         weights = tf.get_variable('softmax_linear',
    55                                   shape=[128, n_classes],
    56                                   dtype=tf.float32,
    57                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
    58         biases = tf.get_variable('biases',
    59                                  shape=[n_classes],
    60                                  dtype=tf.float32,
    61                                  initializer=tf.constant_initializer(0.1))
    62         softmax_linear = tf.add(tf.matmul(local3, weights), biases, name='softmax_linear')
    63 
    64     return softmax_linear
    65 
    66 
    67 def losses(logits, labels):
    68     with tf.variable_scope('loss') as scope:
    69         cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits 
    70             (logits=logits, labels=labels, name='xentropy_per_example')
    71         loss = tf.reduce_mean(cross_entropy, name='loss')
    72         tf.summary.scalar(scope.name + '/loss', loss)
    73     return loss
    74 
    75 
    76 def trainning(loss, learning_rate, global_step):
    77     # with tf.name_scope('optimizer'):
    78     with tf.variable_scope('optimizer') as scope:
    79         optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
    80         # global_step = tf.Variable(0, name='global_step', trainable=False)
    81         train_op = optimizer.minimize(loss, global_step=global_step)
    82     return train_op
    83 
    84 
    85 def evaluation(logits, labels):
    86     with tf.variable_scope('accuracy') as scope:
    87         correct = tf.nn.in_top_k(logits, labels, 1)
    88         correct = tf.cast(correct, tf.float16)
    89         accuracy = tf.reduce_mean(correct)
    90         tf.summary.scalar(scope.name + '/accuracy', accuracy)
    91     return accuracy

    附录代码:train.pyw

     1 # coding=utf-8
     2 # 产生数据—训练-评估-结束标准
     3 # 这里使用的数据是随机生成的,理论上是穷举数据集,评估和训练本质上一致的
     4 '''
     5 改进:
     6 ① 将保存的训练参数使用相对路径
     7 
     8 '''
     9 
    10 import input
    11 import model
    12 import numpy as np
    13 import os
    14 import tensorflow as tf
    15 
    16 bins = 6
    17 sum_num = 1000
    18 n_classes = 5
    19 
    20 BATCH_SIZE = 256
    21 CAPACITY = 128
    22 learn_rate = 0.0010485759
    23 step_damp = 100
    24 rate_damp = 0.9
    25 MAX_STEP = 160000
    26 
    27 root_folder = os.path.dirname(os.path.realpath(__file__))
    28 os.chdir(root_folder)  # 返回上一级文件夹
    29 # print(root_folder)
    30 # print(os.path.dirname(root_folder))
    31 folder = "model2//"  # 使用相对路径
    32 obj = input.data_origin(sum_num)
    33 '''
    34 DNN配置
    35 '''
    36 os.environ["CUDA_VISIBLE_DEVICES"] = '0'  # 指定第一块GPU可用
    37 config = tf.ConfigProto(allow_soft_placement=True)
    38 config.gpu_options.per_process_gpu_memory_fraction = 0.85  # 程序最多只能占用指定gpu 70%的显存
    39 config.gpu_options.allow_growth = True  # 程序按需申请内存
    40 with tf.Session(config=config) as sess:
    41     global_step = tf.Variable(0, name='global_step', trainable=False)  # 有变更,需要注意
    42     learning_rate = tf.train.exponential_decay(learn_rate, global_step, step_damp, rate_damp, staircase=False)
    43 
    44     data_batch = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, bins], name='data')
    45     label_batch = tf.placeholder(dtype=tf.int32, shape=[BATCH_SIZE], name='label')
    46 
    47     train_logits = model.inference(data_batch, BATCH_SIZE, n_classes)
    48     train_loss = model.losses(train_logits, label_batch)
    49     train_op = model.trainning(train_loss, learning_rate, global_step)
    50     train__acc = model.evaluation(train_logits, label_batch)
    51 
    52     summary_op = tf.summary.merge_all()
    53     train_writer = tf.summary.FileWriter(folder, sess.graph)
    54     saver = tf.train.Saver()
    55 
    56     sess.run(tf.global_variables_initializer())
    57     for step in np.arange(MAX_STEP):
    58         data, label = obj.data_sum(BATCH_SIZE)
    59         _ = sess.run(train_op, {data_batch: data, label_batch: label})
    60         if step % step_damp == 0:
    61             step_now, tra_loss, learn_rate, accuracy_now = sess.run(
    62                 [global_step, train_loss, learning_rate, train__acc], {data_batch: data, label_batch: label})
    63 
    64             print('Step %d, train_loss = %f ,accuracy = %f ,learn_rate = %.10f ' % (
    65             step_now, tra_loss, accuracy_now, learn_rate))
    66         if (step % 10000 == 0) or ((step + 1) == MAX_STEP):
    67             checkpoint_path = os.path.join(folder, 'model.ckpt')
    68             saver.save(sess, checkpoint_path, global_step=step)

    附录代码:evaluate.pyw

     1 # coding=utf-8
     2 # 产生数据—训练-评估-结束标准
     3 # 这里使用的数据是随机生成的,理论上是穷举数据集,评估和训练本质上一致的
     4 """
     5 改进:
     6 ① 将保存的训练参数使用相对路径
     7 
     8 """
     9 
    10 import input
    11 import model
    12 import numpy as np
    13 import os
    14 import tensorflow as tf
    15 
    16 bins = 6
    17 sum_num = 1000
    18 n_classes = 5
    19 
    20 BATCH_SIZE = 2048
    21 CAPACITY = 128
    22 step = 10
    23 
    24 root_folder = os.path.dirname(os.path.realpath(__file__))
    25 os.chdir(root_folder)  # 返回上一级文件夹
    26 
    27 logs_train_dir = "model2"  # 使用相对路径
    28 obj = input.data_origin(sum_num)
    29 
    30 
    31 def evaluate(logs_train_dir, BATCH_SIZE):
    32     # GPU计算资源参数
    33     os.environ["CUDA_VISIBLE_DEVICES"] = '0'  # 指定第一块GPU可用
    34     config = tf.ConfigProto(allow_soft_placement=True)
    35     config.gpu_options.per_process_gpu_memory_fraction = 0.85  # 程序最多只能占用指定gpu 70%的显存
    36     config.gpu_options.allow_growth = True  # 程序按需申请内存
    37     with tf.Session(config=config) as sess:
    38 
    39         data_batch = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, bins], name='data')
    40         label_batch = tf.placeholder(dtype=tf.int32, shape=[BATCH_SIZE], name='label')
    41 
    42         train_logits = model.inference(data_batch, BATCH_SIZE, n_classes)
    43         # evaluate_logits = tf.nn.softmax(train_logits)
    44         evaluate_logits = tf.argmax(train_logits, 1)
    45         train__acc = model.evaluation(train_logits, label_batch)
    46 
    47         # 计算图保存参数
    48         # summary_op = tf.summary.merge_all()
    49         # train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
    50         saver = tf.train.Saver()
    51 
    52         sess.run(tf.global_variables_initializer())
    53         # coord = tf.train.Coordinator()
    54         # threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    55 
    56         # 加载训练后的参数
    57         ckpt = tf.train.get_checkpoint_state(logs_train_dir)
    58         if ckpt and ckpt.model_checkpoint_path:
    59             global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
    60             saver.restore(sess, ckpt.model_checkpoint_path)
    61             print('模型加载成功, 训练的步数为 %s' % global_step)
    62         else:
    63             print('模型加载失败,,,文件没有找到')
    64 
    65         # 写入预测数据前期设置
    66         try:
    67             for i in np.arange(step):
    68                 data, label = obj.data_sum(BATCH_SIZE)
    69                 # if coord.should_stop():
    70                 #     break
    71                 # accuracy_now, prediction = sess.run([train__acc, evaluate_logits],
    72                 #                                     {data_batch: data, label_batch: label})
    73                 # print('accuracy = %f' % (accuracy_now), 'label is ', label, 'prediction is ', prediction)
    74 
    75                 accuracy_now = sess.run(train__acc,{data_batch: data, label_batch: label})
    76                 print('accuracy = %f' % accuracy_now)
    77 
    78         except tf.errors.OutOfRangeError:
    79             print('Done training -- epoch limit reached')
    80         # finally:
    81         #     coord.request_stop()
    82         # coord.join(threads)
    83         # print("正常预测第", circle, "个数据", label[circle])
    84     sess.close()
    85 
    86 
    87 evaluate(logs_train_dir, BATCH_SIZE)
  • 相关阅读:
    一维数组
    do while循环(熟悉)
    while循环的概念和使用
    break关键字
    continue关键字
    for循环的概念与使用
    switchcase分支结构
    if else if else分支结构
    关于scanf()读取与返回值和回车键的问题
    WCF通过IIS寄宿服务
  • 原文地址:https://www.cnblogs.com/Mufasa/p/10131509.html
Copyright © 2020-2023  润新知