Research on fractal image compression hybrid algorithm based on convolutional neural network and gene expression programming

Abstract

Regarding the problems of insufficient image segmentation intelligence, low compression rate, slow speed for global searching to find the optimal fractal image compression encoding, and bad decoding effect, this article proposes the fractal image compression hybrid algorithm based on convolutional neural network and gene expression programming. Firstly, according to the accurate and fast image classification of deep convolutional neural network and the fast search and matching encoding advantages of gene expression programming, it realizes theoretically the action mechanism of fractal image compression hybrid encoding by combining the convolutional neural network and the gene expression programming; then, it uses the deep convolutional neural network to train and classify the image, and uses the adaptive quadtree segmentation method to segment the classified image, thus generating the domain block and range block classification set. According to the action mechanism of gene expression programming in fractal image compression encoding, it then quickly obtains the optimal solution of fractal image compression encoding by searching and encoding the sub-blocks of range block classification set and the classification set corresponding to the domain. Finally, in the CPU/GPU environment, it conducts the comparative experiment with basic fractal image compression algorithm and fractal image compression algorithm based on convolutional neural network. The experimental results show that this proposed algorithm outperforms similar algorithms in terms of image segmentation speed and accuracy as well as fractal compression encoding speed and compression ratio. Therefore, this algorithm is a fractal image compression algorithm with intelligent segmentation, fast encoding and high compression ratio.

Keywords

Fractal image convolutional neural network gene expression programming intelligent segmentation hybrid compression CPU/GPU

Introduction

Fractal image compression is an encoding method completely different from traditional compression technology. Barnsley¹ performs the fractal compression encoding on several specific images and obtains a high compression ratio of 10,000:1. Although its encoding process requires the manual participation, it also shows the great potential of fractal technology in image compression encoding. The existing fractal image compression encoding has the problems of being lack of optimization in segmentation method, long calculation time of fractal compression encoding, and large error in encoding and decoding control. To solve these problems, it requires the strong computing power, intelligent segmentation technology and fast search optimization methods. With the advent of CPU/GPU high-performance computing platforms, its powerful graphics processing capabilities and parallel computing capabilities have made it become a new tool in engineering fields such as image processing. The parallel computing model based on the new platform of CPU/GPU (graphic processing unit), multi-thread, multi-process, and thread hybrid programming method and its application in various fields have become the current research hotspots. The artificial intelligence based on deep learning has made great achievements in recent years, and the Alpha-dog upgraded version Master has consistently defeated 50 top professional GO players in the world, and it has also shown great power in the fields of face and voice recognition, thus all governments greatly increase the input in artificial intelligence, and the deep learning and its application have become the research hotspots. Gene expression programming has its unique advantages in optimization accuracy and convergence speed, and is widely used in image processing and pattern recognition, automatic control, artificial life, machine learning and other fields. Therefore, this paper combines the deep-learning neural network and gene expression programming optimization method on CPU/GPU parallel platform to study the intelligent segmentation and compression hybrid encoding algorithm of fractal image, which has important scientific significance and application value.

Related work

At present, the image compression standard mainly uses the discrete cosine transform (DCT), wavelet transform (DWT) and other technologies, these technologies are mature, but their compression ratio is not high. Fractal image compression technology is a completely different encoding method from traditional compression technology, and it is mainly realized by fractal self-similarity and iterated function system (IFS). For the first time, Barnsley applied the IFS theory to image compression encoding, which achieved a very high compression ratio, but the encoding process required the manual participation. Jacquin² proposed a partitioned iterated function system (PIFS) scheme, in which the encoding process can be carried out automatically, but its algorithm operation is huge, resulting in too long encoding time, thus limiting its practicability.³ Since then, people have proposed various improvement plans for image segmentation, image matching search and encoding, and calculation speed increasing in the fractal compression process.

Fractal image segmentation

Traditional image segmentation methods mainly include threshold method, boundary detection method and regional method. While, the fractal image segmentation mostly uses the block-shaped region segmentation methods such as squares, rectangles, and triangles. For example, Kang et al.⁴ divided the domain block and the range block into the squares, and divided all blocks of the image into 72 classes according to the average brightness of the pixels and the corresponding variance of the brightness; Chen et al.⁵ divided the image into 360 classes by rectangular blocks; Sun et al.⁶ divided it into 72 classes according to the triangle block; Yi⁷ proposed an adaptive quadtree partitioning method, which is divided by layers, but its essence is also the square partitioning. Such methods of segmentation by different blocks and performing the matching search among the same class can improve the compression speed. However, it is not conducive to global optimization, and the compression ratio and accuracy of the image will be decreased exponentially. In recent years, the graph-based and cluster-based interactive super pixel segmentation method⁴ has emerged, and its representative algorithms include that: Boykov proposed the Graph Cuts algorithm of the image, and Mustafa et al. proposed the multi-scale segmentation wide-band scene reconstruction feature detection algorithm.^8,9 This kind of algorithm has the group pixels with similar features, so that the image block contains the image content information that is not possessed by a single pixel, which improves the accuracy of segmentation; however, the semi-automatic interaction method is time-consuming and laborious, which affects the efficiency of the algorithm. At present, the image segmentation mainly adopts the semi-automatic interaction mode, while the automatic block segmentation effect is not ideal. Image segmentation is a key step in image processing (including fractal compression encoding); however, there is no fast automatic segmentation method or general theory for image segmentation. With the introduction of new deep learning artificial intelligence technology and gene expression programming optimization method, it provides a good theoretical and technical basis for the establishment of image intelligent segmentation theory and method. To this end, we use the convolutional neural network (CNN) deep learning to study the image segmentation and construct an image intelligent segmentation method.

Fractal image encoding

