基于encoder-decoder和DCGAN的轨迹压缩研究

目录

  • 基于encoder-decoder和DCGAN的轨迹压缩研究

    • 内容介绍
    • 问题介绍
    • 本文思路
      • 网络模型
      • 代价函数
      • 梯度下降
      • 可视化
    • 完整代码如下：

基于encoder-decoder和DCGAN的轨迹压缩研究

内容介绍

首先，本文的实验结果为：失败。
本文仅实现了程序编码和结果可视化，但是没实现的本文的目标。
理论可行的一个课题研究，但是经过初步尝试，似乎不可行，我也不知道哪些地方错了，或者需要加入那些数据处理步骤，或者程序本身就那里逻辑错了。
本文给出了完整的程序和实验思路，用来交流。
由于我对经典的算法比如小波分析，稀疏编码等知识不太了解（本文并不是这个领域的学者，只是一个菜鸟学生）。所以有可能下面的讨论想法可能都是错的，所以希望大家轻喷。
更多的目的只是希望大家交流，本来想写一篇小论文的，但是经过一天尝试，似乎不太行（感觉存在很多不知道怎么处理的问题）。索性写出来交流（虽然不知道有没有人看）。

问题介绍

AIS数据（可以理解为船舶传感器数据）存在很多的冗余情况，AIS信息由于具有重要的研究价值，不能轻易的删除。但是存储一直累计的海量的AIS数据带来了一些存储上的困难。但是目前没有一种可以一种有效的压缩方法（可以实现压缩和还原）。
因此提出课题：能不能向图片压缩一样，向小波分析一样，找到一个完备的字典，能够将AIS数据实现压缩和还原。
在目前的研究中，较为热门的就是用自编码神经网络，设置合适地约束条件，在不停的迭代学习中，来完成字典的寻找。

本文思路

网络模型

构建一个编码器encoder，一个解码器decoder，和一个判别器discriminator。
其中encoder用来实现压缩编码，decoder实现解码，discriminator用来判断解码出来的轨迹是否和原轨迹一样。
代码如下：

def make_encoder():
    model = tf.keras.Sequential()
    model.add(tf.keras.layers.Flatten())
    model.add(tf.keras.layers.Dense(200,activation='relu'))
    model.add(tf.keras.layers.Dense(200,activation='tanh'))
    model.add(tf.keras.layers.Dense(50,activation='relu'))
    model.add(tf.keras.layers.Dense(25,activation='relu'))
    model.add(tf.keras.layers.Dense(20,activation='tanh'))
    model.add(tf.keras.layers.Reshape((100,2)))
    return model

def make_decoder():
    model = tf.keras.Sequential()
    model.add(tf.keras.layers.Flatten())
    model.add(tf.keras.layers.Dense(20, activation='relu'))
    model.add(tf.keras.layers.Dense(25, activation='relu'))
    model.add(tf.keras.layers.Dense(50, activation='relu'))
    model.add(tf.keras.layers.Dense(200, activation='relu'))
    model.add(tf.keras.layers.Dense(200, activation=None))
    model.add(tf.keras.layers.Reshape((100,2)))
    return model

def make_discriminator_model():
    model= tf.keras.Sequential()
    model.add(tf.keras.layers.Flatten())
    model.add(tf.keras.layers.Dense(200,activation='relu'))
    model.add(tf.keras.layers.Dense(100,activation='relu'))
    model.add(tf.keras.layers.Dense(50,activation='relu'))
    model.add(tf.keras.layers.Dense(25,activation='tanh'))
    return model

代价函数

较为重要的是构建代价函数，基于GAN的思想，encoder和decoder可以看成一个整体的生成器，于是两个网络的loss都设置为了判别器把生成的轨迹判别为真的的交叉熵。
而discriminator的loss设置为把真实轨迹识别为真的交叉熵和把生成轨迹识别为假的交叉熵的和。基本思路仍然是两个网络在对抗训练中互相收敛。
代码如下

def discriminator_loss(real_output,fake_output):
    real_loss = cross_entropy(tf.ones_like(real_output),real_output)
    fake_loss = cross_entropy(tf.zeros_like(fake_output),fake_output)
    total_loss = real_loss + fake_loss
    return total_loss
def encode_loss(fake_output):
    return cross_entropy(tf.ones_like(fake_output),fake_output)
def decode_loss(fake_output):
    return cross_entropy(tf.ones_like(fake_output),fake_output)

梯度下降

