车联网轨迹隐私保护研究进展

轨迹隐私保护对车联网（IoV）的发展至关重要,归纳和分析现有研究方法有重要意义。车联网轨迹隐私保护思想有轨迹模糊、假名更换和轨迹加密等3类,实现方法分别有基于用户真实轨迹的方法和基于哑元轨迹的方法、基于混合区域的方法和基于路径混淆的方法、基于私密信息检索（PIR）协议的方法和基于空间转换的方法。首先,介绍和归纳了研究背景和常见攻击等车联网轨迹隐私保护关键问题;然后,从方法思想、科学问题、方法演进等方面详细综述了现有车联网轨迹隐私保护方法,并阐述了需深入研究的难题;在此基础上,总结了代表性方案的隐私保护度、抗攻击性、复杂度等性能指标;最后展望了车联网轨迹隐私保护的未来研究方向。     

自动驾驶场景下的轨迹预测技术综述

轨迹预测是自动驾驶和智能交通领域的关键技术,对于车辆和移动行人轨迹的准确预测可提升自动驾驶系统对周围环境变化的感知能力,保障自动驾驶系统的安全性。数据驱动轨迹预测方法可捕捉智能体之间的交互特征,对场景内智能体历史运动和静态环境信息进行分析,准确预测智能体的未来轨迹。介绍轨迹预测的数学模型并将其分为传统轨迹预测方法和数据驱动轨迹预测方法 2类,阐述主流数据驱动轨迹预测方法所面临的智能体交互建模、运动行为意图预测、轨迹多样性预测、场景内静态环境信息融合等4个主要挑战,从轨迹预测数据集使用、性能评价指标、模型特点等方面出发对典型数据驱动轨迹预测方法进行分析与对比,总结归纳这些典型数据驱动轨迹预测方法针对上述挑战的解决思路和应用场景,并对自动驾驶场景下轨迹预测技术的未来发展方向进行展望。     

轨迹表示学习技术研究进展

基于地理位置信息的应用和服务的迅速发展对轨迹数据挖掘提出新的需求和挑战.原始轨迹数据通常是由坐标-时间戳元组构成的有序序列组成,而现有的大多数数据分析算法均要求输入数据位于向量空间中.因此,为了将轨迹数据从变长的坐标-时间戳序列转化定长的向量表示且保持原有的特征,对轨迹数据进行有效的表示是十分重要且必要的一步.传统的轨迹表示方法多是基于人工设计特征,通常仅将轨迹表示作为数据预处理的一部分.随着深度学习的兴起,这种从大规模数据中学习的能力使得基于深度学习的轨迹表示方法相较于传统方法取得了巨大的效果提升,并赋予了轨迹表示更多的可能性.本文对轨迹表示领域中的研究进展进行了全面的总结,将轨迹表示按照研究对象的不同尺度归纳为对轨迹单元的表示和对整条轨迹的表示两大类别,并在每种类别下对不同原理的方法进行了对比分析.其中重点分析了基于轨迹点表示的关键方法,也对近年来广泛使用的基于神经网络的轨迹表示的研究成果做了系统的归类.此外本文介绍了基于轨迹表示的关键应用,最后对轨迹表示领域的未来研究方向进行了展望.     

轨迹数据的时空模式挖掘与管理决策研究综述

时空轨迹数据的获取变得越来越容易,轨迹数据刻画了移动对象的行为模式与活动规律,是对移动对象在时空环境下的移动模式和行为特征的真实写照,在城市规划、交通管理、服务推荐、位置预测等领域具有重要的应用价值。这些过程通常需要通过对时空轨迹数据进行模式挖掘才能得以实现。简述了轨迹数据挖掘的预处理和基本步骤,归纳了异常轨迹检测方法的分类,分析、总结了近年来基于轨迹数据的四种模式挖掘,从管理决策角度对轨迹数据挖掘进行相关综述和分析,有望为轨迹数据的模式挖掘与管理决策提供必要的文献资料和理论基础。     

任务空间轨迹规划问题的回顾与展望

本文从机器人任务空间的几何结构出发,对任务空间轨迹规划进行了总结。首先任务空间被归结为SE（3）空间;在分析了SE（3）的空间结构之后,对SE（3）空间上的轨迹设计方法进行了总结;在此基础上,对机器人任务空间上各类轨迹规划问题进行了归纳,指出了当前研究的不足,并提出了可行的研究思路。     

