精华内容
下载资源
问答
  • 2018-06-27 17:45:30

    转载自https://blog.csdn.net/devCopper/article/details/11726871

    关于四叉树的原理我想应该不需要多说啦,大家都懂得,实在不晓得的话,百度吧~

    由于四叉树索引效率还可以并且非常简单,因此在Gis中广泛的应用也是毋庸置疑的。

     

    本次就自己实现一个地图四叉树索引,但是还有一些问题也希望各位路过的大神能指点一下。

     

    首先,结合一下应用场景(我们需要用四叉树来索引地图数据),考虑一下使用四叉树索引地图数据存在的一些问题。

    1.什么时候建立四叉树索引,四叉树索引如何存储(序列化还是自己写算法来存储四叉树)?第一次加载数据的时候建立四叉树,当对地图数据操作的时候动态的维护四叉树,关闭地图的时候,保存内存中的四叉树实例,以避免每次建立四叉树耗时。目前我直接使用四叉树序列化。

    2.什么东西可能会影响到四叉树索引地图数据的效率?树的深度,空节点每次还要被搜索,使用不平衡四叉树来避免无意义的搜索;每个节点上所关联的地图数据个数。子节点已经包含了地图数据的实例,则父节点不包含,减少数据的冗余。

     

    为了可以在四叉树节点上关联地图数据,设计如下结构来表示地图数据。

    [csharp]  view plain  copy
    1. /// <summary>  
    2. /// 包含有包络线的对象接口定义  
    3. /// </summary>  
    4. public interface IHasBoundingBox  
    5. {  
    6.     /// <summary>  
    7.     /// 几何对象的包络线  
    8.     /// </summary>  
    9.     BoundingBox Box  
    10.     {  
    11.         get;  
    12.         set;  
    13.     }  
    14. }  


     

    [csharp]  view plain  copy
    1. /// <summary>  
    2. /// 几何对象的的ID和包络线构成索引对象  
    3. /// </summary>  
    4. public class GeoBox:IHasBoundingBox  
    5. {  
    6.     BoundingBox _box;  
    7.   
    8.     /// <summary>  
    9.     /// 几何对象的Id  
    10.     /// </summary>  
    11.     public uint ID;  
    12.  
    13.     #region IHasBoundingBox 成员  
    14.   
    15.     public BoundingBox Box  
    16.     {  
    17.         get  
    18.         {  
    19.             return _box;  
    20.         }  
    21.         set  
    22.         {  
    23.             _box = value;  
    24.         }  
    25.     }  
    26.  
    27.     #endregion  
    28. }  


    用一个矩形范围和几何对象的Id来表示地图上需要索引的几何对象,当请求地图数据的时候,首先根据地图范围来遍历四叉树,找到对应四叉树的节点后,遍历该自树获取所有数据,即Id,根据Id去读取物理文件的数据。

     

    四叉树节点的定义:

    [csharp]  view plain  copy
    1. /// <summary>  
    2. /// 四叉树节点  
    3. /// </summary>  
    4. /// <typeparam name="T">节点中所包含的数据类型</typeparam>  
    5. public class QuadNode<T>  
    6. {  
    7.     private int _depth;  
    8.     private List<T> _datas;  
    9.     private BoundingBox _rect;  
    10.     private QuadNode<T> _lt;  
    11.     private QuadNode<T> _rt;  
    12.     private QuadNode<T> _lb;  
    13.     private QuadNode<T> _rb;  
    14.     private bool _isLeaf;  
    15.     private QuadNodeLimit _limit;  
    16.   
    17.     public QuadNodeLimit Limit  
    18.     {  
    19.         get { return _limit; }  
    20.     }  
    21.   
    22.     public bool IsLeaf  
    23.     {  
    24.         get { return _isLeaf; }  
    25.         set { _isLeaf = value; }  
    26.     }  
    27.   
    28.     public int Depth  
    29.     {  
    30.         get { return _depth; }  
    31.         set { _depth = value; }  
    32.     }  
    33.   
    34.     public List<T> Datas  
    35.     {  
    36.         get { return _datas; }  
    37.         set { _datas = value; }  
    38.     }  
    39.   
    40.     public BoundingBox Rect  
    41.     {  
    42.         get { return _rect; }  
    43.         set { _rect = value; }  
    44.     }  
    45.   
    46.     public QuadNode<T> LT  
    47.     {  
    48.         get { return _lt; }  
    49.         set { _lt = value; }  
    50.     }  
    51.   
    52.     public QuadNode<T> RT  
    53.     {  
    54.         get { return _rt; }  
    55.         set { _rt = value; }  
    56.     }  
    57.   
    58.     public QuadNode<T> LB  
    59.     {  
    60.         get { return _lb; }  
    61.         set { _lb = value; }  
    62.     }  
    63.   
    64.     public QuadNode<T> RB  
    65.     {  
    66.         get { return _rb; }  
    67.         set { _rb = value; }  
    68.     }  
    69.   
    70.     public QuadNode(BoundingBox box,QuadNodeLimit limit, int depth)  
    71.     {  
    72.         _datas = new List<T>();  
    73.         _rect = box;  
    74.         _lt = null;  
    75.         _rt = null;  
    76.         _lb = null;  
    77.         _rb = null;  
    78.         _isLeaf = true;  
    79.         _depth = depth;  
    80.         _limit = limit;  
    81.     }  
    82.   
    83.     public bool Insert(T data)  
    84.     {  
    85.         QuadNode<T> ret = QueryNode((data as IHasBoundingBox).Box);  
    86.         if (ret != null)  
    87.         {  
    88.             //此处开始分裂子节点,不是平衡四叉树  
    89.             if ( ret.Datas.Count >= _limit.MaxObjNum && ret.Depth < _limit.MaxDepth)  
    90.             {  
    91.                 BoundingBox childBox;  
    92.                 double xmin = 0;  
    93.                 double ymin = 0;  
    94.                 double xmax = 0;  
    95.                 double ymax = 0;  
    96.   
    97.                 // 开始分裂子节点  
    98.                 if (ret.LT == null)  
    99.                 {  
    100.                     xmin = _rect.Min.X;  
    101.                     ymin = _rect.Min.Y;  
    102.                     xmax = _rect.Min.X + _rect.Width / 2;  
    103.                     ymax = _rect.Min.Y + _rect.Height/2;  
    104.   
    105.                     childBox = new BoundingBox(xmin, ymin, xmax, ymax);  
    106.                     if (childBox.Contains((data as IHasBoundingBox).Box))  
    107.                     {  
    108.                         ret.LT = new QuadNode<T>(childBox, ret.Limit, ret.Depth + 1);  
    109.                         ret.IsLeaf = false;  
    110.                         SplitDatas(ret.LT, ret.Datas);  
    111.                         ret = ret.LT;  
    112.                     }  
    113.                 }  
    114.                 if (ret.RT == null)  
    115.                 {  
    116.                     xmin = _rect.Min.X + _rect.Width / 2;  
    117.                     ymin = _rect.Min.Y;  
    118.                     xmax = _rect.Max.X;  
    119.                     ymax = _rect.Min.Y + _rect.Height / 2;  
    120.   
    121.                     childBox = new BoundingBox(xmin, ymin, xmax, ymax);  
    122.                     if (childBox.Contains((data as IHasBoundingBox).Box))  
    123.                     {  
    124.                         ret.RT = new QuadNode<T>(childBox, ret.Limit, ret.Depth + 1);  
    125.                         ret.IsLeaf = false;  
    126.                         SplitDatas(ret.RT, ret.Datas);  
    127.                         ret = ret.RT;  
    128.                     }  
    129.                 }  
    130.                 if (ret.LB == null)  
    131.                 {  
    132.                     xmin = _rect.Min.X;  
    133.                     ymin =  _rect.Min.Y + _rect.Height / 2;  
    134.                     xmax = _rect.Min.X + _rect.Width / 2;  
    135.                     ymax = _rect.Max.Y;  
    136.   
    137.                     childBox = new BoundingBox(xmin, ymin, xmax, ymax);  
    138.                     if (childBox.Contains((data as IHasBoundingBox).Box))  
    139.                     {  
    140.                         ret.LB = new QuadNode<T>(childBox, ret.Limit, ret.Depth + 1);  
    141.                         ret.IsLeaf = false;  
    142.                         SplitDatas(ret.LB, ret.Datas);  
    143.                         ret = ret.LB;  
    144.                     }  
    145.                 }  
    146.                 if (ret.RB == null)  
    147.                 {  
    148.                     xmin = _rect.Min.X + _rect.Width / 2;  
    149.                     ymin = _rect.Min.Y + _rect.Height / 2;  
    150.                     xmax = _rect.Max.X;  
    151.                     ymax = _rect.Max.Y;  
    152.   
    153.                     childBox = new BoundingBox(xmin, ymin, xmax, ymax);  
    154.                     if (childBox.Contains((data as IHasBoundingBox).Box))  
    155.                     {  
    156.                         ret.RB = new QuadNode<T>(childBox, ret.Limit, ret.Depth + 1);  
    157.                         ret.IsLeaf = false;  
    158.                         SplitDatas(ret.RB, ret.Datas);  
    159.                         ret = ret.RB;  
    160.                     }  
    161.                 }  
    162.             }  
    163.             ret.Datas.Add(data);  
    164.             return true;  
    165.         }  
    166.         else  
    167.             return false;  
    168.     }  
    169.   
    170.     public void Remove(T data)  
    171.     {  
    172.         QuadNode<T> ret = QueryNode((data as IHasBoundingBox).Box);  
    173.         if (ret != null)  
    174.             ret.Datas.Remove(data);  
    175.     }  
    176.   
    177.     public QuadNode<T> QueryNode(BoundingBox env)  
    178.     {  
    179.         QuadNode<T> ret = null;  
    180.         if (Rect.Contains(env) || Rect.Equals(env))  
    181.         {  
    182.             ret = this;  
    183.         }  
    184.         else if (env.Contains(Rect))  
    185.         {  
    186.             return this;  
    187.         }  
    188.         else  
    189.         {  
    190.             return null;  
    191.         }  
    192.         if (LT != null && LT.Rect.Contains(env))  
    193.         {  
    194.             ret = LT.QueryNode(env);  
    195.         }  
    196.         else if (RT != null && RT.Rect.Contains(env))  
    197.         {  
    198.             ret = RT.QueryNode(env);  
    199.         }  
    200.         else if (LB != null && LB.Rect.Contains(env))  
    201.         {  
    202.             ret = LB.QueryNode(env);  
    203.         }  
    204.         else if (RB != null && RB.Rect.Contains(env))  
    205.         {  
    206.             ret = RB.QueryNode(env);  
    207.         }  
    208.         return ret;  
    209.     }  
    210.   
    211.     public void QueryData(QuadNode<T> node, ref List<T> datas)  
    212.     {  
    213.         QuadNode<T> tempNode = node;  
    214.   
    215.         datas.AddRange(tempNode.Datas);  
    216.         if (tempNode.LT != null)  
    217.         {  
    218.             QueryData(tempNode.LT, ref datas);  
    219.         }  
    220.         if (tempNode.LB != null)  
    221.         {  
    222.             QueryData(tempNode.LB, ref datas);  
    223.         }  
    224.         if (tempNode.RT != null)  
    225.         {  
    226.             QueryData(tempNode.RT, ref datas);  
    227.         }  
    228.         if (tempNode.RB != null)  
    229.         {  
    230.             QueryData(tempNode.RB, ref datas);  
    231.         }  
    232.     }  
    233.   
    234.     private void SplitDatas(QuadNode<T> node, List<T> datas)  
    235.     {  
    236.         for (int i = 0; i < datas.Count; i++)   
    237.         {  
    238.             if (node.Rect.Contains((datas[i] as IHasBoundingBox).Box))  
    239.             {  
    240.                 node.Datas.Add(datas[i]);  
    241.             }  
    242.         }  
    243.         //是否去掉父节点重复的节点,若是去掉获取数据消耗时间会变长,若是没有去掉则树中会有大量的冗余数据  
    244.         for (int i = 0; i < node.Datas.Count; i++)  
    245.         {  
    246.             datas.Remove(node.Datas[i]);  
    247.         }  
    248.     }  
    249. }  

     

    四叉树的定义:

    [csharp]  view plain  copy
    1. /// <summary>  
    2. /// 四叉树地图索引  
    3. /// 四叉树必须要保证层数不能太深,同时也要保证节点保存对象数目不能大于规定的最大对象数目  
    4. /// 上述两个条件冲突时以深度为优先判断要素  
    5. /// 节点保存对象数目小于规定的最小保存数目时该节点则该节点不再分裂子节点  
    6. /// 注意:删除数据时该树不会自动萎缩,用户可以调用重新构造树的方法进行维护树  
    7. /// devCopper 2013.9.12  
    8. /// </summary>  
    9. /// <typeparam name="T">保存对象的数据类型</typeparam>  
    10. public class QuadTree<T> where T : IHasBoundingBox  
    11. {  
    12.     QuadNode<T> _root;  
    13.   
    14.     List<T> _datas;  
    15.   
    16.     /// <summary>  
    17.     /// 四叉树的根节点  
    18.     /// </summary>  
    19.     public QuadNode<T> Root  
    20.     {  
    21.         get { return _root; }  
    22.         set { _root = value; }  
    23.     }  
    24.   
    25.     /// <summary>  
    26.     /// 所有被索引的对象  
    27.     /// </summary>  
    28.     public List<T> Datas  
    29.     {  
    30.         get { return _datas; }  
    31.         set { _datas = value; }  
    32.     }  
    33.   
    34.     public QuadTree()  
    35.     { }  
    36.   
    37.     /// <summary>  
    38.     /// 构造函数  
    39.     /// </summary>  
    40.     /// <param name="env">根节点的包围盒</param>  
    41.     public QuadTree(BoundingBox env, QuadNodeLimit limit)  
    42.     {  
    43.         _root = new QuadNode<T>(env, limit, 0);  
    44.         _datas = new List<T>();  
    45.     }  
    46.   
    47.     /// <summary>  
    48.     /// 插入一个对象  
    49.     /// </summary>  
    50.     /// <param name="data">插入的数据</param>  
    51.     public void Insert(T data)  
    52.     {  
    53.         _root.Insert(data);  
    54.         _datas.Add(data);  
    55.     }  
    56.   
    57.     /// <summary>  
    58.     /// 移除一个对象  
    59.     /// </summary>  
    60.     /// <param name="data">移除的对象,该对象的BoundingBox属性值不需要关心</param>  
    61.     public void Remove(T data)   
    62.     {  
    63.         _root.Remove(data);  
    64.         _datas.Remove(data);  
    65.     }  
    66.   
    67.     /// <summary>  
    68.     /// 遍历四叉树查询矩形框所包含的对象  
    69.     /// </summary>  
    70.     /// <param name="env">查询条件</param>  
    71.     /// <returns>包含对象的节点</returns>  
    72.     public List<T> Query(BoundingBox env)  
    73.     {  
    74.         List<T> data = new List<T>();  
    75.   
    76.         QuadNode<T> ret = _root.QueryNode(env);  
    77.         if (ret != null)  
    78.             ret.QueryData(ret, ref data);  
    79.   
    80.         return data;  
    81.     }  
    82.   
    83.     /// <summary>  
    84.     /// 初始化四叉树  
    85.     /// </summary>  
    86.     /// <param name="objs">初始化对象</param>  
    87.     public void Initialize(List<T> datas)  
    88.     {  
    89.         for (int i = 0; i < datas.Count; i++)  
    90.         {  
    91.             if(_root.Insert(datas[i]))  
    92.                 _datas.Add(datas[i]);  
    93.         }  
    94.     }  
    95.   
    96.     /// <summary>  
    97.     /// 重新构造索引  
    98.     /// </summary>  
    99.     public void Rebuild()  
    100.     {  
    101.         for (int i = 0; i < _datas.Count; i++)  
    102.         {  
    103.             _root.Insert(_datas[i]);  
    104.         }  
    105.     }  
    106.   
    107.     /// <summary>  
    108.     /// 从文件中读取四叉树索引  
    109.     /// </summary>  
    110.     /// <param name="file">文件</param>  
    111.     /// <returns>一颗四叉树</returns>  
    112.     public static QuadTree<GeoBox>  FromFile(string file)  
    113.     {  
    114.         System.IO.FileStream fs = new System.IO.FileStream(file, System.IO.FileMode.Open);  
    115.         BinaryFormatter bf = new BinaryFormatter();  
    116.   
    117.         QuadTree<GeoBox> tree = (QuadTree<GeoBox>)bf.Deserialize(fs);  
    118.           
    119.         fs.Close();  
    120.         return tree;  
    121.     }  
    122.   
    123.     /// <summary>  
    124.     /// 保存四叉树索引  
    125.     /// </summary>  
    126.     /// <param name="tree">四叉树对象</param>  
    127.     /// <param name="file">保存的文件</param>  
    128.     public static void SaveIndex(QuadTree<GeoBox> tree, string file)  
    129.     {  
    130.         System.IO.FileStream fs = new System.IO.FileStream(file, System.IO.FileMode.CreateNew);  
    131.         BinaryFormatter bf = new BinaryFormatter();  
    132.         bf.Serialize(fs, tree);  
    133.         fs.Close();  
    134.     }  
    135.   
    136. }  


    更多相关内容
  • 机器学习笔记 - 自动编码器autoencoder

    千次阅读 2022-03-18 10:19:46
    通过这过程,自动编码器可以学习数据的重要特征。 自动编码器是由多层组成的神经网络。自动编码器的定义方面是输入层包含与输出层一样多的信息。输入层和输出层具有完全相同数量的单元的原因是自动编码器旨在...

    一、什么是自动编码器?

            自编码器是开发无监督学习模型的主要方式之一。但什么是自动编码器?

            简而言之,自动编码器通过接收数据、压缩和编码数据,然后从编码表示中重构数据来进行操作。对模型进行训练,直到损失最小化并且尽可能接近地再现数据。通过这个过程,自动编码器可以学习数据的重要特征。

            自动编码器是由多个层组成的神经网络。自动编码器的定义方面是输入层包含与输出层一样多的信息。输入层和输出层具有完全相同数量的单元的原因是自动编码器旨在复制输入数据。然后分析数据并以无监督方式重建数据后输出数据副本。

            通过自动编码器的数据不仅仅是从输入直接映射到输出。自动编码器包含三个组件:压缩数据的编码(输入)部分、处理压缩数据(或瓶颈)的组件和解码器(输出)部分。当数据被输入自动编码器时,它会被编码,然后压缩到更小的尺寸。然后对网络进行编码/压缩数据的训练,并输出该数据的重建。

            神经网络学习了输入数据的“本质”或最重要的特征,这是自动编码器的核心价值。训练完网络后,训练好的模型就可以合成相似的数据,并添加或减去某些目标特征。例如,您可以在加了噪声的图像上训练自动编码器,然后使用经过训练的模型从图像中去除噪声。

            自编码器的应用包括:异常检测、数据去噪(例如图像、音频)、图像着色、图像修复、信息检索等、降维等

    二、自动编码器的架构

            自动编码器基本上可以分为三个不同的组件:编码器、瓶颈和解码器。

    自动编码器基本上可以分为三个不同的组件:编码器、瓶颈和解码器。

            编码器:编码器是一个前馈、全连接的神经网络,它将输入压缩为潜在空间表示,并将输入图像编码为降维的压缩表示。压缩后的图像是原始图像的变形版本。

            code:网络的这一部分包含输入解码器的简化表示。

            解码器:解码器和编码器一样也是一个前馈网络,结构与编码器相似。该网络负责将输入从代码中重建回原始维度。

            首先,输入通过编码器进行压缩并存储在称为code的层中,然后解码器从代码中解压缩原始输入。自编码器的主要目标是获得与输入相同的输出。

            通常情况下解码器架构是编码器的镜像,但也不是绝对的。唯一的要求是输入和输出的维度必须相同。

    三、自动编码器的类型

    1、卷积自动编码器

            卷积自动编码器是通用的特征提取器。卷积自编码器是采用卷积层代替全连接层,原理和自编码器一样,对输入的象征进行降采样以提供较小维度潜在表示,并强制自编码器学习象征的压缩版本。

     2、去噪自动编码器

            这种类型的自动编码器适用于部分损坏的输入,并训练以恢复原始未失真的图像。如上所述,这种方法是限制网络简单复制输入的有效方法。

            目标是网络将能够复制图像的原始版本。通过将损坏的数据与原始数据进行比较,网络可以了解数据的哪些特征最重要,哪些特征不重要/损坏。换句话说,为了让模型对损坏的图像进行去噪,它必须提取图像数据的重要特征。

    3、收缩自动编码器

            收缩自动编码器的目标是降低表示对训练输入数据的敏感性。 为了实现这一点,在自动编码器试图最小化的损失函数中添加一个正则化项或惩罚项。

            收缩自动编码器通常仅作为其他几种自动编码器节点存在。去噪自动编码器使重建函数抵抗输入的小但有限大小的扰动,而收缩自动编码器使特征提取函数抵抗输入的无穷小扰动。

    4、变分自动编码器

            Variational Autoencoders,这种类型的自动编码器对潜在变量的分布做出了假设,并在训练过程中使用了随机梯度变分贝叶斯估计器。

            训练时,编码器为输入图像的不同特征创建潜在分布。

            本质上,该模型学习了训练图像的共同特征,并为它们分配了它们发生的概率。然后可以使用概率分布对图像进行逆向工程,生成与原始训练图像相似的新图像。 

            这种类型的自动编码器可以像GAN一样生成新图像。由于 VAE 在生成行为方面比GAN更加灵活和可定制,因此它们适用于任何类型的艺术生成。

    四、自动编码器与PCA有何不同?

            PCA 和自动编码器是降低特征空间维数的两种流行方法。

             PCA 从根本上说是一种线性变换,但自动编码器可以描述复杂的非线性过程。如果我们要构建一个线性网络(即在每一层不使用非线性激活函数),我们将观察到与 PCA 中相似的降维。

            PCA 试图发现描述原始数据的低维超平面,而自动编码器能够学习非线性流形(流形简单地定义为连续的、不相交的表面)。

    左:形象的说明了自动编码器可以找到的模式。
    右:PCA会降低维度。

             与自动编码器相比,PCA 的计算速度更快且成本更低。但由于参数数量多,自编码器容易过拟合。

    五、自编码器与GAN有何不同?

            1、两者都是生成模型。AE试图找到以特定输入(更高维度)为条件的数据的低维表示,而GAN 试图创建足以概括以鉴别器为条件的真实数据分布的表示。

            2、虽然它们都属于无监督学习的范畴,但它们是解决问题的不同方法。

            GAN 是一种生成模型——它应该学习生成数据集的新样本

            变分自动编码器是生成模型,但普通的自动编码器只是重建它们的输入,不能生成真实的新样本。

    https://www.quora.com/What-is-the-difference-between-Generative-Adversarial-Networks-and-Autoencodershttps://www.quora.com/What-is-the-difference-between-Generative-Adversarial-Networks-and-Autoencoders

    六、实例1:去噪自动编码器

    1、概述

            去噪自动编码器的一个应用的例子是预处理图像以提高光学字符识别 (OCR) 算法的准确性。如果您以前应用过OCR,就会知道一丁点错误的噪声(例如,打印机墨水污迹、扫描过程中的图像质量差等)都会严重影响OCR识别的效果。使用去噪自编码器,可以自动对图像进行预处理,提高质量,从而提高OCR识别算法的准确性。

            我们这里故意向MNIST训练图像添加噪声。目的是使我们的自动编码器能够有效地从输入图像中去除噪声。

    2、参考代码

            创建autoencoder_for_denoising.py文件,插入以下代码。

    # import the necessary packages
    from tensorflow.keras.layers import BatchNormalization
    from tensorflow.keras.layers import Conv2D
    from tensorflow.keras.layers import Conv2DTranspose
    from tensorflow.keras.layers import LeakyReLU
    from tensorflow.keras.layers import Activation
    from tensorflow.keras.layers import Flatten
    from tensorflow.keras.layers import Dense
    from tensorflow.keras.layers import Reshape
    from tensorflow.keras.layers import Input
    from tensorflow.keras.models import Model
    from tensorflow.keras import backend as K
    import numpy as np
    
    class ConvAutoencoder:
    	@staticmethod
    	def build(width, height, depth, filters=(32, 64), latentDim=16):
    		# initialize the input shape to be "channels last" along with
    		# the channels dimension itself
    		# channels dimension itself
    		inputShape = (height, width, depth)
    		chanDim = -1
    		# define the input to the encoder
    		inputs = Input(shape=inputShape)
    		x = inputs
    
    		# loop over the number of filters
    		for f in filters:
    			# apply a CONV => RELU => BN operation
    			x = Conv2D(f, (3, 3), strides=2, padding="same")(x)
    			x = LeakyReLU(alpha=0.2)(x)
    			x = BatchNormalization(axis=chanDim)(x)
    		# flatten the network and then construct our latent vector
    		volumeSize = K.int_shape(x)
    		x = Flatten()(x)
    		latent = Dense(latentDim)(x)
    		# build the encoder model
    		encoder = Model(inputs, latent, name="encoder")
    
    		# start building the decoder model which will accept the
    		# output of the encoder as its inputs
    		latentInputs = Input(shape=(latentDim,))
    		x = Dense(np.prod(volumeSize[1:]))(latentInputs)
    		x = Reshape((volumeSize[1], volumeSize[2], volumeSize[3]))(x)
    		# loop over our number of filters again, but this time in
    		# reverse order
    		for f in filters[::-1]:
    			# apply a CONV_TRANSPOSE => RELU => BN operation
    			x = Conv2DTranspose(f, (3, 3), strides=2, padding="same")(x)
    			x = LeakyReLU(alpha=0.2)(x)
    			x = BatchNormalization(axis=chanDim)(x)
    		# apply a single CONV_TRANSPOSE layer used to recover the
    		# original depth of the image
    		x = Conv2DTranspose(depth, (3, 3), padding="same")(x)
    		outputs = Activation("sigmoid")(x)
    		# build the decoder model
    		decoder = Model(latentInputs, outputs, name="decoder")
    		# our autoencoder is the encoder + decoder
    		autoencoder = Model(inputs, decoder(encoder(inputs)), name="autoencoder")
    		# return a 3-tuple of the encoder, decoder, and autoencoder
    		return (encoder, decoder, autoencoder)
    
    
    # set the matplotlib backend so figures can be saved in the background
    import matplotlib
    matplotlib.use("Agg")
    # import the necessary packages
    from tensorflow.keras.optimizers import Adam
    from tensorflow.keras.datasets import mnist
    import matplotlib.pyplot as plt
    import numpy as np
    import argparse
    import cv2
    # construct the argument parse and parse the arguments
    ap = argparse.ArgumentParser()
    ap.add_argument("-s", "--samples", type=int, default=8, help="# number of samples to visualize when decoding")
    ap.add_argument("-o", "--output", type=str, default="output.png", help="path to output visualization file")
    ap.add_argument("-p", "--plot", type=str, default="plot.png", help="path to output plot file")
    args = vars(ap.parse_args())
    
    # initialize the number of epochs to train for and batch size
    EPOCHS = 25
    BS = 32
    # load the MNIST dataset
    print("[INFO] loading MNIST dataset...")
    ((trainX, _), (testX, _)) = mnist.load_data()
    # add a channel dimension to every image in the dataset, then scale
    # the pixel intensities to the range [0, 1]
    trainX = np.expand_dims(trainX, axis=-1)
    testX = np.expand_dims(testX, axis=-1)
    trainX = trainX.astype("float32") / 255.0
    testX = testX.astype("float32") / 255.0
    
    # sample noise from a random normal distribution centered at 0.5 (since
    # our images lie in the range [0, 1]) and a standard deviation of 0.5
    trainNoise = np.random.normal(loc=0.5, scale=0.5, size=trainX.shape)
    testNoise = np.random.normal(loc=0.5, scale=0.5, size=testX.shape)
    trainXNoisy = np.clip(trainX + trainNoise, 0, 1)
    testXNoisy = np.clip(testX + testNoise, 0, 1)
    
    # construct our convolutional autoencoder
    print("[INFO] building autoencoder...")
    (encoder, decoder, autoencoder) = ConvAutoencoder.build(28, 28, 1)
    opt = Adam(lr=1e-3)
    autoencoder.compile(loss="mse", optimizer=opt)
    # train the convolutional autoencoder
    H = autoencoder.fit(trainXNoisy, trainX, validation_data=(testXNoisy, testX), epochs=EPOCHS, batch_size=BS)
    # construct a plot that plots and saves the training history
    N = np.arange(0, EPOCHS)
    plt.style.use("ggplot")
    plt.figure()
    plt.plot(N, H.history["loss"], label="train_loss")
    plt.plot(N, H.history["val_loss"], label="val_loss")
    plt.title("Training Loss and Accuracy")
    plt.xlabel("Epoch #")
    plt.ylabel("Loss/Accuracy")
    plt.legend(loc="lower left")
    plt.savefig(args["plot"])
    
    
    # use the convolutional autoencoder to make predictions on the
    # testing images, then initialize our list of output images
    print("[INFO] making predictions...")
    decoded = autoencoder.predict(testXNoisy)
    outputs = None
    # loop over our number of output samples
    for i in range(0, args["samples"]):
    	# grab the original image and reconstructed image
    	original = (testXNoisy[i] * 255).astype("uint8")
    	recon = (decoded[i] * 255).astype("uint8")
    	# stack the original and reconstructed image side-by-side
    	output = np.hstack([original, recon])
    	# if the outputs array is empty, initialize it as the current
    	# side-by-side image display
    	if outputs is None:
    		outputs = output
    	# otherwise, vertically stack the outputs
    	else:
    		outputs = np.vstack([outputs, output])
    # save the outputs image to disk
    cv2.imwrite(args["output"], outputs)

            然后输入以下命令进行训练。

    python train_denoising_autoencoder.py --output output_denoising.png --plot plot_denoising.png

    3、训练结果

            经过25epoch的训练结果。

    训练过程很稳定,没有出现过拟合的迹象

             对应的去噪结果图,左边是添加噪声的原始MNIST数字,而右边是去噪自动编码器的输出——可以看到去噪自动编码器能够在消除噪音的同时从图像中恢复原始信号。

    展开全文
  • 信息论与编码

    千次阅读 2020-10-08 15:18:16
    编码是后人沿着香农指明的可行方向,为寻求有效而可靠的编译方法而发展起来的一门学科,主要研究在有噪信道条件下各种可行的编码方案及实施技术。 信息论 信息是什么? 信息是确定性的增加,信息的度量(熵)是信息不...

    信息论研究信息的度量,内容主要围绕香农三大定理展开,研究在不许失真的情况下信息传输率的极限值,以及给定信源且允许一定失真的条件下信息速率极限值,并研究在误码率小于给定值的条件下如何最有效地利用信道的传输能力。
    编码是后人沿着香农指明的可行方向,为寻求有效而可靠的编译方法而发展起来的一门学科,主要研究在有噪信道条件下各种可行的编码方案及实施技术。

    信息论

    • 信息是什么?
      信息是确定性的增加,信息的度量(熵)是信息不确定性的度量.
    • 数字通信系统
      数字通信系统信源、信源及信道编码器、信道、信源及信道译码器、信宿五部分组成;
      信源编码器将信源符号转换成适合信道传输的符号,并压缩信源的冗余度以提高通信的有效性,也叫压缩编码;
      信道编码器通过增加冗余的纠错码元来提高通信的可靠性,配合译码将差错率降到允许范围内.

    1. 信源

    • 信源的数学模型为一个样本空间及概率测度.
    • 信源分为离散的和连续的、无记忆的和有记忆的.离散无记忆单符号信源每次只输出一个离散的符号消息,不同时刻的符号之间彼此统计独立;离散无记忆扩展信源输出的消息是由许多不同时刻发出的符号所成的符号序列,先后发出的符号彼此间统计独立,符号序列的概率是序列中各个符号概率的乘积;有记忆信源时间上先后发出的消息间有依赖关系.

    2. 信道

    • 信道的数学模型用转移概率描述.
    • 信道分为离散的和连续的、无记忆的和有记忆的.离散无记忆单符号信道(DMC)的输入和输出都是离散无记忆的单个符号,离散无记忆N维扩展信道的输入输出都是长为N的符号序列,序列的信道转移概率是对应N个符号信道转移概率的乘积.
    • 四种常见DMC:二元对称信道,无干扰信道,二元删除信道,二元Z信道.

    3. 信息的度量

    自信息量

    • 自信息量(信息量):​​​​​​
      在这里插入图片描述
    • 条件自信息量:接收到yj后对xi是否发生的不确定度:在这里插入图片描述
      q(xi)为先验概率,q(xi|yj)为后验概率.

    互信息量

    • 互信息量:事件x,y之间的互信息是y发生所得到的关于x的信息量,等于“x的自信息量”减去 “y条件下x的自信息量”:
      在这里插入图片描述在这里插入图片描述在这里插入图片描述
    • 互信息量的性质
      互易: I(x;y)=I(y;x);
      可负: yj的发生降低了xi发生的可能性;
      当xi,yj统计独立时,互信息量及条件互信息量为0;
      任何两个事件的互信息量不大于其中一个事件的自信息量.

    信息熵

    • 平均自信息量(熵,信源熵):在这里插入图片描述

    • 平均条件自信息量(条件熵):在这里插入图片描述
      联合概率q(xiyj)=q(yj|xi)q(xi)=q(xi|yj)q(yj);当X和Y统计独立时,q(xiyj)=q(xi)q(yj).

    • 联合熵:H(X)在二维空间XY上的推广
      在这里插入图片描述

    • 平均互信息量(交互熵):
      在这里插入图片描述

    • 熵,条件熵,联合熵的关系:
      在这里插入图片描述
      当X,Y统计独立时:
      在这里插入图片描述

    • 交互熵与信源熵,条件熵的关系:
      在这里插入图片描述

    熵函数的性质

    • 极值性(极大离散熵定理):对于有限离散随机变量集合,当集合中的事件等概率发生时,熵最大.在这里插入图片描述
    • 条件熵小于等于无条件熵: H(Y|X) ≤ H(Y);
    • 联合熵大于独立事件的熵,小于等于两独立事件熵之和:H(XY)>=H(X),H(XY)>=H(Y),H(XY)<=H(X)+H(Y).

    平均互信息量性质

    • 非负:I(X;Y)>=0;
    • 互易:I(X;Y)=I(Y;X);
    • 极值:I(X;Y)<=H(X),I(X;Y)<=H(Y);
    • 凹凸性:平均互信息量I(X;Y)是信源的n凸函数,是信道的u型凸函数.

    4.信源编码

    无失真编码不改变信源的熵.
    码的分类
    信源编码可看作信源符号集(消息)到码符号集的一种映射,码字是码符号的组合;课程内只讨论唯一可译码(唯一可译码可保证无差错编码).

    • 二元码:码符号集为0,1;

    • 等长码/变长码:都是唯一可译码;

    • 奇异码/非奇异码:非奇异码不同消息对应不同码字;

    • 原码的N次拓展码:将信源N次拓展得到新的信源符号序列而由原码级联得到的新码;

    • 唯一可译码:任意N次拓展码都是非奇异码的码;
      所有可译码中平均码长最短的称为最佳码,信源编码就是寻找最佳码.
      克拉夫特不等式:在这里插入图片描述

    • 即时码:任一码字都不是其他码字字头的码(也称无前缀码);
      即时码一定是唯一可译码;即时码可用树图法构造
      在这里插入图片描述

    信息传输速率

    • 平均码长:在这里插入图片描述
    • 信息传输速率:在这里插入图片描述
    • 编码效率:在这里插入图片描述

    等长编码定理和变长编码定理

    • 等长编码定理
      在这里插入图片描述
    • 变长编码定理(香农第一定理)在这里插入图片描述

    三种常用变长码编码方法

    • 香农编码法,费诺编码法,霍夫曼编码法(编码效率最高)

    5. 信道编码基础

    信道编码是为了抵抗信道干扰提高可靠性而进行的处理和变换,如差错控制编码,最简单的如"重复编码,择多译码".
    信道容量
    在这里插入图片描述
    I(X;Y)是平均每个码元的信息量,对于无扰信道有I(X;Y)=H(X);信道容量C是保证可靠通信下信道所能容纳的最大信息传输量,对于固定信道,信道容量是一个定值;若要达到信道容量,信源分布(信道输入概率)须满足一定条件.

    • 一维信道和N维信道的关系:在这里插入图片描述
      当信源和信道都离散无记忆时,等号成立,即N维序列传输问题可归结为单符号传输问题.
    • 几种特殊信道的信道容量及达到信道容量的充要条件:
      在这里插入图片描述
      对称信道/准对称信道/强对称信道:略.

    信道编码定理(香农第二定理)

    • 最大后验概率译码准则:错误概率最小等同于后验概率最大.
      即收到yi后在所有x中选择使后验概率q(x|y)(也称信道疑义度)最大的xi作为译码.
    • 极大似然译码准则:收到yi后在所有x中选择使转移概率q(y|x)最大的xi作为译码.
    • 信道编码定理:对任何离散无记忆信道DMC,当信道的信息传输率R<C,码长N足够长时,总可以找到译码规则使信道输出端的最小平均错误译码概率Pmin达到任意小(信道容量C是无差错传输时信息传输率R的极限值).
    • 信道编码逆定理:当R>C时不可能存在任何方法使差错率任意小(或说趋于零).

    率失真编码定理(香农第三定理)

    • 失真测度d(x,y):量化失真.
    • 平均失真:失真的数学期望.
    • 率失真函数:在这里插入图片描述
    • 率失真函数的性质
      值域:在这里插入图片描述
      定义域:在这里插入图片描述
      R(D)是连续,单调,减函数.
    • 率失真编码定理:给定允许失真D,当信息传输率R>R(D)时,只要信源序列足够长,总可以找到一种编码方法使平均失真趋近于D.
    展开全文
  • 图像编码的原因: 数据时信息传递的手段,相同的信息可以通过不同的数据量去表示,尝试用不同的表达方式以减少表示图像的数据量,对图像的压缩可以通过对图像的编码实现。 数据压缩 减少表示给定信息所需要的数据量...

    基础概念

    图像编码的原因:
    数据时信息传递的手段,相同的信息可以通过不同的数据量去表示,尝试用不同的表达方式以减少表示图像的数据量,对图像的压缩可以通过对图像的编码实现。
    在这里插入图片描述
    数据压缩
    减少表示给定信息所需要的数据量,包含不相关和重复信息的数据称之为冗余数据。数据压缩的目的就是消除冗余数据。

    压缩率和相对冗余度
    n1为压缩前的数据量(比特数),n2位压缩后的数据量
    在这里插入图片描述
    三种数据冗余类型

    编码冗余
    编码是用于表示信息实体和事件集合的符号系统(字母、数字、比特和类似的符号等)。
    码字:每个信息和事件(灰度值)被赋予一个编码符号的序列(0x00–0xFF)
    码长:码字中的符号数量(8)
    码本:构成码字的所有编码符号的集合(0和1)
    例:在多数二维灰度阵列中,用于表示灰度的8比特编码所包含的比特数要比表示该灰度所需要的比特数多。
    每个像素的平均比特数
    在这里插入图片描述
    其中rk为某一灰度值,pr(rk)为该灰度值出现的概率,l(rk)为该灰度值使用的码字的码长(即所用的比特数),根据上式可以得出Lavg(比特/像素)
    注:
    1.如果用较少的比特数表示出现概率较大的灰度级,用较多的比特数表示出现概率较小的灰度级,得到的平均比特数较小。
    2.如果平均比特数不能达到最小,就说明存在编码冗余。
    在这里插入图片描述
    空间和时间冗余
    空间:相邻像素是空间相关的,即信息重复了
    时间:相邻两帧中重复的信息

    心理视觉冗余
    图像中被人的视觉系统忽略的信息可以被当做是冗余信息去除

    信息论相关

    图像信息的度量
    信息论中,一个具有概率P(E)的随机时间E所包含的信息量I(E)为
    在这里插入图片描述
    对数的底决定了信息的单位,一般取2

    信源与熵
    信源:一幅图像可以看做一个具有随机离散输出的信源,信源可以从一个有限的符号集中产生一个随机符号序列。

    产生单符号的信源
    在这里插入图片描述
    信源输出的平均信息H(u)
    在这里插入图片描述
    H(u)称信源的熵,表示观察到单个信源符号(即bi直接构成信息)输出时所获得的平均信息量。
    注:
    1.图像中,熵表示图像灰度级的平均比特数(划重点)或图像信源的平均信息量
    2.当信源各个符号出现的概率相等时,信源的熵最大,信源此时提供最大的单个符号的平均信息量。

    产生块随机变量的信源
    产生的符号集是n个一组的符号
    在这里插入图片描述
    在这里插入图片描述
    对于这类信源的熵:
    在这里插入图片描述
    其熵对应单符号信源熵的n倍。

    香农第一定理
    确定了对零记忆信源的每个信源符号编码可达到的最小平均码字长度,即nH(u)
    编码效率:
    在这里插入图片描述

    图像压缩系统模型

    在这里插入图片描述
    编码器:
    映射器:对输入数据变换以减少像素的相关冗余(降低空间和时间冗余,例如游程编码)
    量化器:减少映射器输出的精度减少心理视觉冗余
    符号编码器:将短码赋给最频繁出现的量化器的输出以减少编码冗余

    解码器:
    符号解码器 反映射器
    量化器—不可逆,解码中没有量化器的逆操作,故量化器不可用在无失真编码中

    常用压缩算法

    1.哈夫曼编码

    基本原则:
    较少的比特数表示概率较大的灰度值,较多的比特数表示概率较小的灰度值
    编码过程:
    1.缩减信源符号数量(全8bit到各种小于8bit的编码)
    2.对每个信源符号赋值(信源符号由自己赋值,且每个信源符号各不相同(长度也是),故可以通过查表去解码)
    编码注意事项:
    从最后一步剩下的两个概率开始逐步向前进行编码。每步只需对两个分支各赋予一个二进制码,如对概率大的赋予码元0,对概率小的赋予码元1,记住在尾部添加!
    在这里插入图片描述
    哈夫曼编码特点:
    1.Huffman码在字长变长码中最佳,码长平均长度很接近于符号的熵值。
    2.满足即时性的编码(即读完一个码字就将其对应的信源符号(灰度值)确定)。
    3.解码具有唯一性。

    位平面编码

    位面:
    灰度图像的每个比特可看作表示了一个二值的平面。
    位面0:最低位面
    位面7:最高位面
    在这里插入图片描述
    直接位平面分解的缺点:
    像素微小变化可能会引起位平面复杂变化。
    在这里插入图片描述
    灰度码方法:
    在这里插入图片描述
    特点:上述计算后像素灰度微小变化不影响所有位平面。
    在这里插入图片描述
    注:
    1.低位面图比高位面图包含细节多,更随机。
    2.灰度码表达的位面图比对应的二值位面图复杂度更低,具有视觉意义信息的位面图数量更多。

    位平面编码
    游程编码:
    对1组从左到右扫描而得的连续的0或1游程用游程的长度编码,默认以0开始
    在这里插入图片描述
    在这里插入图片描述
    游程编码后再进行哈夫曼编码,却存在问题?
    1.如果不采用任何编码手段,则数据量为843=96bit
    2.采用了游程编码,得到42个像素点,后对这些像素点进行哈夫曼编码,计算得到平均码字长度为2.453,这样的话编码后的数据量达到了2.453*42=103bit
    为神马编码完了反而数据量增大了。。。

    预测编码

    基本思想:
    1.图像相邻像素存在很强的相关性,通过观察其相邻像素取值,可以预测一个像素的大概情况。
    2.预测值和实际值存在误差,称为预测误差。
    3.预测误差的方差必然比原图像像素的方差小,因此对预测误差进行编码必然压缩其平均码长。
    线性预测编码:
    在这里插入图片描述
    注:
    1.编码时对预测序列en进行编码,可以压缩数据量
    2.在en的头部加上10(即初值值),这样就可以不断迭代(10+0,10+0+2……)

    有损预测编码:
    和无损预测编码的差别:
    增加了量化器,将预测误差映射到有限个输出中。
    例:德尔塔调制
    在这里插入图片描述
    在这里插入图片描述
    步骤:
    1.存入初始条件
    在这里插入图片描述
    2.得到过去预测
    在这里插入图片描述
    3.计算预测误差
    在这里插入图片描述
    4.量化预测误差
    在这里插入图片描述
    5.计算预测值,然后跳回2
    在这里插入图片描述
    注:
    1.同样对量化后的预测误差进行编码,再在头部存入初始值,即可通过迭代得到解码器的输出。

    展开全文
  • LDPC编码原理

    千次阅读 2021-05-02 04:36:04
    线性规化算法(LP)是基于最优化理论提出的一种新的译码算法,主要思想是可以把 译码问题看作一整数优化问题,通过对约束条件的放缩,形成一简单的线性规化问题, 利用最优化理论的知识完成译码。这种译码算法...
  • 帧内编码时I帧主要的压缩编码方法,帧内编码的性能对视频整体编码结果具有重要影响 I帧在编码时只采用当前帧的图像内部数据,体积通常比B/P帧更大,对整体码率的影响很大 I帧在帧间编码中通常作为B/P帧的参考数据,...
  • 计算机网络:四类数据编码技术

    千次阅读 2020-12-07 17:10:11
    对数字数据的数字信号编码、数字数据的模拟信号编码:、模拟数据的数字信号编码、模拟数据在模拟信道上传输进行了相关的介绍!
  • 文章目录杂谈前言一、何为编码器二、编码器的分类1、增量式编码器2、绝对式编码器3、霍尔编码器三、带编码器的直流减速电机详解1、直流减速电机的概念2、如何运用编码器进行测速3、脉冲数转变成速度值方法4、程序...
  • 霍夫曼编码是一种不等长非前缀编码方式,于1951年由MIT的霍夫曼提出。 用于对一串数字/符号编码获取最短的结果,获取最大的压缩效率。...思考:对5编码没必要每数是同样的长度,只要五字符对应的五...
  • 霍夫曼编码及其MATLAB实现

    千次阅读 多人点赞 2022-01-05 10:35:25
    霍夫曼编码及其MATLAB实现
  • 编码器基础知识大扫盲

    千次阅读 2021-02-22 12:20:07
    如何测量旋转量和旋转速度? 在我们的日常生活中,周围有各种精密仪器和电子设备。 比如家用电器,工业机器人以及其他一些机器,这些设备的基本配置如下。 ...检测旋转的编码器称为旋转编码器,检
  • DNA编码

    千次阅读 2017-12-27 14:42:19
    虽然一万不想学这东西,但还是要先了解一些。书名《DNA编码序列的设计与优化》 第一章 DNA的计算 主要讲了DNA计算相关的内容。 首先说了DNA为什么出现,分子水平的研究成熟,数学上很多NP-hard问题传统计算机...
  • 有没有简单有效的方法快速提升团队的编码水平,人人都能写高质量优秀代码?本篇文章用实战案例告诉你。
  • 实验七-卷积编码的MATLAB实现

    千次阅读 热门讨论 2021-07-24 16:59:38
    主题是卷积编码,以(2,1,3)卷积码的实现和性能分析作为例子。
  • 、贝叶斯网络 原文:Bayesian networks 译者:飞龙 协议:CC BY-NC-SA 4.0 自豪地采用谷歌翻译 我们从表示的话题开始:我们如何选择概率分布来为世界的一些有趣方面建模? 建立一好的模型并不容易...
  • 打印机显示型号编码不可用

    千次阅读 2021-08-03 01:14:52
    如果条件具备的话.可更换打印机连接电缆,或者将打印机连接到另一台电脑上进行测试。完成上述几步骤的检查后,如果打印机还不能与主机相连,则应考虑打印机本身的硬件故障。 原因:打印机处于暂停打印状态 方法...
  • H.264视频编码基本知识

    千次阅读 2020-09-22 20:45:22
    从H.261视频编码建议,到 H.262/3、MPEG-1/2/4等都有一共同的不断追求的目标,即在尽可能低的码率(或存储容量)下获得尽可能好的图像质量。而且,随着市场对图像传输需求的增加,如何适应不同信道传输特性的问题...
  • 信源编码和信道编码

    千次阅读 2018-12-06 15:14:59
    但现代通信应用中常见的信源编码方式有:Huffman编码、算术编码、L-Z编码,这三种都是无损编码,另外还有一些有损的编码方式。信源编码的目标就是使信源减少冗余,更加有效、经济地传输,最常见的应用形式就是压缩。...
  • 旋转编码器工作原理

    万次阅读 多人点赞 2019-04-21 17:36:50
    一、旋转编码器的原理和特点: 旋转编码器是集光机电技术于一体的速度位移传感器。当旋转编码器轴带动光栅盘旋转时,经发光元件发出的光被光栅盘狭缝切割成断续光线,并被接收元件接收产生初始信号。该信号经后继...
  • 《H.264/AVC视频编解码技术详解》视频教程已经在“CSDN学院”上线,视频中详述了H.264的背景、标准协议和实现,并通过一实战工程的形式对H.264的标准进行解析和实现,欢迎观看! “纸上得来终觉浅,绝知此事要...
  • AV1编码标准-算法描述

    万次阅读 2020-10-15 22:35:22
    AV1编码标准 本文档介绍了相关编解码器中包含的编码工具的技术方面。本文档不是相关编解码器的规范。相反,它总结了针对新开发人员的编码工具的突出功能。 缩略语 CfL: Chroma from Luma IntraBC: Intra block ...
  • 编码器及其变形很多,本篇博客目前主要基于普通自编码器、欠完备自编码器、稀疏自编码器和去噪自编码器,会提供理论+实践(有的理论本人没有完全理解,就先没有写上,后更)。另外,关于收缩自编码器、变分自编码...
  • 哈夫曼树与哈夫曼编码(前缀编码)理解

    万次阅读 多人点赞 2017-11-21 14:30:11
    哈夫曼树又称最优二叉树,是带权路径长度(WPL)最短的树,可以构造最优编码,用于数据传输,数据压缩等方向 下面是二叉树和哈夫曼树二、概念 路径:树中一结点到另一结点之间的分支序列构成两结点间的路径 ...
  • 本文内容参考了Conditional VAE (Variational Auto Encoder) 条件付きVAE
  • JAVA编写一程序,可以接收用户从键盘输入任意汉字,然后输出该汉字对应的Unicode编码
  • 有时这两个条件不能同时满足,就需要B了。B(调节脉冲)应该和1的极性看成一组,保证极性交替正负。而第一个V的极性保持和上一个1的极性相同,不需要B的调节。 再举一个例子,就能更加清楚地明白了。 消息代码:1 0 ...
  • MPEG2视频编码简介

    千次阅读 2019-04-20 17:42:17
    MPEG-2视频编码简介 MPEG-2是一组用于视音频压缩编码及其数据流封装的国际标准。它定义了编解码技术及数据流的传输协议;制定了MPEG-2解码器之间的共同标准。编码是MPEG-2标准的核心内容之一,其涉及到MPEG-2视频流...
  • 、《信息与编码》考试复习笔记3----第三章无失真离散信源编码(重要) 五、《信息与编码》考试复习笔记3----第三章无失真离散信源编码补充例题 六、《信息与编码》考试复习笔记4----第章离散信道容量 七、《信息...
  • 图像处理总复习6、图像编码

    千次阅读 2021-08-07 08:32:22
    图像压缩编码 数据压缩与信息论基础 图像压缩与编码基本概念 信息论基础 • 图像压缩编码 无损压缩 有损压缩 • 更多图像编码方法 LZW编码 预测编码 为什么要进行图像压缩 图像数据压缩的可能性 数据冗余 图像压缩的...
  • 信源编码与信道编码

    千次阅读 2018-03-18 23:03:20
    一.信源编码和信道编码的发展历程...但现代通信应用中常见的信源编码方式有:Huffman编码、算术编码、L-Z编码,这三种都是无损编码,另外还有一些有损的编码方式。信源编码的目标就是使信源减少冗余,更加有效、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 244,996
精华内容 97,998
关键字:

影响编码的四个条件