encoder_optimizer=tf.keras.optimizers.Adam(1e-4)
decoder_optimizer=tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer=tf.keras.optimizers.Adam(1e-4)
## 该注解将会使下面的函数被“编译”
@ tf.function
def train_step(track):
    with tf.GradientTape() as encoder_tape, tf.GradientTape() as decoder_tape, tf.GradientTape() as disc_tape:
        en_track = encoder(track,training = True)
        de_track = decoder(en_track,training = True)
        real_output = discriminator(track,training = True)
        fake_output = discriminator(de_track,training =True)

        en_loss = encode_loss(fake_output)
        de_loss = decode_loss(fake_output)
        disc_loss = discriminator_loss(real_output,fake_output)
        gradients_of_encoder = encoder_tape.gradient(en_loss,encoder.trainable_variables)
        gradients_of_decoder = decoder_tape.gradient(de_loss,decoder.trainable_variables)
        gradients_of_disc = disc_tape.gradient(disc_loss,discriminator.trainable_variables)
        encoder_optimizer.apply_gradients(zip(gradients_of_encoder,encoder.trainable_variables))
        decoder_optimizer.apply_gradients(zip(gradients_of_decoder,decoder.trainable_variables))
        discriminator_optimizer.apply_gradients(zip(gradients_of_disc,discriminator.trainable_variables))
        return en_loss, de_loss , disc_loss

可视化

def plot_curve(var):
    var = tf.squeeze(var)
    x = tf.squeeze(var[:,0])
    y=tf.squeeze(var[:,1])
    plt.cla()
    plt.scatter(x,y)
    plt.xlabel('longitude')
    plt.ylabel('latitude')
    plt.show()
    plt.pause(0.1)

完整代码如下：

tensorflow：2.0

import time

import pickle

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import os
# from IPython import display
print(tf.__version__)

data_path = '/home/jason/PycharmProjects/AIS_ZIP/data/data_02.pickle'

f= open('/home/jason/PycharmProjects/AIS_ZIP/data/data_02.pickle','rb')
try:
    data=pickle.load(f)
except:
    pass

data = np.array(data)
def make_encoder():
    model = tf.keras.Sequential()
    model.add(tf.keras.layers.Flatten())
    model.add(tf.keras.layers.Dense(200,activation='relu'))
    model.add(tf.keras.layers.Dense(200,activation='tanh'))
    model.add(tf.keras.layers.Dense(50,activation='relu'))
    model.add(tf.keras.layers.Dense(25,activation='relu'))
    model.add(tf.keras.layers.Dense(20,activation='tanh'))
    model.add(tf.keras.layers.Reshape((100,2)))

    return model

def make_decoder():
    model = tf.keras.Sequential()
    model.add(tf.keras.layers.Flatten())
    model.add(tf.keras.layers.Dense(20, activation='relu'))
    model.add(tf.keras.layers.Dense(25, activation='relu'))
    model.add(tf.keras.layers.Dense(50, activation='relu'))
    model.add(tf.keras.layers.Dense(200, activation='relu'))
    model.add(tf.keras.layers.Dense(200, activation=None))
    model.add(tf.keras.layers.Reshape((100,2)))
    return model

def make_discriminator_model():
    model= tf.keras.Sequential()
    model.add(tf.keras.layers.Flatten())
    model.add(tf.keras.layers.Dense(200,activation='relu'))
    model.add(tf.keras.layers.Dense(100,activation='relu'))
    model.add(tf.keras.layers.Dense(50,activation='relu'))
    model.add(tf.keras.layers.Dense(25,activation='tanh'))
    model.add(tf.keras.layers.Dense(1))
    return model

def plot_curve(var):
    var = tf.squeeze(var)
    x = tf.squeeze(var[:,0])
    y=tf.squeeze(var[:,1])
    plt.cla()
    plt.scatter(x,y)
    plt.show()
    plt.pause(0.1)

encoder=make_encoder()
decoder = make_decoder()
discriminator =make_discriminator_model()

data1 = tf.convert_to_tensor(np.reshape(data[5,:,:],(-1,100,2)),dtype=tf.float32)
# enl = encoder(data1)
# decl = decoder(enl)
print(data1)
plot_curve(data1)
# decision = discriminator(decl)
# # plot_curve(decl)
cross_entropy =tf.keras.losses.BinaryCrossentropy(from_logits=True)
def discriminator_loss(real_output,fake_output):
    real_loss = cross_entropy(tf.ones_like(real_output),real_output)
    fake_loss = cross_entropy(tf.zeros_like(fake_output),fake_output)
    total_loss = real_loss + fake_loss
    return total_loss