轨迹大数据:数据处理关键技术研究综述

大数据时代下移动互联网发展与移动终端的普及形成了海量移动对象轨迹数据.轨迹数据含有丰富的时空特征信息,通过轨迹数据处理技术可以挖掘人类活动规律与行为特征、城市车辆移动特征、大气环境变化规律等信息.海量的轨迹数据也潜在性地暴露移动对象行为特征、兴趣爱好和社会习惯等隐私信息,攻击者可以根据轨迹数据挖掘出移动对象的活动场景、位置等属性信息.另外,量子计算因其强大的存储和计算能力成为大数据挖掘重要的理论研究方向,用量子计算技术处理轨迹大数据可以使一些复杂的问题得到解决并实现更高的效率.本文对轨迹大数据中数据处理关键技术进行综述.首先,介绍轨迹数据概念和特征,并且总结了轨迹数据预处理方法包括噪声滤波、轨迹压缩等.其次,归纳轨迹索引与查询技术,以及轨迹数据挖掘已有的研究成果包括模式挖掘、轨迹分类等.总结了轨迹数据隐私保护技术基本原理和特点,介绍了轨迹大数据支撑技术如处理框架、数据可视化.本文也讨论了轨迹数据处理中应用量子计算的可能方式,并且介绍了目前轨迹数据处理中所使用的核心算法所对应的量子算法实现.最后,对轨迹数据处理面临的挑战与未来研究方向进行了总结与展望.     

基于轨迹分析的行人异常行为识别

提出一种基于轨迹分段主题模型的异常行为检测方法。为了解决跟踪偏差引起的轨迹不连续问题,首先使用模糊聚类算法对所有的轨迹进行全局聚类,然后对每一类轨迹采用分段采样的方式对段内轨迹点使用主题模型LDA进行局部聚类;以最大概率的轨迹点作为视觉单词,每类轨迹表示成一系列视觉单词的集合,在此基础上建立局部隐马尔科夫模型HMM;最后通过轨迹匹配的方法进行异常轨迹识别。在CAVIAR数据库上的实验结果表明,该算法能识别多种异常行为,提高了异常行为检测的准确率。     

基于立体视觉的目标检测与轨迹预测研究综述

目前基于立体视觉信息的运动目标识别定位、跟踪及轨迹预测是机器视觉领域的研究热点.通过归纳整理相关文献,从双目立体视觉技术、运动目标检测技术、运动目标轨迹预测技术三个方面对基于立体视觉的运动目标检测及轨迹预测进行了概述,分别阐述了相机标定的常见方法、图像特征提取及立体匹配不同算法的适用场景、各运动目标检测方法的优缺点、常...     

TFR-resm:一种基于可变区域相似点的新型轨迹隐私保护方法

随着智能设备的不断普及,用户的隐私泄露问题日益频发,针对动态用户信息泄露问题,提出一种新的轨迹隐私保护方法TFR-resm,该方法主要是依靠寻找相似用户,提出使用波动距离与波动角度的方法生成相似位置点代替真实用户发送消息,并且通过提出的SMTA方法构建混合轨迹,由于该轨迹中不存在信息请求用户,达到了预期的隐私保护结果.通过使用真实数据对TFR-resm方法实现,证明提出的方法对轨迹隐私保护匿名度平均提高了5％,最高为15％.     

移动对象轨迹更新体系

在移动对象数据库中存在着移动对象位置的频繁更新,因而,如何管理移动对象轨迹（位置）的更新将成为移动对象数据库要解决的问题。对移动对象轨迹更新策略中存在的问题,提出了一个统一的移动对象轨迹更新体系。首先定义了移动对象的轨迹,从移动对象轨迹建模的角度,将移动对象轨迹的更新策略归纳为基于点与矢量的移动对象轨迹更新策略,给出了移动对象轨迹的更新原理及算法,并进行了两种更新策略的模拟实验比较。     

树型结构在递归程序教学中的应用

递归程序可以嵌套调用,因此在运行过程中其运行轨迹较复杂。本文将用数据结构中的树型结构来形象化描述递归程序运行轨迹,使递归程序的运行轨迹更加清晰明了和易于理解。     