In order to improve the encoding quality of fractal images and reduce the search time and range, people conduct the hybrid encoding of discrete transform, genetic algorithm and other methods with fractal images. (1) Commonly used method includes the hybrid encoding of DCT and wavelet transform (WT) with fractal images. They concentrate the image information mainly into the low frequency part of frequency domain through the conversion from time domain to frequency domain, which reduces the encoding range and improves the encoding efficiency and quality. For example, Wang et al.¹⁰ proposed a DCT domain fractal image compression encoding method, which maps the images to the DCT domain for encoding; Karthikeyan et al.¹¹ proposed a fractal image compression method based on wavelet analysis. Soyjaudah and Jahmeerbacus¹² proposed a wavelet domain fractal image compression algorithm based on quadtree. Their purpose is to map all the images to the wavelet domain, and then perform the block segmentation on the wavelet domain, thus reducing the search amount and range, which can obtain a better compression ratio. However, the cosine and wavelet transformations do not make full use of the similarity between sub-bands in the wavelet domain, and the compression ratio of hybrid image encoding is discounted. (2) Another hybrid encoding method is to combine the optimization methods such as genetic algorithm, ant colony algorithm and gene expression programming with fractal images, and use the optimizing precision of optimization algorithm to automatically classify, thus realizing the matching search within the class, improving the encoding speed, and reducing the blocking effect. For example, Soyjaudah et al.¹² proposed a fractal image compression method based on genetic algorithm by using the fractal image compression of self-organizing map¹³; Zhao Deping¹⁴ proposed a fast fractal image compression method based on ant colony algorithm; Menassel et al.¹⁵ proposed an improved fractal image compression using wolf pack algorithm, which divides the image space into blocks, and the sliding wolf explores in this space to find other similar smaller blocks. They construct an optimization algorithm for classification search matching, which effectively overcomes the shortcomings of block-based search method to a certain extent and improves the compression ratio and fidelity.^16,17 Li et al.¹⁸ applied the gene expression programming to fractal image compression encoding and achieved a better compression ratio. In addition, there are many applications such as niche, BFGS and other optimization algorithms and strategies for hybrid encoding of fractal images.^19,20 (3) Fractal hybrid encoding improves the encoding speed and the solving accuracy to a certain extent, and the blocking effect produced by decoding is improved. However, the fractal dimension, affine transformation and its parameters of fractal compression are still the key factors of fractal image compression. Chamorro-Posada²¹ proposed the compression fractal dimension to achieve high compression ratio by improving the search accuracy; Omari et al.²² proposed a new image compression mechanism, which constructs a compression map by using the relationship between rational numbers and corresponding quotients and achieves a high compression ratio while maintaining the image quality. Swalpa proposed a new method for calculating the fractal encoding affine parameters to reduce the computational complexity of fractal encoding. (4) The huge computation amount of fractal image encoding still limits the encoding speed and time.^23,24 To this end, people have proposed the parallel algorithm for fractal image compression on a variety of parallel platforms, which greatly improves the compression encoding speed and reduces the encoding time. For example, Wang and Zheng²⁵ proposed a distributed parallel fractal image compression algorithm in the cluster environment; Li et al.²⁶ proposed the adaptive image fractal compression parallel algorithm based on relative gradient; in multi-core PC platform, Li et al.²⁷ proposed the GEP-based parallel algorithm for fractal image compression. In addition, other scholars have proposed many different parallel algorithms for fractal image encoding.^28,29 Although the parallel encoding of fractal images in parallel platforms such as multi-core PC and clusters can reduce the encoding time, it still does not meet the actual needs of people. The emergence of CPU/GPU systems has provided us with an opportunity to solve this problem.

Gene expression programming

GEP is a new evolutionary computation algorithm first proposed by Portuguese scholar Candida³⁰ in 2001, and it is a new member of genetic algorithm family. It has strong function discovery ability and high efficiency, and does not need any prior knowledge during function discovery, with no need to pre-store the type of function model, thus avoiding the blindness of pre-selecting the function types in traditional algorithm modeling. After Candida Ferreira proposed the GEP algorithm, it has attracted the research of many scholars from the whole world. Among them, Xu et al. ³¹ used the GEP algorithm to study the classification rules, and Zhu et al.³² applied GEP to one-dimensional chaotic mapping. In China, the research team led by Professor Tang Changjie at Sichuan University and the research team of Professor Yuan Changan at Guangxi Normal University have proposed many more efficient and more adaptable algorithms for different applications.³³ Jedrzejowicz and Wierzbowska³⁴ proposed the gene expression programming in large data set classification parallel environment. Li et al.²⁷ applied GEP to the application research of fractal image compression, and used GEP's efficient search ability to quickly search the self-similarity of fractal images, which achieved good results. GEP combines the advantages of both genetic algorithms and genetic programming, and is two to four orders of magnitude more efficient than traditional genetic programming methods when solving the complex problems. It will be widely used in function optimization, combinatorial optimization, image processing and pattern recognition, artificial life, genetic programming, automatic control, machine learning, and production scheduling problems. To this end, we integrate GEP and deep CNNs on the CPU/GPU parallel platform to deeply study the fractal image compression encoding, so as to build a new automatic fast parallel algorithm with high compression ratio.

Deep learning

In 2006, Hinton and Osinde Rosthe at University of Toronto proposed the concept of deep learning, which opens the prelude to the development of deep learning. As a typical algorithm for traditional training of multi-layer networks, BP algorithm actually contains only a few layers of networks, and its training method is not ideal. Hinton and Osinde Rosthe³⁵ proposed the unsupervised greedy layer-by-layer training algorithm based on deep belief networks (DBNs), which brings hope to solving the optimization problem related to deep structure. The CNN proposed by Lecun et al.³⁶ is the first real multi-layer structure learning algorithm, which uses the spatial relative relations to reduce the number of parameters, thus improving the BP training performance. Since then, there have been many deformation structures in deep learning, such as denoising auto encoder, DCN, sum product, etc.^37,38 BalléLaparra and Simoncelli³⁹ at New York University proposed the end-to-end optimized image compression (EEOIC), and this optimization method has better compression ratio than standard jpeg and jpeg 2000 compression methods; in addition, many scholars have combined the CNNs with fractal image compression and have also achieved some research results.^40–43

In summary, various improved algorithms and hybrid algorithms for fractal image compression encoding being proposed mostly use the fixed, simple automatic or semi-automatic image segmentation methods, resulting in too long encoding time and poor decoding image quality, and they are all facing the PC or PC cluster platform, with low encoding and decoding speed and compression efficiency. Therefore, on the CPU/GPU high-performance parallel platform, we use the fast and accurate image classification characteristics of deep CNNs to study the intelligent segmentation method of fractal images, so as to realize the intelligentization of image segmentation. In fractal image encoding, by using the advantage of high optimizing precision and fast convergence of gene expression programming, we apply it to the solution of all transform parameters of fractal image compression encoding IFS, thus improving the solving speed and accuracy.

Basic ideas of CNN and GEP fusion encoding

On the CPU/GPU platform, the fractal image compression encoding based on deep CNN and gene expression programming uses a two-stage processing method: the first is the fractal image segmentation of deep CNNs; the second is that the gene expression programming performs the quick searching and encoding on the range block classification set and the domain block classification set, and finds the optimal solution of fractal image compression IFS.

Fractal image segmentation of deep CNN based on CPU/GPU