def encode_loss(fake_output):
    return cross_entropy(tf.ones_like(fake_output),fake_output)
def decode_loss(fake_output):
    return cross_entropy(tf.ones_like(fake_output),fake_output)

encoder_optimizer=tf.keras.optimizers.Adam(1e-4)
decoder_optimizer=tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer=tf.keras.optimizers.Adam(1e-4)
checkpointer_dir = './training_checkpoints'
checkpointer_prefix = os.path.join(checkpointer_dir,"ckpt")
checkpoint = tf.train.Checkpoint(encoder_optimizer=encoder_optimizer,
                                 decoder_optimizer=decoder_optimizer,
                                 discriminator_optimizer=discriminator_optimizer,
                                 encoder=encoder,
                                 decoder=decoder,
                                 discriminator=discriminator
                                 )
EPOCHS = 500

## 该注解将会使下面的函数被“编译”
@ tf.function
def train_step(track):
    with tf.GradientTape() as encoder_tape, tf.GradientTape() as decoder_tape, tf.GradientTape() as disc_tape:
        en_track = encoder(track,training = True)
        de_track = decoder(en_track,training = True)
        real_output = discriminator(track,training = True)
        fake_output = discriminator(de_track,training =True)
        en_loss = encode_loss(fake_output)
        de_loss = decode_loss(fake_output)
        disc_loss = discriminator_loss(real_output,fake_output)
        gradients_of_encoder = encoder_tape.gradient(en_loss,encoder.trainable_variables)
        gradients_of_decoder = decoder_tape.gradient(de_loss,decoder.trainable_variables)
        gradients_of_disc = disc_tape.gradient(disc_loss,discriminator.trainable_variables)
        encoder_optimizer.apply_gradients(zip(gradients_of_encoder,encoder.trainable_variables))
        decoder_optimizer.apply_gradients(zip(gradients_of_decoder,decoder.trainable_variables))
        discriminator_optimizer.apply_gradients(zip(gradients_of_disc,discriminator.trainable_variables))
        return en_loss, de_loss , disc_loss

def train(dataset,epochs):
    for epoch in range(epochs):
        start = time.time()

        for batch in dataset:
            en_loss, de_loss, disc_loss=train_step(batch)
            print(en_loss, de_loss , disc_loss)

        generate_and_save_images(encoder,decoder,epoch + 1,data1)
        if (epochs+1)%15==0:
            checkpoint.save(file_prefix = checkpointer_prefix)
        print('Time for epochs {} is {} sec'.format(epoch+1,time.time()-start))

        generate_and_save_images(encoder,decoder, epoch + 1, data1)

def generate_and_save_images(model1, model2, epoch, test_input):
    # 注意 training` 设定为 False
    # 因此，所有层都在推理模式下运行（batchnorm）。
    entrack = model1(test_input, training=False)
    detrack = model2(entrack, training=False)

    for i in range(detrack.shape[0]):

        plot_curve(detrack[i, :, :])

    plt.savefig('/pics/image_at_epoch_{:04d}.png'.format(epoch))

plt.ion()
BUFFER_SIZE =93
BATCH_SIZE = 31
train_dataset = tf.data.Dataset.from_tensor_slices(data).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
train(train_dataset,EPOCHS)

原文地址：https://www.cnblogs.com/jason233wang/p/12149719.html

时间： 2024-11-13 08:10:13

基于encoder-decoder和DCGAN的轨迹压缩研究的相关文章

轨迹压缩之Douglas-Peucker算法之Java实现

第一部分 问题描述 1.1 具体任务 本次作业任务是轨迹压缩,给定一个GPS数据记录文件,每条记录包含经度和维度两个坐标字段,所有记录的经纬度坐标构成一条轨迹,要求采用合适的压缩算法,使得压缩后轨迹的距离误差小于30m. 1.2 程序输入 本程序输入是一个GPS数据记录文件. 1.3 数据输出 输出形式是文件,包括三部分,压缩后点的ID序列及坐标.点的个数.平均距离误差.压缩率 第二部分 问题解答 根据问题描述,我们对问题进行求解,问题求解分为以下几步: 2.1 数据预处理 本次程序输入为GPS

基于哈夫曼编码的文件压缩（c++版）