蚁群智能模型检测算法

蚁群智能模型检测算法借鉴了自然界中蚂蚁通过信息素相互沟通,从而完成觅食、搬迁等需要协作的复杂社会活动的原理。通过分布在程序控制流图和状态图上的代理,即人工蚂蚁的回溯来跟踪寻找模型中的正确路径和错误路径,人工蚂蚁在控制流图上移动时,分别在正确路径和错误路径上释放两种不同的信息素,通过对两种信息素的对比,可自动定位出程序中引发特定错误的原因。由于人工蚂蚁之间相互独立、并行工作,因此算法能够同时、并行地跟踪多条正确路径和错误路径,也可同时定位出引发多个不同错误的不同原因。通过对中小规模程序的检测,结果表明,该算法是有效的。     

面向未解释程序的合作验证方法

未解释程序的验证问题通常是不可判定的,但是最近有研究发现,存在一类满足coherence性质的未解释程序,其验证问题是可判定的,并且计算复杂度为PSPACE完全的.在这个结果的基础上,一个针对一般未解释程序验证的基于路径抽象的反例抽象精化（CEGAR）框架被提出,并展现了良好的验证效率.即使如此,对未解释程序的验证工作依然需要多次迭代,特别是利用该方法在针对多个程序验证时,不同的程序之间的验证过程是彼此独立的,存在验证开销巨大的问题.本文发现被验证的程序之间较为相似时,不可行路径的抽象模型可以在不同的程序之间复用.因此,本文提出了一个合作验证的框架,收集在验证过程中不可行路径的抽象模型,并在对新程序进行验证时,用已保存的抽象模型对程序进行精化,提前删减一些已验证的程序路径,从而提高验证效率.此外,本文通过对验证过程中的状态信息进行精简,对现有的基于状态等价的路径抽象方法进行优化,以进一步提升其泛化能力.本文对合作验证的框架以及路径抽象的优化方法进行了实现,并在两个具有代表性的程序集上分别取得了2.70x和1.49x的加速.     

UML行为图驱动的Java程序运行时验证工具

UML是一种标准的可视化建模工具，广泛应用于软件系统的描述、可视化、构建和建立文档。本文介绍了一种UMI。行为图驱动的Java程序运行时验证工具。该工具以一个随机的测试用例集作为输入，运行经过插装的被测Java程序，得到一组用于验证的程序运行轨迹。通过对程序运行轨迹和UML行为图中合法的事件序列的比较，该工具可以对程序的动态行为规约进行检查。本文描述了该工具的设计思想、算法和实现技术，并通过对实例研究对该工具的可用性和有效性进行了讨论。     

A Framework for Generating Distributed-Memory Parallel Programs for Block Recursive Algorithms

A framework for synthesizing communication-efficient distributed-memory parallel programs for block recursive algorithms such as the fast Fourier transform (FFT) and Strassen's matrix multiplication is presented. This framework is based on an algebraic representation of the algorithms, which involves the tensor (Kronecker) product and other matrix operations. This representation is useful in analyzing the communication implications of computation partitioning and data distributions. The programs are synthesized under two different target program models. These two models are based on different ways of managing the distribution of data for optimizing communication. The first model uses point-to-point interprocessor communication primitives, whereas the second model uses data redistribution primitives involving collective all-to-many communication. These two program models are shown to be suitable for different ranges of problem size. The methodology is illustrated by synthesizing communication-efficient programs for the FFT. This framework has been incorporated into the EXTENT system for automatic generation of parallel/vector programs for block recursive algorithms.     

Complexity issues in automated synthesis of failsafe fault-tolerance

We focus on the problem of synthesizing failsafe fault-tolerance where fault-tolerance is added to an existing (fault-intolerant) program. A failsafe fault-tolerant program satisfies its specification (including safety and liveness) in the absence of faults. However, in the presence of faults, it satisfies its safety specification. We present a somewhat unexpected result that, in general, the problem of synthesizing failsafe fault-tolerant distributed programs from their fault-intolerant version is NP-complete in the state space of the program. We also identify a class of specifications, monotonic specifications, and a class of programs, monotonic programs, for which the synthesis of failsafe fault-tolerance can be done in polynomial time (in program state space). As an illustration, we show that the monotonicity restrictions are met for commonly encountered problems, such as Byzantine agreement, distributed consensus, and atomic commitment. Furthermore, we evaluate the role of these restrictions in the complexity of synthesizing failsafe fault-tolerance. Specifically, we prove that if only one of these conditions is satisfied, the synthesis of failsafe fault-tolerance is still NP-complete. Finally, we demonstrate the application of monotonicity property in enhancing the fault-tolerance of (distributed) nonmasking fault-tolerant programs to masking.     