Commonly used deep learning models include Restricted Boltzmann Machines (RBMs), AutoEncoders (AE), CNNs, and DBNs. DBN is an algorithm based on RBM and AE, which is a stack of multi-layered unsupervised RBM and a supervised BP network. The greedy learning weight matrix of each layer needs a longer training time; CNN is a supervised learning algorithm with shared convolution kernel, and it can extract the required features by convolution and better handle 2D and high dimensional data, such as 2D/3D image classification. However, when the CNN network level is too deep, using the BP propagation to modify the parameters will make the parameters near the input layer change slowly. Therefore, the algorithm of this paper selects the CNN algorithm with five convolution layers and five maximum pooling layers for image classification.

Image classification principle of CNNs

The deep CNN consists of multiple convolution layers, pooling layers, fully connected layers and upsampling layers, and its image classification process includes the forward network calculation and the reverse error propagation. This algorithm uses the deep CNN consisting of five convolution layers, five maximum pooling layers, one fully connected layer and one upsampling layer.

Forward network calculation

Assuming that the size of the image B is h_b × w_b and the size of convolution kernel K is h_k × w_k (where h_b ≥ h_k, w_b ≥ w_k), then the size of convolution map matrix G = B ⊕ K is (h_b − h_k + 1) × (w_b − w_k + 1).

The calculation of its each layer is as follows

Network calculation of the jth(j = 1, 3, 5, 7, 9) convolution layer. G₁ layer: Input n × n image data matrix B, then conduct the convolution with h narrow convolution kernels $K_{i}^{1} (i = 1, 2, \dots, h)$ of size n₁ × n₁ to generate h1 feature maps of n₂ × n₂ size. G₂ layer: Conduct the convolution again, and all h1 pooling maps in P₂ go through h3 n₁ × n₁ convolution kernels $K_{i}^{3} (i = 1, 2, \dots, h)$ to generate h3 feature maps. The calculation formula for the jth layer is