本博客由Rcchio原创 我了解到很多压缩文件的程序是基于哈夫曼编码来实现的,所以产生了自己用哈夫曼编码写一个压缩软件的想法,经过查阅资料和自己的思考,我用c++语言写出了该程序,并通过这篇文章来记录一下自己写该程序学到的东西.因为本人写的程序在压缩率上,还有提升的空间,所以本文将不定期更新,但程序整体的思路不会有较大的改动. 一.基于哈夫曼编码可实现压缩文件的原理分析 在计算机中,数据的存储都是二进制的,并且以字节作为基本的存储单位,像英文字母在文本中占一个字节,汉字占两个字节,我们把这种每一

自定义Encoder/Decoder进行对象传递

转载:http://blog.csdn.net/top_code/article/details/50901623 在上一篇文章中,我们使用Netty4本身自带的ObjectDecoder,ObjectEncoder来实现POJO对象的传输,但其使用的是Java内置的序列化,由于Java序列化的性能并不是很好,所以很多时候我们需要用其他高效的序列化方式,例如 protobuf,Hessian, Kryo,Jackson,fastjson等. 本文中Java序列化不是重点,对Java序列化不熟悉的

一种改进的red5集群方案的应用、基于Red5服务器集群负载均衡调度算法研究

转自: 一种改进的red5集群方案的应用: http://wenku.baidu.com/link?url=jYQ1wNwHVBqJ-5XCYq0PRligp6Y5q6BYXyISUsF56My8DP8dc9CZ4pZvpPz1abxJn8fojMrL0IyfmMHStpvkotqC1RWlRMGnzVL1X4IPOa_ 基于Red5服务器集群负载均衡调度算法研究 http://www.doc88.com/p-0456863461331.html

Jcompress: 一款基于huffman编码和最小堆的压缩、解压缩小程序

前言 最近基于huffman编码和最小堆排序算法实现了一个压缩.解压缩的小程序.其源代码已经上传到github上面: Jcompress下载地址 .在本人的github上面有一个叫Utility的repository,该分类下面有一个名为Jcompress的目录便是本文所述的压缩.解压缩小程序的源代码.后续会在Utility下面增加其他一些实用的小程序,比如基于socket的文件断点下载小程序等等.如果你读了此文觉得还不错,不防给笔者的github点个star, 哈哈.在正式介绍Jcompres

Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation

1.主要完成的任务是能够将英文转译为法文,使用了一个encoder-decoder模型,在encoder的RNN模型中是将序列转化为一个向量.在decoder中是将向量转化为输出序列,使用encoder-decoder能够加入词语与词语之间的顺序信息. 2.另一个任务是将序列表达为一个向量,利用向量能够清楚的看出那些语义上相近的词聚集在一起. 3.在设计RNN的隐藏层时,在读入或产生序列加入了reset和update门,可以选择丢掉记忆信息和更新记忆信息,得到了更有意义的结果.

轨迹压缩之Douglas-Peucker算法之C++实现

http://www.cnblogs.com/xdlwd086/p/5100425.html 这位学长编了java版本的,于是在借鉴学长的思路的基础上,做出了C++的实现,以此分享. #include <stdio.h> //定义输入/输出函数 #include <stdlib.h> //定义杂项函数及内存分配函数 #include <ctime> #include <cstdlib> #include <string> #include <

论文：基于数据挖掘的网络入侵检测关键技术研究-郭春

目录 1.文章主要工作: 1.1 设计了一种适用于入侵检测的特征提取方法.(降维)DSFE:Distance-sum based feature extraction method; 1.2 设计了一种能够适用于入侵检测的样本约简方法.(样本约简,即缩减数据集中的样本数量) 1.3 设计了一种离群点挖掘的异常检测方法.(能够发现数据集中偏离大部分数据的离群值) 1.4 设计了一种包含三个检测模块的两层混合入侵检测模型. 1.文章主要工作: 1.1 设计了一种适用于入侵检测的特征提取方法.(降维)

(5)基于协同过滤推荐算法的图书推荐研究

协同过滤算法以其出色的计算速度和健壮性,在全球范围内特别是在互联网领域中取得了巨大成功.文章介绍了基于物品的协同过滤算法的基本思想和实现步骤,以及应用于实际图书推荐项目中的效果和产生的问题.基于物品的协同过滤算法的基本原理是和某用户历史上感兴趣的物品,越相似的物品,越有可能在用户的推荐列表中获得比较高的排名.算法的基本步骤为收集用户偏好,计算物品之间的相似度,计算用户对某一个物品的兴趣度.文章中介绍的系统在实际应用中效果良好.今后该系统的升级版将重点研究如何解决算法的稀疏性以及如何提高图书推荐质