Symbolic synthesis of masking fault-tolerant distributed programs

We focus on automated addition of masking fault-tolerance to existing fault-intolerant distributed programs. Intuitively, a program is masking fault-tolerant, if it satisfies its safety and liveness specifications in the absence and presence of faults. Masking fault-tolerance is highly desirable in distributed programs, as the structure of such programs are fairly complex and they are often subject to various types of faults. However, the problem of synthesizing masking fault-tolerant distributed programs from their fault-intolerant version is NP-complete in the size of the program’s state space, setting the practicality of the synthesis problem in doubt. In this paper, we show that in spite of the high worst-case complexity, synthesizing moderate-sized masking distributed programs is feasible in practice. In particular, we present and implement a BDD-based synthesis heuristic for adding masking fault-tolerance to existing fault-intolerant distributed programs automatically. Our experiments validate the efficiency and effectiveness of our algorithm in the sense that synthesis is possible in reasonable amount of time and memory. We also identify several bottlenecks in synthesis of distributed programs depending upon the structure of the program at hand. We conclude that unlike verification, in program synthesis, the most challenging barrier is not the state explosion problem by itself, but the time complexity of the decision procedures.     

Using SPIN for automated debugging of infinite executions of Java programs

This paper presents an approach for the automated debugging of reactive and concurrent Java programs, combining model checking and runtime monitoring. Runtime monitoring is used to transform the Java execution traces into the input for the model checker, the purpose of which is twofold. First, it checks these execution traces against properties written in linear temporal logic (LTL), which represent desirable or undesirable behaviors. Second, it produces several execution traces for a single Java program by generating test inputs and exploring different schedulings in multithreaded programs. As state explosion is the main drawback to model checking, we propose two abstraction approaches to reduce the memory requirements when storing Java states. We also present the formal framework to clarify which kinds of LTL safety and liveness formulas can be correctly analysed with each abstraction for both finite and infinite program executions. A major advantage of our approach comes from the model checker, which stores the trace of each failed execution, allowing the programmer to replay these executions to locate the bugs. Our current implementation, the tool TJT, uses Spin as the model checker and the Java Debug Interface (JDI) for runtime monitoring. TJT is presented as an Eclipse plug-in and it has been successfully applied to debug complex public Java programs.     

A study of potential parallelism among traces in Java programs

The exploitation of parallelism among traces, i.e. hot paths of execution in programs, is a novel approach to the automatic parallelization of Java programs and it has many advantages. However, to date, the extent to which parallelism exists among traces in programs has not been made clear. The goal of this study is to measure the amount of trace-level parallelism in several Java programs. We extend the Jupiter Java Virtual Machine with a simulator that models an abstract parallel system. We use this simulator to measure trace-level parallelism. We further use it to examine the effects of the number of processors, trace window size, and communication type and cost on performance. We also analyze the dependence characteristics of the benchmarks and see how they relate to parallelism. The results indicate that enough trace-level parallelism exists for a modest number of processors. Thus, we conclude that trace-based parallelization is a potentially viable approach to improve the performance of Java programs.     

Distance String Models for Program Behavior

To analyze or simulate an operating/computer system, one must construct a model of the programs executing within the system. Many recent analyses, particularly queueing models, have used mathematically convenient program models. For example, in one popular model the times between page faults are assumed to be exponentially distributed and independent. However, such a program model is inaccurate, which may cause the analysis to be unrepresentative of the real world. Simulation models of systems, on the other hand, have relied largely on traces of actual programs. Such traces are undoubtedly more accurate than simple mathematical models, but they have several drawbacks. They are expensive to generate, they may not be truly representative of typical programs, and they may contain more detail than is necessary for accurate system modeling. Moreover, it is difficult to extrapolate their behavior to other similar programs.