{\begin{cases} G_{i}^{j} = cov 2 (B, K_{i}^{j},' valid') + b_{i}^{j} \\ v_{i}^{j} = G_{i}^{j} \\ c_{i}^{j} = f (v_{i}^{j}) \end{cases}

(1)

where

G_{i}^{j}

is the convolution result of the jth layer after the activation function,

c_{i}^{j}

is the graph element of convolution layer or pooling layer, which is the input of the next layer, valid indicates the narrow convolution, and f(*) is the activation function, and

b_{i}^{j}

is the bias.

Network calculation of the kth (k = 2, 4, 6, 8) pooling layer. P₂ layer: Perform the pooling operation after the convolution, the size of pooling window is r × r, each n₂ × n₂ feature map generates a pooling map of n₂/₂ × n₂/₂, and a total of h1 pooling maps are generated. P₄ layer: Perform the pooling operation again, the size of pooling window is r × r, each n₄ × n₄ feature map generates a pooling map of n₄/₂ × n₄/₂, and a total of h3 pooling maps are generated. The forward calculation formula of pooling layer is

{\begin{cases} P_{i}^{k} = η_{i} down (c_{i}^{j}) + b_{i}^{k} \\ v_{i}^{k} = P_{i}^{k} \\ c_{i}^{k} = f (v_{i}^{k}) \end{cases}

(2)

where

P_{i}^{k}

is the pooling layer result of the kth layer, and other parameters are the same as the convolution layer.

Calculation of fully connected layer. Expand $c^{10}$ （i = 1, 2, … , h9）into a one-dimensional vector in order, with the ordered connection as the input of fully connected layer, then calculate the output according to the back-propagation neural network BP algorithm formula.

{\begin{cases} z_{i}^{10} = ω \times c^{10} + b_{i}^{10} \\ v_{i}^{10} = z_{i}^{10} \\ c_{i}^{10} = f (v_{i}^{10}) \end{cases}

(3)

Reverse error propagation

4. Loss function. Find the best weight (w) and the bias (b) to minimize the value of loss function, thus the loss function J is a function about w and b, where w and b are the set of all weights and deviations in the network. Therefore, assuming that the loss function of the network is

{\begin{cases} J (ω, b) = \frac{1}{m} J (ω, b; x^{(i)}, y^{(i)}) \\ J (ω, b; x^{(i)}, y^{(i)}) = \frac{1}{2} {(y^{(i)} - h_{ω, b} (x^{(i)}))}^{2} \end{cases}

(4)

where x⁽ⁱ⁾, y⁽ⁱ⁾ are the input and sample output respectively. h(x) is the network's calculation result on x.

5. Weight correction of fully-connected layer. The reverse derivation of the fully-connected layer of CNN is consistent with the reverse derivation of BP neural network.

\begin{array}{l} δ^{(5)} = \frac{\partial J}{\partial z^{5}} = \frac{\partial}{\partial z} {(y - h (x))}^{2} \\ = \frac{\partial}{\partial z^{5}} {(y - f (z^{5}))}^{2} = (y - f (z^{5})) f^{'} (z^{5}) \end{array}

(5)

where δ is the residual, which is equal to the product of the difference between the output and the sample output of network calculation with the derivative of activation function.

6. Weight correction of convolution layer. The convolution layer is obtained by calculating the network weight through the intermediate convolution kernel. The correction of the weight is based on the error of convolution layer, uses the ReLU excitation function, and is modified according to the weight correction formula of reverse neural network. Therefore, the weight and bias (threshold) correction formula is

{\begin{cases} ω^{(l)} = ω^{(l)} - α \frac{\partial J}{\partial ω^{(l)}} \\ b^{(l)} = b^{(l)} - α \frac{\partial J}{\partial b^{(l)}} \end{cases}

(6)

Segmentation of fractal image range set and domain set

In the CPU/GPU parallel system, after the convolution, pooling, full connection, and upsampling operations of CNN, the image is classified and restored to the same size as the original image. On this basis, the classified images are segmented into non-overlapping range block sets and overlapping domain block sets, and the parallel adaptive quadtree segmentation method is used for segmentation.

The main thread divides the classified image into four equal non-overlapping sub-blocks, and one sub-block is reserved by itself, and the other three sub-blocks are distributed to other slave threads for processing; the main thread divides the reserved sub-block into four grand-subblocks of equal size, one is reserved, and the other three grand-subblocks are distributed again to other slave threads. Similarly, the other three sub-blocks are also divided into four equal parts by their respective slave threads, and one grand-subblock is reserved by itself, and the other three parts are distributed to other slave threads; until the size of sub-block being divided by each thread satisfies the conditions. Image segmentation generates a categorical range block pool;

Similarly, the main thread divides the classified image into four equal non-overlapping sub-blocks, and one sub-block is reserved by itself, and the other three sub-blocks are distributed to other slave threads for processing; the main thread again divides the reserved sub-block into four grand-subblocks of equal size, one is reserved, and the other three grand-subblocks are distributed again to other slave threads. Similarly, the other three sub-blocks are also divided into four equal parts by their respective slave threads, and one grand-subblock is reserved by itself, and the other three parts are distributed to other slave threads; until the size of sub-block being divided by each thread satisfies the conditions. Image segmentation generates a categorical domain block pool.

Fractal image classification and segmentation algorithm for CNNs

Image segmentation is a key step in fractal image compression; however, all existing image segmentation methods have the problems of insufficient automation and intelligence and low image recovery accuracy. To this end, we classify the fractal image through a five-layer CNN in CPU/GPU parallel system environment, and use the adaptive quadtree to automatically segment the classification results. The image classification is processed in parallel by CNN, and it creates multiple threads through the multi-core CPU, and each thread is responsible for transmitting the image convolution processing data to the GPU, and performing the scheduling and data receiving of GPU array processor, respectively. The original image is classified in parallel by CNN on the GPU and its processing includes five convolution layers, five maximum pooling layers, one fully connected layer and one upsampling layer. With the automatic segmentation of image range block and domain block, the classified images are divided into the non-overlapping range block and the overlapping domain block by CPU multi-threading through the adaptive quadtree, thus achieving the parallel segmentation of fractal images. The flow chart of its classification and segmentation algorithm is shown in Figure 1.

Figure 1.

Automatic segmentation flow chart of fractal image convolutional neural network.

As shown in Figure 1, the GPU module is the convolution process, including G1, G2, G3, G_4, G₅ convolution layers and P1, P2, P3, P₄, P₅ pooling layers, 1 fully connected layer, and 1 upsampling layer. The convolution layers G1, G2, G3, G₄, and G₅ are calculated according to the parameters given in formula (1) and the module; the P1, P2, P3, P₄, and P₅ pooling layers are calculated according to the parameters given in formula (2) and the module, and the fully connected layer is calculated according to the parameters given in Formula (3) and the module; the BP reverse error calculation as well as the weight and the convolution weight correction of fully connected layer are calculated according to formulas (4) to (6) respectively. UpSampling restores the feature map of full convolution layer (FullConv) back to the original image.

Fractal image compression based on gene expression programming

Basic principle of fractal compression

Definition 1. Set w as the affine transformation of $R^{n} \to R^{n}$ : for any $x = {(x_{1}, x_{2}, \dots, x_{n})}^{T} \in R^{n}$ , there is

ω (x) = Ax + t

(7)

where

A = (a_{i j})

is n × n non-singular matrix,

t = {(t_{1}, t_{2}, \dots, t_{n})}^{T} \in R^{n}

is the constant vector.

If the norm $∥ A ∥ < 1$ , then the affine transformation ω defined by equation (1) is a compression transformation.

A grayscale image has the two-dimensional array of grayscale, i.e. z = f(x,y), where (x, y) is the spatial position and z is the grayscale value at the corresponding location. In order to adapt to the processing of grayscale images, the two-dimensional affine transformation is extended to three-dimensional affine transformation. Three-dimensional affine transformation for grayscale images ω: $R^{3} \to R^{3}$ is expressed as follows

ω_{i j} (\begin{array}{l} x^{'} \\ y^{'} \\ z^{'} \end{array}) = [\begin{matrix} a_{i j} & b_{i j} & 0 \\ c_{i j} & d_{i j} & 0 \\ 0 & 0 & s_{i j} \end{matrix}] (\begin{matrix} x \\ y \\ z \end{matrix}) + (\begin{matrix} e_{i j} \\ f_{i j} \\ o_{i j} \end{matrix})

(8)

This affine transformation can then be viewed as the combination of the 2D affine transformation on the (x, y) plane and the grayscale transformation in the Z direction. Where s_i controls the contrast of grayscale, and o_ij controls the offset of grayscale. Because the sub-block set in range block classification pool is in the same class with the sub-graph of corresponding sub-block set in domain block classification pool after the classification by the above CNN, and it has self-similarity. The grayscale compression factor s_ij and the grayscale offset factor o_ij will not be considered in the matching search. The definition and collage theorem of IFS are described in Jedrzejowicz and Wierzbowska.³⁴

Action mechanism of GEP in fractal image compression

Gene expression programming, like genetic programming, is developed based on genetic algorithms. However, it uses a new individual description method different from genetic algorithm, and its formal description requires two kinds of symbols: terminators and functions. The formal definition of GEP is as follows:

Definition 2. The gene expression programming environment is a binary group, which is written as

GEP = 〈 F, T 〉

where F is the set of functions and T is the set of terminators. For example: F = {+, −, *, /}, T = {a, b, c, d}.

The chromosomes of gene expression programming are composed of K-expressions.³⁴ The definition, gene head, tail and GEP basic algorithm of K-expression are described inJedrzejowicz and Wierzbowska.³⁴

Approximation solution mechanism of GEP

The mechanism of GEP approximation to find the optimal solution is: assuming that A is a color or grayscale image, according to the self-similarity and collage theorem of fractal image and the powerful evolutionary search ability of GEP algorithm, the true value solution of original image is quickly approached in the space R³. However, in the approaching process, the following three problems must be solved.

First, the encoding representation of GEP gene and chromosome; second, the fractal compression fitness function shall be designed to select the good individuals and accelerate the evolution of the system and the solving of the problem; third, a finite number of individuals (chromosomes) are randomly generated to quickly approach the true value solution of original binary image after nine genetic evolution operations, such as individual selection, mutation, reversal, interpolation, root interpolation, gene transformation, single-point recombination, two-point recombination and gene recombination.

Encoding of genes and individuals (chromosomes)

Gene encoding

As known from formula (2), there is a set of finite compression transforms ω_ij that make up an IFS F_i = [ω_i₁, ω_i₂, ω_i₃, … , ω_in]. The ω_ij compression transform is mapped to the jth gene of the ith chromosome of GEP, F_i represents the ith IFS (chromosome), and several IFSs F_ij form a population (i, j = 1, 2, … , n). The function set of the gene is F = {+, −, *, A}; the set of variables is T = {a_ij, b_ij, c_ij, d_ij, e_ij, f_ij, x_ij, y_ij | a_ij, b_ij,c_ij, d_ij, e_ij, and f_ij satisfies the condition of formula (2), x ∈ [0, 640], y ∈ [0, 480]}. Assuming that the gene has a head length of h = 9, n = 2, and the tail length t = 10, then the total length of the gene is 19 bits. Each gene can be expressed as the following K-expression

{\begin{cases} 0123456789012345678 \\ {A+++e+f}^{****} axbycxdy \end{cases}

(9)

where A represents the logic and operation, the first line of K-expression represents the sequential position of gene string, and the second line represents the function or variable symbol of gene linear string.

Several IFSs form a population

Then the encoding of an IFS (chromosome) is

F_{i} = [ω_{i}_{1}, ω_{i}_{2}, ω_{i}_{3}, \dots, ω_{in}]

(10)

where F_i represents the ith IFS (chromosome) in the population, and n represents the number of genes contained in this IFS (chromosome). For example, if the IFS (chromosome) consists of three genes, the chromosome length is 57, and its K-expression is as follows

\begin{array}{l} 01234567890123456780123456789 \\ 0123456780123456789012345678 \\ A + - + e + f^{* * * *} axbycxdyA - + e \\ + f^{*} -^{*} - axbycxdyA - + + e + f^{*} - +^{*} axbycxdy \end{array}

Fractal compression fitness function design

The fitness of the IFS of GEP image fractal compression is mainly shown in: the similarity between the decoded image and the original image, the small compression factor, and the small number of compressed affine transformations.

The fitness function is defined as follows

fitness (B, ω, λ, ξ) = s (B, ω) c (λ) L (ξ)

(11)

where s(B, ω)represents the similarity of the image, shown by formula (12); c(λ) represents the compression factor, shown by formula (13); L(ξ) represents the factors of compressed affine transformation number, shown by formula (14). The parameter B is the image, ω is the affine transformation, λ is the compression factor, and ξ is the number of desired compression affine transformations, and the meaning of the parameters and formulas is given in Hinton and Osinde Rosthe.³⁵

The cross similarity metric formula is as follows

s (B, \cup_{i = 1}^{n} ω_{i} (B)) = \frac{| B \cap (\cup_{i = 1}^{n} ω_{i} (B)) |}{| B \cup (\cup_{i = 1}^{n} ω_{i} (B)) |}

(12)

The compression function c(λ) is defined as follows

c (λ) = (1 - λ^{10}) e^{- \frac{λ^{2}}{4 η^{2}}}

(13)

The affine transformation number L(ξ) function is defined as follows

L (ξ) = e^{- \frac{μ^{2}}{4 ξ^{2}}}

(14)

Genetic operation of GEP

GEP adopts the linear isometric encoding, and the genetic operation process satisfies the principle of “the length of the gene keeps unchanged and only the terminator can appear in the tail,” and the genes of the progeny chromosomes produced by the inheritance are still legal. Its genetic basic operators include nine genetic evolution operations such as selection, mutation, reversal, interpolation, root interpolation, gene transformation, single-point recombination, two-point recombination and gene recombination. Due to limited space, they are not described here, please refer to Hinton and Osinde Rosthe.³⁵

Hybrid algorithm of deep CNN and gene expression programming

According to the design idea of ‘Image classification principle of CNNs’ section, through the fractal image parallel segmentation of deep CNN and the fractal image compression encoding of gene expression programming, the fractal image compression hybrid algorithm based on deep CNN and gene expression programming is obtained, and its steps are as follows:

Input: Read the original image data; initial parameters of convolution training; initial parameters of gene expression programming such as population size, gene head and tail length, number of genes, maximum iteration number, termination iteration fitness value, mutation rate, interpolation rate, and recombination rate.

Output: Output the optimal coded IFS.

Begin:

Step 1: Create multiple (set k = 2, 4, 8, 16…) threads from the multi-core CPU, one of which is the main thread and the other is the slave thread.

Step 2: Read the original image data, and send the image data to the corresponding array computing core of the GPU by multiple threads.

Step 3: Call the CNN fractal image classification and segmentation algorithm. The image classification is processed in parallel by CNN, which creates multiple threads through the multi-core CPU, and the multiple threads are responsible for transmitting the image convolution processing data to the GPU, and respectively performing the scheduling and data receiving on GPU array processor. The CNN is used to classify the original image in parallel in GPU, and its processing includes five convolution layers, five maximum pooling layers, one fully connected layer and one upsampling layer, and finally the Soft-max layer obtains the classification result, wherein there is one ReLU activation function layer behind each convolution layer, and the pooling layer adopts the maximum pooling.

Step 4: The main thread divides the classified image B of the size $2^{N} \times 2^{N}$ into four equal non-overlapping sub-blocks $2^{N - 2} \times 2^{N - 2}$ , and one sub-block is reserved by itself, and the other three sub-blocks are distributed to other slave threads for processing; the main thread again divides the reserved sub-block $2^{N - 2} \times 2^{N - 2}$ into four grand-subblocks $2^{N - 4} \times 2^{N - 4}$ of equal size, one part is reserved by itself, and the other three grand-subblocks are distributed again to other slave threads. Similarly, the other three sub-blocks are also divided into four equal parts by their respective slave threads, and one grand-subblock is reserved by itself, and the other three parts are distributed to other slave threads until each thread can divide the sub-blocks $^{R_{i}}$ (i = 1, 2, … , $2^{N - R} \times 2^{N - R}$ ) of size $2^{R} \times 2^{R}$ , then these sub-blocks are all sent back to the main thread for unified storage, and a range block pool is established.

Step 5: The main thread divides the classified image B of the size $2^{N} \times 2^{N}$ into four equal overlapping sub-blocks $2^{N - 2} \times 2^{N - 2}$ , and one sub-block is reserved by itself, and the other three sub-blocks are distributed to other slave threads for processing; the main thread again divides the reserved sub-block $2^{N - 2} \times 2^{N - 2}$ into four grand-subblocks $2^{N - 4} \times 2^{N - 4}$ of equal size, one part is reserved by itself, and the other three grand-subblocks are distributed again to other slave threads. Similarly, the other three sub-blocks are also divided into four equal parts by their respective slave threads, and one grand-subblock is reserved by itself, and the other three parts are distributed to other slave threads until each thread can divide the parent-blocks $D_{i} (i = 1, 2, \dots, 2^{N - D} \times 2^{N - D})$ of size $2^{D} \times 2^{D}$ , then, these sub-blocks are all sent back to the main thread for unified storage, and a domain block pool is established.

Step 6: Initialize the population. In the main thread, input the initial parameters such as population size, gene head and tail length, number of genes, maximum iteration number (maxg), termination iteration fitness value (minf), mutation rate, interpolation rate, recombination rate, and distribute them to each slave thread.

Step 7: Adopt the dynamic task allocation–work pool parallel search and encoding method. The main thread is responsible for the task management and allocation of range block classification pool. First, the complete ith (i = 1, 2… , m) class range sub-block set is sent to the kth (k = 1, 2, … , p) slave thread according to the classification order. If the distribution cannot be fully completed in one time, the remaining range sub-block sets (p + 1, … , m) are allocated as required by slave thread.

Step 8: After the kth (k = 1, 2, … , p) slave thread receives the first range sub-block set, the sub-blocks are grouped together and the sub-block diagrams R_ij(i = 1, 2… , m;j = 1, 2… , g) are taken out one by one for encoding with the corresponding domain sub-block set D_ij(i = 1, 2… , n; j = 1, 2… , q) in domain block classification pool.

Step 9: In the encoding process, each thread calculates the fitness value according to formulas (11) to (14).

Step 10: The kth (k = 1, 2… , p) slave thread sends nine basic operators of gene expression programming used in the programming process (including selection, mutation, reversal, interpolation, root interpolation, gene transformation, single-point recombination, two-point recombination, and gene recombination) and the calculation of individual fitness values to the k*10 kernels of GPU for parallel computations:

{

U _k ₁ nuclear calculation: selection operation;

U _k ₂ nuclear calculation: mutation operation;

U _k ₃ nuclear calculation: reversal operation;

U _k ₄ nuclear calculation: interpolation operation;

U _k ₅ nuclear calculation: root interpolation operation;

U _k ₆ nuclear calculation: gene transformation;

U _k ₇ nuclear calculation: single-point recombination;

U _k ₈ nuclear calculation: two-point recombination;

U _k ₉ nuclear calculation: gene recombination;

U _k ₁₀ nuclear calculation: calculation of individual fitness values;

} while (fitness<=minf or gen<maxg)

Step 11: k(k = 1, 2… , p) slave threads will complete the encoding of a range block R_ij, and obtain the parameters of classification sub-block sets such as the transform parameters, the domain block D_i and the compression transform ω_ij corresponding to the range block R_ij, which are then sent back to the main thread. The main threads form them into the complete and optimal coded IFS according to the original image classification order.

Step 12: The main thread outputs the optimal coded IFS.

Experimental results and analysis

Experimental environment and parameter settings

The hardware environment is: Intel DBS2600CW2 server board, dual XEON W3520 processor, GeForce RTX 2080 8 G memory card, 128GB memory, 80GB SSD and Gigabit Ethernet card. The software is: Windows 7, matlabR2014a, VS2013, CUDA 7.0, and Open CV 3.1.

The experiment uses the Camvid image set for training. Wherein, there are 2169 training sets, 406 evaluation sets and 861 test sets. According to the characteristics of image set, the original 32 classification is roughly divided into 13 categories, namely the cars, roads, trees, pedestrians, sky, bicycles, children, baby carriages, traffic lights, houses, street lamps, sidewalks, and billboards. Since the number of classifications is reduced, the loss weights of different categories integrate the number of each classification according to the training data set, and the weight w_i corresponding to the ith classification is equal to the pixel number n_i/total pixels in this classification, and the loss weight of each classification is as shown in Table 1.

Initial parameters of convolution training. Including setting the mini-batches size as 256, the initial learning rate is 0.01, and the learning rate is divided by 10 for every 10,000 iterations. The method used for weight initialization is the Gaussian distribution with a mean of 0 and a variance of 0.01, and the maximum number of iterations is set at 50,000. Wherein, the parameters of convolution layer 1 are size = 3, pad = 1, stride = 1, and num = 64; the parameters of convolution layer 2 are size = 3, pad = 1, stride = 1, and num = 128; the parameters of convolution layer 3 are size = 3, pad = 1, stride = 1, and num = 256; the parameters of convolution layer 4 and convolution layer 5 are both size = 3, pad = 1, stride = 1, and num = 512; the parameters of pooling layer 1 to pooling layer 5 are all taken as MAX = 2 × 2, size = 2 × 2, and stride = 2; the upsampling layer restores the image to the original image size; the fully-connected layer takes num = 4096; the Soft-max layer obtains the classification results.

The main parameter settings of gene expression programming (GEP) are shown in Table 2.

Using the binary, grayscale and three color 512 × 512 images to conduct the comparative experiment on the fractal image compression encoding algorithm based on gene expression programming and its parallel algorithm (four threads) and this algorithm.

Table 1.

Classification loss weight.

Classification	Weight	Classification	Weight
Car	0.8713	Baby carriage	6.5874
Road	0.1286	traffic light	3.5866
Tree	0.3641	House	0.1016
Pedestrian	4.2631	Street light	3.5864
Sky	0.3265	Sidewalk	0.8967
Bicycle	12.3672	Billboard	1.5863
Child	7.4673

Table 2.

Basic parameter settings of GEP.

Parameter description	Value
Pop_size The initial size of the population	50
Gap next-generation individuals	5
Mutation rate	0.044
Reverse string, insert string, root string, transform	0.1
Single point reorganization	0.4
Two point reorganization	0.2
Gene recombination	0.1

GEP: gene expression programming.

Test results and analysis

The experimental results show that: when the learning rate is set at 0.01, the network converges rapidly. After 30,000 iterations, the loss function value hardly changes, and the correct rate and loss of training set are basically stable. The classification effect of this algorithm and the original SegNet algorithm on the Camvid dataset is shown in Figure 2. Table 3 shows that, among 13 classifications, 8 classifications have the higher classification results than the original SegNet algorithm. This algorithm can also classify the smaller or lesser classification, and the segmentation effect is more refined.

Table 4 is the peak signal-to-noise ratio (PSNR) test results based on four compression algorithms: GEP algorithm,¹⁸ GEP parallel algorithm,²⁷ EEOIC³⁹ (compression ratio better than jpeg and jpeg 2000) and the algorithm in this paper. Table 5 is the experimental result of their compression ratio, and Table 6 is the running time of these algorithms. As seen from the peak signal-to-noise ratio (PSNR) test results in Table 4, the EEOIC algorithm has the best reconstruction effect, followed by the algorithm in this paper. Because the EEOIC algorithm optimizes the DCT and multi-scale orthogonal WT of JPEG and JPEG 2000 for pixel blocks, its inverse transform has less decoding distortion. While the fractal compression algorithm reconstructs the image by transforming the parameters, the degree of distortion is large, and the reconstruction effect is relatively poor. This algorithm conducts the classification by deep convolutional network, and the segmented range block set and the domain block set have better search and matching precision in the encoding process of gene expression programming, which improves the imaging quality and obtains the better decoding effect than GEP or GEP parallel algorithm. The decoding reconstruction effect is shown in Figure 3.

As seen from the compression ratio test results in Table 5, “C-curve and Lena diagram” are binary images, and a relatively high compression ratio is obtained, mainly because they do not need classification and have strong self-similarity characteristics, and the IFS being obtained has fewer transformation parameters, and the compression ratio is relatively high. The color image is relatively complicated, as it contains more information, thus, after the convolution classification and the segmentation, it obtains more IFS parameters, and the compression ratio is relatively small. Although the EEOIC compression ratio is better than jpeg and jpeg 2000, it only optimizes the DCT of JPEG on pixel blocks and the multi-scale orthogonal wavelet decomposition used by JPEG 2000, its compression rate is lower than fractal compression algorithm, and its decompression effect is better than fractal algorithm. Compared with the other three algorithms, this algorithm obtains a higher compression ratio, but the decoding effect is worse than the EEOIC algorithm.

As seen from the compression time of the algorithm in Table 6, the compression time of this algorithm in “C curve and Lena map” is about 30–50% faster than “Street view”. Its reason is that, when processing “C curve and Lena map”, it is not necessary to perform classification calculation, which reduces the time expenditure. It is 6–10 times faster than the GEP-based serial algorithm, 3–4 times faster than the GEP-based parallel algorithm (4 threads), and 4–5 times faster than the EEOIC algorithm. It is mainly because this algorithm uses the deep CNN to classify the image first and then performs the segmentation, and its encoding search and matching number are reduced. Meanwhile, the compression encoding time is accelerated by the multi-thread scheduling of CPU/GPU platform and the accelerated operation of CUDA array processor. While the other two GEP algorithms directly segment the original image, which has large block search encoding, and the EEOIC algorithm uses serial coding and its calculation speed is slow.

In summary, this algorithm has a larger advantage in compression ratio and compression time compared to the advanced EEOIC algorithm, but it is slightly worse in compression distortion.

Figure 2.

Comparison of segmentation effects on CamVid annotation dataset.

Table 3.

CamVid dataset segmentation results.

Classification	SegNet algorithm	The algorithm	Classification	SegNet algorithm	The algorithm
Car	81.6	87.4	Baby carriage	7.4	8.71
Road	96.9	97.3	Traffic light	21.2	22.2
Tree	88.1	82.7	House	87.3	88.1
Pedestrian	58.3	55.7	Street light	26.8	27.2
Sky	91.1	92.6	Sidewalk	85.4	84.1
Bicycle	32.8	33.1	Billboard	24.8	26.2
Child	17.3	18.5

Table 4.

Signal-to-noise ratio (PSNR) test results.

Algorithm	C curve	Lena	Street view
GEP-based algorithm	35.3	34.2	30.6
GEP-based Parallel Algorithms	36.5	33.8	31.3
EEOIC algorithm	39.6	36.3	35.2
This algorithm	38.7	35.7	34.5

GEP: gene expression programming; EEOIC: end-to-end optimized image compression.

Table 5.

Compression ratio test results.

Algorithm	C curve	Lena	Street view
GEP-based algorithm	130.1	30.2	28.6
GEP-based parallel algorithms	129.6	30.8	29.3
EEOIC algorithm	260.2	270.5	280.6
This algorithm	130.3	33.7	32.5

GEP: gene expression programming; EEOIC: end-to-end optimized image compression.

Table 6.

Compression time test results (time unit: second).

Algorithm	C curve	Lena	Street view
GEP-based algorithm	963.21	1256.32	2376.21
GEP-based parallel algorithms	286.69	460.33	683.65
EEOIC algorithm	128.11	169.32	213.73
This algorithm	146.03	186.36	231.37

GEP: gene expression programming; EEOIC: end-to-end optimized image compression.

Figure 3.

Fractal compression encoding and decoding test comparison chart. (a) C curve original image (b) GEP serial reconstruction (c) GEP parallel reconstruction (d) This algorithm reconstruction (e) Lena original image (f) GEP serial reconstruction (g) GEP parallel reconstruction （h）This algorithm reconstruction (i) Street view original image (j) GEP serial reconstruction (k) GEP parallel reconstruction (l) This algorithm reconstruction.

Conclusion

This paper adopts a two-stage CUDA parallel programming hybrid processing method on CPU/GPU platform to segment the fractal image of deep CNN, and uses the gene expression programming to quickly search and encode the classification range block set and the classification domain block set, thus obtaining a higher compression ratio and better decoding reconstruction effect. This algorithm makes full use of the high-performance computing speed of CPU/GPU parallel system, the accurate and fast image classification of CNN, and the fast search and evolution convergence advantages of gene expression programming, thus its convergence speed is fast and its precision is high. However, when applying the CNN on CPU/GPU platform for image segmentation and classification numerical training, because the training data set is not universal and the training classification sample is too small, it has better segmentation and classification effect for the same type of image as the data set, but its segmentation and classification effect are not ideal for non-dataset images. Therefore, it is our next major research work to train different data sets on the CPU/GPU heterogeneous cluster platform in order to obtain the general multi-sample classifier, so as to adapt to the efficient classification and segmentation of various images.

Footnotes

Declaration of conflicting interests

The author(s) declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

Funding

The author(s) disclosed receipt of the following financial support for the research, authorship, and/or publication of this article: This study is supported by the National Natural Science Foundation of China under Grant Nos. 61866006,61741203; Guangxi Natural Science Foundation (2016GXNSFAA380243); Guangxi innovation-driven development of special funds project (Gui Ke AA17204091); Guangxi Nanning Science and Technology Development Planning Project (20181015–5).

References

Barnsley

Fractals everywhere. New York: Academic,1988.

Jacquin

AE.

A fractal theory of iterated markov operators with applications to digital image coding. PhD thesis, Georgia Institute of Technology, Atlanta, Georgia, 1989.

Al-Jawfi

RA.

Fractal image compression using self-organizing mapping. Appl Math 2014; 5: 342–357.

Kang

Fang

, et al. Extended random walkers based classification of hyper spectral images. IEEE Transac Geosci Remote Sens 2015; 53: 144–153.

Chen

Summers

Yao

Kidney tumor growth prediction by coupling reaction-diffusion and biomechanical model. IEEE Trans Biomed Eng 2013; 60: 169–173.

Sun

Scanned image descreening with image redundancy and adaptive filtering. IEEE Trans Image Proc 2014; 23: 3698–3710.

Fast fractal image encoding based on novel quadtree partition. Comput Digital Eng 2009; 37: 151–153.

Jiang

Hao

, et al. Survey on content-based image segmentation methods. J Software 2017; 28: 160–183.

Mustafa

Kim

Hilton

MSFD: multi-scale segmentation based feature detection for wide-baseline scene reconstruction. IEEE Trans on Image Proc 2019; 28: 1118–1132.

10.

Wang

Zhang

Guo

Novel hybrid fractal image encoding algorithm using standard deviation and DCT coefficients. Nonlinear Dyn 2013; 73: 347–355.

11.

Karthikeyan T, Praburaj B and Kesavapandian

Wavelet based image compression algorithms – a study. Int J Adv Comput Res 2014; 4: 78–89.

12.

Soyjaudah

KMS

Jahmeerbacus I.

Fractal image compression using quad tree partitioning. Int J Electric Eng 2013; 39: 183–210.

13.

Tian

Wang

, et al. On fractal image compression technology based on genetic algorithm. Comput Appl Software 2013; 4: 138–140.

14.

Zhao D P, Li P, Niu Z C et al. Novel Fast Fractal Image Compression Approach Based on Ant Colony Algorithm[J]. Journal of Shenyang Architectural University Natural Science Edition, 2006; 22(4): 653–656.

15.

Menassel

Nini

Mekhaznia

An improved fractal image compression using wolf pack algorithm. J Exp Theor Artif Intell 2017; 11: 1–12.

16.

Ruochen

Bingjie

Lang

A new two-step learning vector quantization algorithm for image compression. Transac Inst Measure Control 2015; 37: 3–14.

17.

Gupta

Mehrotra

Kumar Tyagi

Comparative analysis of edge-based fractal image compression using nearest neighbor technique in various frequency domains

. Alexandria Eng J 2018; 57: 1525–1533.

18.

Liu

Liao

Gene expression programming applied to fractals image compression encoding. Microelectron Comput 2011; 28: 67–73.

19.

Kang-Shun

Wei

Zhang

WD.

Image compression based on niching evolutionary algorithm. Tien Tzu Hsueh Pao/Acta Electron Sin 2014; 42: 809–814.

20.

WuLiang

Han

, et al. A two-stage lossless compression algorithm for aurora image using weighted motion compensation and context-based model. Optics Commun 2013; 290: 19–27.

21.

Chamorro-Posada

A simple method for estimating the fractal dimension from digital images: the compression dimension. Chaos Solitons Fract 2016; 91: 562–572. .

22.

Mohammed Omari, Salah Yaichi. Image Compression Based on Mapping Image Fractals to Rational Numbers[J]. IEEE Access 2018; 6: 47062–47074.

23.

Swalpa Kumar Roy, Siddharth Kumar, Bhabatosh Chanda, et al. Fractal image compression using upper bound on scaling parameter[J]. Chaos, Solitons and Fractals 2018; 106: 16–22.

24.

LiuMei

WH.

Simultaneous image compression, fusion and encryption algorithm based on compressive sensing and chaos. Optics Commun 2016; 366: 22–32.

25.

Wang

Zheng

Distributed parallel algorithm for fractal image compression

. Mini Micro Syst 2003; 24: 487–490.

26.

Huang

Liao

The parallel algorithm of relative gradient-based adaptive image fractal compression

. Microelectron Comput 2007; 24: 115–117.

27.

Zhong

Yuan

Fractals image compression parallel algorithm based on gene expression programming. Comput Eng 2012; 38: 201–202.

28.

Nakib A,Souquet

Talbi

EG.

Parallel fractal decomposition based algorithm for big continuous optimization problems. J Parallel Distributed Comput 2018; hal-01844420(1): 1–10.

29.

Vulcan

Nicolae

MM.

Fractal compression with GPU suppor. In: 21st international conference on control systems and computer science (CSCS), Bucharest, Romania, 1st may 2017, pp.459–462, IEEE CPS.

30.

Candida

Gene expression programming mathematical modeling by an artificial intelligence. Berlin: Springer, 2006: 10–478.

31.

Liu

Tang

, et al. A novel method for real parameter optimization based on gene expression programming. J Appl Soft Comput 2009; 9: 725–737.

32.

Zhu

Tang

Qiao

, et al. Genetic neutrality in naive gene expression programming. In: Wang

(ed) Proceedings of the engineering services and knowledge management. Berlin: Springer-Verlag, 2008, pp. 1–4.

33.

Zheng

Tang

Qiao

, et al. Mining causality in sub-complex dynamic system based on perturbation. Chin J Comput 2014; 37: 2548–2561.

34.

Jedrzejowicz

Wierzbowska

PI.

Implementing gene expression programming in the parallel environment for big datasets classification.

Vietnam J Comp Sci 2019; 6: 163–175.

35.

Hinton

Osinde Rosthe

YW.

A fast learning algorithm for deep belief nets. Neural Comput 2006; 18: 1527–1554.

36.

LeCun

Kavukcuoglu

Farabet

Convolutional networks and applications in vision. In: Proceedings of the IEEE international symposium on circuits and systems (ISCAS), Paris, France, 30th may 2010, pp.253–256. Piscataway, NJ: IEEE.

37.

Farabet

Najman

, et al. Learning hierarchical features for scene labeling. IEEE Trans Pattern Anal Mach Intell 2013; 35: 1915–1929.

38.

Goodfellow

Bulatov

Ibarz

, et al. Multi-digit number recognition from street view imagery using deep convolutional neural networks. Comput Sci 2013; 1:8.

39.

BalléLaparra

Simoncelli

EP.

End-to-end optimized image compression. In: 5th international conference on learning representations, Toulon, France, 24th-26th April 2017, pp.1–27. Rhineland, Germany: dblp computer science bibliography.

40.

Khatun

Iqbal

A review of image compression using fractal image compression with neural network. Int J Innov Res Comp Sci Technol 2018; 6: 9–11.

41.

Maha Lakshmi

GV.

Implementation of image compression using fractal image compression and neural networks for MRI images. In: International conference on information science (ICIS), Kochi,12st August 2016,pp.60–64. IEEE.

42.

Zhao

Wang Jia

, et al. Light field image compression based on deep learning. In: IEEE international conference on multimedia and expo (ICME), San Diego, 1st July 2017,p.1-6. IEEE.

43.

YuanPeng

Qin

, et al. Principle and application of gene expression programming algorithm. Beijing: Science Publishing House, 2010, pp.13–95.