text:
Generation High resolution 3D model from natural language by Generative Adversarial Network

We present a method of generating high resolution 3D shapes from natural language descriptions. To achieve this goal, we propose two steps that generating low resolution shapes which roughly reflect texts and generating high resolution shapes which reflect the detail of texts. In a previous paper, the authors have shown a method of generating low resolution shapes. We improve it to generate 3D shapes more faithful to natural language and test the effectiveness of the method. To generate high resolution 3D shapes, we use the framework of Conditional Wasserstein GAN. We propose two roles of Critic separately, which calculate the Wasserstein distance between two probability distribution, so that we achieve generating high quality shapes or acceleration of learning speed of model. To evaluate our approach, we performed quantitive evaluation with several numerical metrics for Critic models. Our method is first to realize the generation of high quality model by propagating text embedding information to high resolution task when generating 3D model.

Introduction
People usually use their natural languages to communicate their thoughts and emotions to others. Recently, artificial intelligence (AI) technology allows us to use these natural languages for operating and controlling the computer systems. For example, it is becoming possible for an AI engine to generate 3D shapes from descriptions of a natural language.
When creating 3D models, 3D designers commonly rely on expensive modeling software, such as Maya, Blender, and 3DSMAX, and they need to spend very long time to create satisfied quality of 3D models with these tools. Even after becoming an expert of these tools, it takes a long time to create one 3D model. Compared with using 3D modeling software, if human already has an image of the target object in her/his brain, it is very easy to express the outline of the shapes in the form of text descriptions. If an AI engine can generate 3D shapes quickly form text descriptions, it is possible to reduce the time taken for these heavy tasks.
There have been research efforts to generate 3D models from vectors of encoded text descriptions by using Generative Adversarial Network(GAN) [3]. For example, in [7], it is possible to generate 3D shapes with rough categories, but it is not possible to generate the fine models of them with colors or details of each part. Prior work shown in [2] successfully generates 3D shapes with colors from text descriptions. However the resolution of the shapes is still low. In the work, text is first converted to a vector representation via an encoder. Next, a corresponding 3D shape is generated by the Generator from the vector. This Generator is based on a deep-learning methodology and a GAN framework. When the vectorized text is input to the Generator, it is combined with noises to ensure the flexibility of the Generator.
The output of the 3D shapes is created through 3D deconvolution operations and then input to a Critic network. The Wasserstein distance between the actual 3D shape and the generated one is calculated. On one hand, the Critic network attempts to calculate the Wasserstein distance accurately. On the other hand, the Generator attempts to minimize the distance calculated by Critic. This ensures that the probability distribution of the actual 3D shape and the generated one becomes closer. The details of the algorithm will be described later in Section ??.
In the previous work, the output is generated in the form of 3D voxels. As for voxel generation, learning was done with voxel size of (x, y, z, color) = (32, 32, 32, 4). Since, in general, 3D model designers do not create 3D model in the form of voxels but in the form of mesh structure, voxels can be converted to mesh with the some methods such as Marching Cube [6]. However, if the resolution of the voxels is low, the appearance of the transformed mesh becomes considerably coarse. In addition, it becomes difficult to display sufficient details written in the text with low resolution voxels. Therefore, in this research, we propose another GAN learning methodology to generate voxels with higher resolution. Specifically, we use voxel size of (x, y, z, color) = (64, 64, 64, 4).
One of the ways to make the resolution higher is using larger neural network models. However, this cause tremendous increase in the number of parameters required to learn. If we simply use this large neural network model with a number of parameters, learning time increases significantly and sometimes learning is unstable. Therefore, in our proposed methodology, we reconsider the role of the Critic network of the previous research so that learning phase can be fast and stable.
Throughout this paper, we propose several GAN models where the rolse of the Critic network differ, for example, whether or not focusing on preciseness of the text descriptions. Since these models have advantages and disadvantages for various indices, we also introduce several metrics to compare the effectiveness of these proposed models.
The rest of this paper is organized as follows. In the next section, .....

Generative
Adversarial Network (GAN) [3] In the Generative Adversarial Network (GAN) framework, two networks called Generator and Discriminator are learned. Generator is trained to generate the data similar to the training data from latent vector. Discriminator learns to discriminate between the training data and the data generated by Generator. Generator and Discriminator is trained alternately with this mechanism, and finally it is expected that Generator can make the data similar to the training one.
These processes can be expressed by the following mathematical expression, where, G, D, and x are Generator, Discriminator, and training data, respectively. This expression shows the objective function of D, G. Here, we use z as a noise dor the latent vector and G generates data from the noise z. D(x) means the probability that x is regarded as the training data.

Conditional GAN (CGAN)[8]
In the original GAN, all elements of the latent vector which input to G are noise based on certain probability distribution. However, if noise is taken as an input, it is difficult to specify and generate the data which you want to generate specially. On the other hand, CGAN can express what we want to generate, by inputting a label as latent vector into Generator and Discriminator. In the CGAN, the latent vector of what you want to generate is encoded (from image, text. etc.) before generation.
In CGAN, the latent vector l which is appropriately generated by the training data is combined with the noise vector z and input to the Generator. The reason for combining with the noise vector is that this ensures Generator having diversity. Otherwise, it may limit its possible output, determined only by the latent vector. In addition to that, this helps make the output more robust even for some parts where latent vector cannot describe sufficiently (such as details of the background of an image).
It is common in usual GAN frameworks to use combined latent vector for an input to Generator so that the Discriminator recognizes the generated data as training data. The difference of CGAN is that it uses the combined vector l as an input to Discriminator. By doing so, Discriminator can judge whether the output from the Generator is actually linked with the corresponding latent vector description.
To implement the above point, the objective function of CGAN is expressed as follows: In order to strengthen the capability of identifying whether output is generated with the corresponding latent vector, the literature [10] proposes a way to train the data so that D should output 0 for training data that differs with the description of the latent vector. In this case, the objective function is expressed as follows: where p mis (x) is the probability distribution of the training data that mismatched with the latent vector.

WassersteinGAN(WGAN)[1]
The aim of WassersteinGAN (WGAN) is to bring the probability distribution of the generated voxel, P g (x), close to the probability distribution of the training data, P r (x). The simplest way of doing this is minimizing Kullback-Leibler (KL) divergence which is one of the metrics to observe distances between two probability distributions. KL divergence (KL) between the probability distribution P r and P g is calculated as follows: In the case of GANs, it is not possible to numerically calculate KL, and hence compute the loss function for them, because a specific probability distribution is not assumed in GANs. Instead of using KL directly, the GAN try to minimize Jensen-Shanon divergence (JSD). Although KL is asymmetrical, JSD can be symmetrical. The mathematical expression of JSD is represented as follows: As for loss of the GAN shown below; obviously JSD becomes maximum in the case of In this condition, the objective function becomes as follows In other words, while D accurately approximates JSD, G learns to minimize JSD which is calculated by D. However, in training GANs, it is very important to carefully adjust learning balance between Discriminator and Generator or learning rate of them. If the Discriminator's training is insufficient, the Generator will minimize the incorrect JSD. On the other hands, if Discriminator's training is too enough, the gradient for the parameters of Discriminator will be small, making Generator's training infeasible. As discussed, the success of learning of GANs depends on learning parameters. Specially when learning a model with a large number of parameters such as for 3D voxel creation in this research, adjustment of those learning parameters is extremely difficult. To overcome this challenge, One of prior work introduces another index to measure the distance between probability distributions instead of using JSD. In WassersteinGAN [1], Wasserstein distance is introduced as a metric of distance. Wasserstein distance is expressed as follows: where (P r , P g ) denotes the set of all joint distributions γ(x, y) whose marginals are P r and P g , respectively. Intuitively, γ(x, y) indicates how much "mass" must be transported from x to y for converting the probability distributions P r into the probability distribution P g . Originally, this is a metric used for optimal transport problems. This makes measuring the distance between low dimensional manifolds possible.
The Wasserstein distance can a better way to describe the distance than JSD, but it is difficult to calculate. According to Kantorovich-Rubinstein duality [9], it can be expressed using the 1-Lipschitz function f as follows: where x ∈ χ and f : χ → R. The meaning of 1-Lipschitz function is that the slope of a straight line of arbitrary x, x ∈ χ does not exceed 1. Here, if f is a function {f w } w∈W represented by some parameters and x ∼ P g follows g θ (z) : R n → χ, we can express W (P r , P g ) as follows: In order to satisfy the 1-Lipschitz condition, it suffices that each parameter fit into the compact space, that is, the absolute value of the weight parameter w is clipped to a certain value c. Discriminator is called Critic to distinguish it from the original GAN.
In WGAN, the Critic and the Generator networks learn alternately until Wasserstein distance converges. While the Critic attempts to calculate the Wasserstein distance between training data and generated data accurately, the Generator attempts to bring the probability distribution of generated data close to that of the training data by minimizing the Wasserstein distance calculated. Given that gradients do not disappear even if the Wasserstein distance converges completely WGAN is very stable in learning. Therefore adjustment of the learning balance between the Critic and the Generator is unnecessary.
In conventional GANs, since the Critic and the Generator networks use different loss functions, the loss values do not converge even if training fairly progress. The problem here is that the timing of finishing training is difficult to find out. However, the loss value of the Critic always goes toward converge in WGAN. Therfore, one of the advantages of WGAN is that decrease of the loss value always correlates with improvement in the quality of the generated data.
However, one of the disadvantage in WGAN is clipping weight parameters. If the weight parameters are clipped, the weights become polarized to the clipped boundary values, resulting in the gradient explosion or disappearance. This cause delay in learning. Here, the optimized Critic has a characteristic that it has a slope whose norm is 1 at almost all points below P r and P g [4]. Based on this feature, WGANgp is proposed [4]. In WGANgp, a penalty term is introduced in the loss function so that the Critic has a slope whose norm is 1 at almost all points below P r and P g . This allows it to be optimized without clipping the weights. Let D(x) be the output of the Critic. Then the loss is expressed as follows: By providing the penalty to the gradient, the weights have diversified values without polarizing, giving higher model performance.

text2shapeGAN[2]
As mentioned in Section 1, this paper is based on prior work which generates 3D voxels from texts [2]. In text2shapeGAN (TSGAN), they generate 3D voxels stably by combining CGAN and WGANgp techniques. In TSGAN, the Critic not only evaluates how realistic the generated voxels look like, but also how faithfully the generated voxels reflect texts. The objective function of TSGAN is as follows: where t is the text embedding, s is the 3D voxel, and p τ is the probability distribution of the text embedding. In addition, p mat and p mis are the probability distribution of matching text-voxel pairs and mismatching text-voxel pairs, respectively. Note that they sum up gradients for all the input variables of D to make the gradient penalty. First, it combines text embedding with a noise vector. This is an input to the Generator and a set of 3D voxels is output by deconvolution. As the last layer of the Generator, it has a sigmoid layer so that the output value is restricted from 0 to 1. The generated 3D voxels are input to the Critic and it is transformed into a one-dimensional vector via convolutional layers. It is combined with the text embedding and then passed to the fully connected layers. The output of the final fully connected layer is a scaler value. The output of the Generator is a set of voxels of (x, y, z, color) = (32, 32, 32, 4).

Approach
As the simplest approach to generate high resolution 3D shapes, it is conceivable that we can add a higher resolution deconvolution layer to the model of TSGAN. However, the number of parameters to be added becomes too large to compute because it needs to deal with three-dimensional data for learning. In this research, we assume to use a GPU for faster learning speed, but the number of parameters that a GPU can store in its memory for learning is limited, depending on the memory size of the GPU.
If the number of parameters is large, the problem is not only the fact that the learning is sometimes terminated by the lack of memory, but also the number of epochs required for training dramatically increases. Since the training for three-dimensional data is proportional to the order of cubic, training will not be finished in realistic time. Even though we can limit the number of epochs, the generated voxels may be collapsed. For these reasons, simply adding higher resolution layer does not work well.
To overcome the challenges described above, our approach is dividing the tasks into two steps; one is for generating a low resolution shape which roughly reflects the target text (StageI) and the other is for generating corresponding high resolution shape (StageII) by using the knowledge of StackGAN [12]. In StackGAN, StageI generates a low resolution image by roughly deciding color distribution and placement of it. In StageII, low resolution image generated in StageI is input to some convolution layers, then combined with the text embedding, which is sent to the Residual layer. Finally, a high resolution output image is generated via deconvolution layers. In the proposed method, we use TSGAN as StageI and constructing a new model for StageII to generate high resolution voxels. The following sections describe the details of these two stages.

Low resolution task (StageI)
The Generator tries to create rough shapes of resulting voxels at this stage. Unlike TSGAN, StageI in this research does not need to generate voxels which are strictly faithful to the input text since the details described in the text are reshaped at StageII. Instead of using latent vectors combined with additional noises as proposed in [2], we use only latent vectors as the input to the Critic since we found that it can create sufficient level of voxels and achieve faster convergence of training. In addition to that, we found a problem in TSGAN. In TSGAN, generated voxels are first converted to one-dimensional vectors through convolutional and fully connect layers of the Generator, and then combined with text latent vectors. This causes some cases that spatial information of voxels is lost, resulting in the lack of meaningful connection between the voxels and corresponding texts. Therefore, we spatially duplicated the text embedding vectors and combined them with the convolved voxels to hold the spatial feature as like StackGAN [12]. Fig.2 shows our proposed network model for StageI.

High resolution task (StageII)
In the high resolution task, the role of the Critic network varies depending on the type of input variables or loss functions. In contrast with StageI which decides the rough color and shape of voxels, we can consider two training models in StageII; focusing only on heightening resolution or extending the existing training models by refining the prior work. Therefore, we propose the following two models for StageII: • (v0): This model supposes that the faithfulness to text is sufficient in StageI, so that binding to text is relaxed. The Critic network focus on whether the generated high resolution shapes are correct or not.
• (v1): Like TSGAN, the Critic network focus on whether voxel is accurately generated from the text description of the shape.

High resolution model v0
In this model, Critic monitors whether higher resolution shapes can be appropriately achieved from the low resolution voxels. Fig.3 shows the flow of v0 model. A vector of text embedding is first input to the generator of StageI for generating low resolution voxels. The output voxels are input to the generator of StageII to generate higher resolution voxels. In v0 model, the input of the Critic network is both high resolution voxels and low resolution voxels so that the Critic can evaluate high resolution voxels based on the information of low resolution ones. We do not use vectors of text embedding for tasks after StageII because StageII concentrates solely on heightening resolution. Therefore, high resolution tasks can be completely separated from low resolution tasks by not using the text information in StageII.  Fig.4 shows the training model of v0. We introduce a residual layer as a hidden layer of the Generator network of StageII. By the residual layer, we can optimize each layer by learning the residual function using layer input instead of learning the optimum output of each layer [5].
The loss function for v0 model is defined as follows: where the generators for low resolution and high resolution tasks are indicated by G 1 and G 2 , respectively. By relieving the term contributed to p mis from L CW GAN , the model suppress learning the aspect of whether the shape matches with the text description. The degree of matching between the text description and the generated shape depends on the quality of training in StageI. However, by concentrating solely on heightening resolution, the number of parameter updates in the training phase can be greatly reduced, resulting in faster learning speed.

High resolution model v1
In this model, the Critic network monitors whether voxels are faithfully generated from the text depictions as like TS-GAN. Fig.5 shows the flow of v1 model. A vector of textembedding is first input to the generator of StageI for generating low resolution voxels. Here, StageI is the same as Generator of Fig.2. The generated low resolution voxel is input to StageII and a one-dimensional vector is created through the convolution layers. The vector is combined with the vector of text embedding and converted to a voxel again by the deconvolution layers. The reason of combining a vector representation of the voxel with the vector of text embedding is to generate a higher resolution voxel which reflects the details described in the text. The Critic network tries to determines both how realistic the generated voxel looks and how closely it matches with the text by using Wasserstein distance. Fig.6 shows the training model of v1. The loss function for v1 is defined as follows: This is the same loss function as TSGAN. Therefore, the Critic network evaluates whether the generated voxel is properly created from the text. The cost for a voxel mismatched with the text is included in the loss function to check how accurately the voxel is matched with the text. However, many parameter updates are needed in training the network since the Generator has two roles of heightening the resolution and making the generated voxel is closely matched with the text. Therefore, long training time is expected in this model 4 Evaluation

Experimental setup
In this section, we evaluate the proposed high resolution tasks v0 and v1. We compare the shapes generated by the models trained with 18000 epochs. In this evaluation, we use two objects, table and chair for generating 3D shapes. For this experiment, we used the same dataset as in TSGAN [2]. We created train/validation/test data by randomly splitting the dataset into the ratio of 80%/10%/10%, respectively. As for text embedding, we exclude texts which are not related to a table or a chair, texts with misspelling, or text without enough description to generate voxels.
In order to evaluate the generated 3D shapes in the aspect of quality, we use the following two indices.
• Accuracy of classification (Class acc.): The first index is the accuracy rate of classification which evaluate how correctly the generated shapes are classified. We created another classifier network model to classify two target objects represented by voxels generated from the text descriptions. All the generated 3D voxels are input to the classifier and evaluate its accuracy rate. The model of the classifier is created based on the prior work [7]. We expect that this accuracy metric can reflect how realistic the generated voxels look like.
• Mean squared error (mse): The second index is the mean square error of the text embedding vector. We created an encoder that generates a 128 dimensional vector from a resulted voxel. The dimension of the vector is the same as the text embedding vector. We train this encoder to minimize the mean squared error between the output vectors and original text embedding vectors. We input the resulting voxels into the encoder network and then calculate the mse between the result and the corresponding latent vectors. We expect that this can evaluate how well each voxel is matched with the text representation for it.   Table 1 shows the evaluation results of two indices for v0 and v1 models. The higher the classification accuracy rate, the better the quality of generated voxels. As for the mse, the lower the better. From the table, we see that the classification accuracy rate of v1 is larger than that of v0 and the mse of v1 is smaller than that of v0. Fig. 9 and Fig 10 show the trend of training losses of the Critic and the Generator network for two high resolution tasks, respectively. The loss for the both the overall trend of the loss for v0 and v1 in the Critic network is similar. However, variance of the loss trend for v0 is larger than that of v1 in the Generator network.

Discussion
As stated above, we compare the results of the networks trained with 18000 epochs. At this epoch, both v0 and v1 models have almost no 3D shape collapse. According to Table 1, v1 model is more faithful to the text than v0 model. As for the accuracy, both v0 and v1 model have high classification accuracy, but the v1 model achieves a little higher accuracy rate compared with the v0 model. This is because the Critic in v1 model can calculate the distance of the probability distribution between the train data and the generated voxel more accurately by referring to the text description. Thus, the Generator could generate more realistic voxels properly. The mean squared error for v1 is smaller that v0, meaning that v1 achieves better encoding results. This indicates the v1 model can generate voxels more faithfully to the text. Since we use information of the cost for a voxel mismatched with the text, the Critic can calculate Wasserstein distance more properly.
As can be seen from Fig. 7 and Fig. 8 (and also the figures in Appendix, the shape resolution is appropriately increased in both v0 and v1 models. However, a little change in the color distribution can be seen compared with the low resolution cases. We consider this is because the constraint of "How realistic and faithful the generated voxel is" is applied to the loss function, but we do not set any constraint regarding "How a high resolution shape is faithful to the corresponding low resolution shape". As in the previous study [11], introducing a constraint on the mean and variance of the color distribution to the loss function may suppress the change in color.

Conclusion
In this paper, we extend the prior work [2] and propose new GAN models that can generate high resolution voxels. In the proposed model, we also improved the previous method to generate even low resolution voxels more faithfully to a given text.
The contributions of this research are three-fold. First, we proposed the models which generate high resolution voxels faithfully to a given text from low resolution voxels. From the evaluation results, it is possible to generate high resolution voxels with good visual quality. Second, we contrived multiple roles of the Critic network and configured multiple models. We showed that there was a difference in accuracy depending on whether separating the higher resolution task from considering the text latent vector. Third, we introduced multiple indices to compare the performance of the models. As described in the discussion, there is a possibility for our proposed model to generate voxels that are more faithful to a given text with a higher quality shape.


extfieldsofstudy:
Physics
Computer Science

text:
Seizure Type Classification on EEG Signal using Support Vector Machine

One instrument to record the activity of brainwave in a specific time is called Electroencephalography (EEG). EEG signal can be used to analyze the epilepsy disease. Brainwave of seizure patient has a low frequency with a tighter pattern than brainwave of normal people. We use data from Temple University Hospital Seizure Corpus (TUSZ) that represents an accurate clinical condition characterization. Based on neurologist report, several types of seizure can be found in the dataset. In this research, we classify three types of seizure, Generalized Non-Specific Seizure (GNSZ), Focal Non-Specific Seizure (FNSZ) and Tonic-Clonic Seizure (TCSZ). We added a normal EEG signal, so we have four classes to be classified using Support Vector Machine (SVM). The training dataset consists from 120 data (20 GNSZ, 50 FNSZ, 25 TCSZ and 25 Normal), while the evaluation dataset is 90 datasets (20 GNSZ, 50 FNSZ, 5 TCSZ and 15 Normal). We observe the combination of three feature extraction method, Mel Frequency Cepstral Coefficients (MFCC), Hjorth Descriptor and Independent Component Analysis (ICA). The best result obtained by combining MFCC and Hjorth descriptor that can detect seizure type with 90.25%, 97.83%, and 91.4% of average sensitivity, average specificity, and accuracy respectively.

Introduction
The brain is one of the most important organs in the human body as a central nervous system (CNS) which functions as a controlling center, intelligence, creativity, emotions, memories, and body movements. Inside the brain, there are neuron cells that are connected through synapses to deliver information when responding to a stimulus. The process of sending this information through electricity transmission as a result of neuronal cell biopotential activity. Under normal conditions or healthy people, this electrical activity is found in all area of the brain and then produces brain waves that can be studied. When the electrical cells of neurons disrupted by either excessive activity or loss of the function of biopotential signal transmission, it can cause brain function disorders. One of the effects of abnormalities in electrical functions is epilepsy, which is generally characterized by body seizures and merely stares blankly for a few seconds during a seizure with a specific duration. According to WHO, Epilepsy is one of the most common neurological disorders. Based on a survey, about 50 million people worldwide have epilepsy [1].
Patient with epilepsy needs a continuous treatment that can increase their quality of life. First treatment that can be done is by medication. in this process, the patient's EEG signal need to be monitored and analyzed continuously in a certain period. The analysis of EEG signal usually done manually by a certified neurologist. Due to the massive development of computer technology, seizure detection, and seizure types classification in EEG signal can be done by applying digital signal processing using simple and even complex methods. Analyzing computed EEGs can help us to get information that can be used to diagnose normal brain activity or epilepsy. Doctors generally classify seizures as either focal or generalized, to determine the right treatment for the treatment of this disease [2].
Some researchers have conducted studies to detect the phase of seizures through EEG signal processing as reported in the study [3][4][5][6][7][8]. In this study, the classification of the seizure phase was called pre-ictal, ictal, inter-ictal and postictal with the aim of analyzing differences in characteristics in each phase. The method used for signal processing can be done in the time, frequency or timefrequency domains. Another important study was early detection of the phase before seizures to give an alarm to epilepsy patients as reported in the study [9][10][11]. Early detection is essential to help people with epilepsy predict conditions that they will experience in the future so that they prepare their self, such as finding a safe place before the seizures occur.
In this research, we detect the type of seizures as opportunities and challenges to help the neurologist in classifying the seizure from EEG recording. This classification of seizure may respond to the right treatment and if possible, prognosis prediction. Different types of seizures may also be used to determine the original location and seizure pattern so that that appropriate medical measures can be determined, either in the form of medication or surgery. Therefore, in this proposed study, we conducted an epileptic EEG signal processing simulation to differentiate the types of seizure. The seizure types studied in this research were a generalized non-specific seizure, non-specific focal seizure, and tonic-clonic seizure [12]. The methods used in this research were Mel Frequency Cepstral Coefficients (MFCC), Hjorth Descriptor, and Independent Component Analysis (ICA) as features extractions while Support Vector Machine (SVM) used as the classifier.
Analyzing EEG signal in time and frequency domains are essential. Dominant timing and frequency band belong to every EEG signal for extracting different features [13]. Hjorth Descriptor was one of a method that works in time domain [14]. MFCC can process quasi-stationary signals which in the forms of sound signals and EEG signals [15]. This method has widely used in EEG signal processing with high accuracy [16]. ICA can be used to obtain considering only the relevant signals and powerful tool for the biomedical analysis involved more channels in electroencephalogram [17,18].

Temple University Hospital Seizure Corpus
Temple University Hospital Seizure Corpus (TUSZ) is the most massive open source corpus that represents an accurate clinical condition characterization [12,19]. Data recorded by using 250 Hz and 256 Hz frequency sampling each second from each data. Electrode placement on the scalp is using the standard 10/20 system. Data were taken at one part in the frontal cortex. The data consists of 3 types of seizures. There are GNSZ, FNSZ, and TCSZ. GNSZ can be seen from the spastic focal of the spike. A signal can be declared as a generalized non-specific seizure signal if there is not much evidence of its existence, it can be defined as generalized seizure type. FNSZ cannot be specified by its type, and its location is in the hemispheric or focal part of the brain. TCSZ has two steps of events, at first stiffening or tonic phase and then jerking of the body or clonic phase [12].
The number of training dataset is 120 signals consist of 20 GNSZ, 50 FNSZ, 25 TCSZ, and 25 Normal EEG signals. On the other hand, the number of evaluation dataset is 90 signals that consist of 20 GNSZ, 50 FNSZ, 5 TCSZ, and 15 Normal EEG signals. Each data extracted by using five scenarios explained in the next section.

Hjorth Descriptor
Hjorth Descriptor method as feature extraction works in time domain [14]. The output of this method represented with three parameters. They are activity, mobility, and complexity [13]: a. Activity It's the average of signal power and the surface of power spectrum in frequency domain can be indicated with this parameter by using the variance of time function. The value of activity can be large if there are many high frequency components of its signal, vice versa. (1) Mobility is the average of power spectrum frequency.
c. Complexity Complexity is the first derivative of mobility ratio of its signal.

Mel Frequency Cepstral Coefficients
Sampling frequency that is used for processing these data using MFCC method is 8000 Hz. The steps of MFCC extraction feature described as follows [16,20,21]: 1. Data were divided into some frames. Framing, the duration each frame was 30 ms. 2. Hamming window, the length of window is the value of sampling frequency times duration each frame.
where: = sample of signal windowing to-n = value of sample to-n = value of windowing to-n = number of samples in the frame 3. FFT, changing from the time domain to frequency domain. The output of this process called spectrum. 4. Mel-frequency wrapping, calculating the log amplitude at spectrum into Mel scale by using triangle filter bank. The output of this process was log energy for each filter. 5. Cepstrum, transforming mel-spectrum coefficient by using Discrete Cosine Transform (DCT) producing fourteen cepstral coefficients for each frame

Independent Component Analysis
Independent Component Analysis (ICA) commonly used for blind source separation. It needs specific conditions in order to separate a mixed signal. These conditions were (1) Independent, namely S1 and S2 as different random variables. (2) Fundamental and essential principle in estimating ICA is Non-Gaussianity. The presence or absence of kurtosis can indicate Gaussian or not a signal. If the kurtosis value is 0, then the signal is a Gaussian signal. Conversely, if the positive or negative kurtosis value is called a non-gaussianity signal [17,18].
The results of the algorithm that have been processed are independent components that have a kurtosis value not equal to 0. Then the highest value of kurtosis is chosen. Next is to find the statistical value of the selected component. The weight formula for every i can be calculated using Eq.8 [17].

Support Vector Machine
Support Vector Machine (SVM) was developed by Vapnik in 1995 to solve a classification problem. This primary goal then extended to give solution for regression technique [22]. Basically, SVM is a type of linear classifier where it can separate two classes by making optimal hyperplane function with the most significant margin. Hyperplane can be said as a dimensionless vector space that can clearly divide the vector space into two different classes. The primary goal of calculating the hyperplane is to maximize the distance from the nearest class pattern [23,24]. Fig. 1 shows an example of the use of hyperplane for splitting two classes [24]. Consider a training dataset with number of samples, and represent each sample dimension as shown in Eq.9. denotes the sample class label with . The boundary that separates each classes is shown in Eq.10, where and represent the weight and bias respectively. Eq.11 shows the linear classifier's decision function. To find the maximum margin, the distance value between hyperplane and its nearest point needs to be maximized. It can be done by finding the minimum point of Eq.12, taking into account the constraint of Eq.13 [25]. SVM kernel can be grouped into two, and they are linear SVM and nonlinear SVM. The nonlinear kernel consists of two polynomial functions (quadratic and cubic), and the radial basis function (fine, medium, and coarse gaussian). In this research, we use these six kernels to find out which one suitable for the classification process [24]. The dataset consists from 210 signals, that split into 120 training data and 90 evaluation data. Those data consist from 20 GNSZ, 50 FNSZ, 25 TCSZ, and 25 Normal EEG signals. On the other hand, the number of evaluation data was 90 signals that consist of 20 GNSZ, 50 FNSZ, 5 TCSZ, and 15 Normal EEG signals.

Testing Scenario
In this research, we do five scenarios that combine the use of three feature extraction methods.
1. The first scenario, extracting the features by using Hjorth Descriptor with three features (Activity, mobility, and complexity).

Classification Result
We used R2018b version of Matlab software. We use MFCC toolbox for extracting 14 cepstral coefficients, and SVM toolbox for the classifier. We used 5-fold cross validation to test generalization capabilities. After that, we split the dataset into training and testing data as mentioned in section 2. Figure 2 shows the example of normalized seizure type signals, GNSZ, FNSZ, TCSZ, and normal EEG signal. Visually the pattern of each seizure signal shows that they follow the general information about the seizure, which has a lower frequency, and higher amplitude [2]. We observe the optimum classification result from different SVM kernels. The kernels used were linear, quadratic, cubic, fine, medium, and coarse Gaussian. The result from each scenario are


extfieldsofstudy:
Computer Science
Mathematics

s2fieldsofstudy:
Computer Science
Mathematics

text:
Contracting Proximal Methods for Smooth Convex Optimization

In this paper, we propose new accelerated methods for smooth convex optimization, called contracting proximal methods. At every step of these methods, we need to minimize a contracted version of the objective function augmented by a regularization term in the form of Bregman divergence. We provide global convergence analysis for a general scheme admitting inexactness in solving the auxiliary subproblem. In the case of using for this purpose high-order tensor methods, we demonstrate an acceleration effect for both convex and uniformly convex composite objective functions. Thus, our construction explains acceleration for methods of any order starting from one. The augmentation of the number of calls of oracle due to computing the contracted proximal steps is limited by the logarithmic factor in the worst-case complexity bound.

1. Introduction. One of the classical iterative methods in theoretical optimization is the proximal point algorithm [24]. This method, as applied to minimizing a convex function f : dom f → R, consists of solving at each iteration the following subproblem: where · is the standard Euclidean norm, and {a k } k≥1 is a sequence of positive coefficients. In general, we can hope only to use an inexact solution of the subproblem (1.1) (see [10,27,26] for the convergence analysis). An important observation is that the regularized objective in (1.1) is strongly convex. Therefore, we can hope that computing an (inexact) proximal step is usually simpler than solving the initial problem.
For a function f ∈ F 1,1 L (convex differentiable functions with Lipschitz continuous gradients), we can set all values of the coefficients a k equal to a positive constant. This gives a global sublinear rate of convergence of the iterations (1.1) in functional residual of the order O(1/k). This rate is the same rate as that of the gradient method [21].
For the same class of functions, we can get a faster rate of convergence of the order O(1/k 2 ) using the accelerated gradient method [18]. This is the best possible rate achievable for the first-order black-box optimization on F 1,1 variant of the proximal point algorithm with the optimal rate of convergence was proposed in [11] (see also [25,13,14,12] for extensions and some applications).
In this paper, we present a new family of proximal-type algorithms for smooth convex optimization called contracting proximal methods, which includes an accelerated algorithm from [11] as a particular case and provides a systematic way for constructing faster proximal accelerated methods for high-order optimization. Thus, for the class of convex functions, whose p-th derivative is Lipschitz continuous (p ≥ 1), our new methods achieve the O(1/k p+1 )-rate of convergence for the outer proximal iterations, while the inner subproblems can be efficiently solved up to desired accuracy by the high-order tensor methods [22]. Note that this rate can also be achieved by a direct acceleration scheme, utilizing the notion of estimating sequences [2,22]. It can be improved up to the level O(1/k 3p+1 2 ) by using a special line-search on each iteration [16,7]. The latter rate was shown to be the optimal one [1].
The main difference between contracting proximal methods and the classical approach (1.1) consists in employing the contracted objective function (which provides the methods with their name) and the Bregman divergence (notation β d (x; y)) instead of the usual Euclidean norm. The exact form of our method is very simple: Thus, we use a sequence of auxiliary points {v k } k≥0 and the scaling coefficients Let us illustrate the basic idea behind this construction by the simplest Euclidean setting, when β d (x; y) ≡ 1 2 x − y 2 . We are going to ensure at each iteration k ≥ 0 the following condition: We can propagate inequality (1.3) to the next iteration by a trivial observation: where the last inequality is due to convexity of the objective. Note that the first step of contracting proximal method (1.2) is defined exactly as follows: Hence, by strong convexity of h k+1 (·), we finally justify that Thus, for the Euclidean setting, iteration (1.2) immediately results in the convergence guarantee (1.4). However, we are still free in the choice of coefficients {a k } k≥1 . The only reason for bounding their growth consists in keeping the complexity of the optimization problem (1.5) at an acceptable level. 1 For f ∈ F 1,1 L , the recommended choice of a k+1 corresponds to the quadratic equation [18]: It is easy to see that this choice results in the optimal O(1/k 2 )-rate of convergence for the method. On the other hand, it makes the condition number of the problem (1.5) equal to an absolute constant. Let us assume for simplicity that f is two times continuously differentiable. Then, in view of the presence of the regularization term, On the other hand, 2I.
Hence, we are able to solve the problem (1.5) very efficiently by a usual gradient method (see the details in section 4). It is remarkable that exactly the same reasoning justifies the accelerated versions of all high-order tensor methods (p ≥ 2). The only difference consists in the degree of the proximal term, which must be compatible with the order of optimization scheme used for solving the problem (1.5).
Our first-order contracting proximal method for the Euclidean setting (described above) produces the same sequence of points as the accelerated Proximal Point Algorithm from [11]. However, now we can also employ the Bregman divergence, which sometimes is more suitable to the topology of our function and ensures faster convergence.
The rest of the paper is organized as follows. Section 2 introduces notation used throughout the paper and describes our problem of interest in the composite form. We also give a definition of Bregman divergence and mention some of its properties.
In section 3, we introduce a general contracting proximal method (formulated as Algorithm 1). We present its convergence analysis for a problem in composite form and arbitrary Bregman divergence. We study both convex and strongly convex cases under inexactness in proximal steps. Theorem 3.2 specifies how the parameters of the algorithm and inner accuracy affect the convergence rate.
In section 4, we discuss implementation of one iteration of our method, under the assumption that the p-th derivative (p ≥ 1) of the smooth part of the objective is Lipschitz continuous. We present a fully defined optimization scheme (Algorithm 2), with incorporated steps of the tensor method of a certain degree. The resulting algorithm achieves the accelerated rate of convergence, with an additional logarithmic factor for the number of total oracle calls. The final complexity estimate for this scheme is given by Theorems 4.6 and 4.7.
Section 5 contains numerical experiments. Section 6 has some final remarks.

Notation.
In what follows, we denote by E a finite-dimensional real vector space and by E * its dual space, which is a space of linear functions on E. The value of function s ∈ E * at point x ∈ E is denoted by s, x .
Let us fix some arbitrary (possibly non-Euclidean) norm · on space E and define the dual norm · * on E * in the standard way: For a smooth function f , its gradient at point x is denoted by ∇f (x), and its Hessian is Higher derivatives are denoted as D p f (x) [·], which are p-linear symmetric forms on E, and the norm is induced: For convex but not necessary differentiable function ψ, we denote by ∂ψ(x) ⊂ E * its subdifferential at point x ∈ dom ψ.
Our goal is to solve the following composite minimization problem: where f is several times differentiable on its open domain convex function, with some reasonable assumptions on the growth of its derivatives (for example, that its p-th derivative is Lipschitz continuous for some p ≥ 1), and ψ : E → R ∪ {+∞} is a proper closed convex function, which we assume to be simple, but possibly nondifferentiable, with dom ψ ⊂ dom f . We also assume that solution x * ∈ dom F of problem (2.1) does exist, denoting F * = F (x * ). Let us fix arbitrary differentiable strictly convex function d : dom ψ → R, which we call theprox function. Then, we denote by β d (x; y) the corresponding Bregman divergence, centered at x: We say that function d is uniformly convex of degree p + 1 (with respect to the norm · ) with constant σ p+1 (d) > 0 if it holds for all x, y ∈ dom d: x − y p+1 .
The main example, which naturally appears in tensor methods (see [22]) and which we use in section 4, is the following prox function.
for some p ≥ 1. For the Euclidean norm (when x ≡ Bx, x 1/2 for a fixed postivedefinite linear operator B = B * 0) this prox function is uniformly convex of degree p + 1 with constant 2 1−p (see Lemma 5 in [5]), so it holds that For more examples of available prox functions see [3,15]. The definition of Bregman divergence can be extended onto nondifferentiable function ψ by specifying a particular subgradient ψ (x) ∈ ∂ψ(x): However, we will use simpler notation β ψ (x; y) if no ambiguity arises.
We say that function ψ is strongly convex with respect to d (see [28,3,15]) with constant σ d (ψ) > 0 if it holds for all x, y ∈ dom ψ and for all ψ (x) ∈ ∂ψ(x) that Inequality (2.4) always holds with σ d (ψ) = 0 just by convexity. An interesting illustration of this concept is given by a regularized Taylor polynomial of degree 3 for convex function (see [22]).
Example 2.2. Let f : dom f → R be convex, with Lipschitz continuous third derivative: Denote by Ω 3 (f, x; y) its Taylor approximation of degree 3 around some fixed point x, and consider its regularization of degree 4, with some τ > 1: Then, for the Euclidean norm, the function g(·) is strongly convex with respect to the following prox function (see Lemma 4 in [22]): Let us summarize some basic properties of Bregman divergence, which follow directly from its definition. For any pair f 1 , f 2 of convex functions and all x, y ∈ dom (f 1 + f 2 ) we have For any linear function (x) = a + g, x we have Therefore, from (2.5) and (2.6) we conclude that when f (y) = β d (z; y) for some fixed z. Now, consider the following simple but general construction, which we use in a core of our analysis. Let h be a regularized composite objective: h(y) = g(y) + aψ(y) + γβ d (z; y), a, γ ≥ 0, where g and ψ are arbitrary closed convex functions, and ψ is strongly convex with respect to d with some constant σ d (ψ) ≥ 0. Then we have, for every x, y ∈ dom h and every h (x) ∈ ∂h(x) In particular, for the exact minimum T = argmin y∈E h(y), we have 3. Contracting proximal method. In our general scheme, we are going to maintain the following inequality, for every x ∈ dom ψ and k ≥ 0: and {γ k } k≥0 is a sequences of nondecreasing proximal coefficients, We would prefer to have functions C k (x) as big as possible. Thus, if it happens to be C k (x * ) ≥ 0 for all k ≥ 1, then from (3.1) we have a convergence guarantee, and the rate of convergence is determined by the growth of coefficients A k toward infinity. However, generally C k (x) may have arbitrary sign.
Let us discus a simple possibility for propagating relation (3.1) to the next iteration.
where the last inequality is due to the convexity of f . Let us consider a contracted objective with a regularizer from the last step: This function is strongly convex with respect to d(·) with parameter If we are able to compute the exact minimum then by (2.9) we see that And it is natural to set v k+1 = T and Thus we would obtain guarantee (3.1) for the next step, with Now, instead of computing the exact minimum (3.5), let us relax v k+1 ∈ dom ψ to be a point with a small norm of subgradient: Note that condition (3.7) can be easily verified algorithmically since in composite setting we are able to compute points with a small subgradient of h k+1 (see [22]). Thus, we come to the following general scheme.

Algorithm 1: Contracting Proximal Method
Require: 2: Denote contracted objective with regularizer: At this moment, we need one additional assumption. It relates the dual norm · * (used at step 4) with the Bregman divergence β d (v; x).
Let us write down the convergence guarantees of the method.
Let Assumption 3.1 hold. Then for Algorithm 1 at all iterations k ≥ 0 we have Proof. First, let us ensure by induction in k ≥ 0 the following inequality: where s i ∈ ∂h i (v i ). It is obviously true for k = 0. Let it hold for some k ≥ 0 and consider the next. Note that (3.10) is exactly (3.1) with Therefore, we have This is (3.10) for the next step. Now, plugging x ≡ x * into (3.10) and taking into account the nonnegativity of all terms in the left-hand side, we get Now, we need to estimate the right-hand side from above. Using the uniform convexity (2.2), we conclude that for every k ≥ 0 In order to finish the proof, it is enough to bound from above the value α k , for which we have the following recurrence: Dividing both sides by α 1 p+1 k and using the monotonicity of this sequence, we get Finally, from the last inequality we obtain which is the right-hand side of (3.8).
We see that accuracies δ k for subgradients of the subproblems appear in (3.9) in an additive form, weighted by the coefficients γ − 1 p+1 k . They should be chosen in a way making the right-hand side of (3.8) small enough. Let us consider the simplest case, when all δ k are the same. Corollary 3.3. Let δ k = δ > 0 for all k ≥ 1. Assume that the coefficients A k grow sublinearly: with some constant c > 0. Then for every Proof. Indeed, Summing up these two inequalities we obtain (3.14).
Proof. Indeed, Now, note that the following inequality holds for all x ≥ 0: And we obtain Estimates (3.13) and (3.17) show that the bound for the inner accuracy δ has a reasonable dependency on the absolute accuracy ε required for the initial problem (2.1). Thus, in both cases, in step 4 of the algorithm we need to find a point v k+1 with subgradient s ∈ ∂h k+1 (v k+1 ): This is a reachable goal, especially for methods minimizing h k+1 (·) with a linear rate of convergence.
In practice, it may be reasonable not to use very small inner accuracy on a first stage but to decrease it over the iterations. Then, the following simple choice of {δ k } k≥0 can work.
Corollary 3.5. Let us define δ k ≡ c k s with fixed absolute constants c > 0 and s > 1. Then, Therefore, we have

Application of tensor methods.
In this section, let us incorporate the high-order tensor methods [22] into Algorithm 1 for solving the corresponding inner subproblem (3.5). From now on, we restrict our attention to Euclidean norms. Let us fix symmetric positive-definite linear operator B : E → E * (notation B = B * 0) and use the following norm for the primal space: x ≡ Bx, x 1/2 , x ∈ E. The norms for multilinear forms on E are induced in the standard way (see section 2).
For this setup, we use the following simple prox function: Thus, the choice of prox function (4.2) is strictly related to the preferable degree p ≥ 1 of smoothness of function f . Let us define the Taylor approximation Ω p (f, x; y) of function f around the point x ∈ dom f : By Assumption 4.1, we are able to bound its accuracy in the following way: for all x, y ∈ dom f it holds that Let us look at our regularized objective h k+1 (·), which needs to be minimized at every step k ≥ 0: . This is a sum of two convex functions: smooth component g k+1 and possibly nonsmooth but simple component φ k+1 , which is strongly convex with respect to d.
Let us drop unnecessary indices and consider the subproblem in a general form: with g having bounded Lipschitz constant for some p ≥ 1: 0 < L p (g) < +∞. Since we assume the objective to be strongly convex with respect to d from (4.2) with parameter σ d (h) > 0, for every x, y ∈ dom h and all h (x) ∈ ∂h(x) we have Bound (4.3) motivates us to define the following point, and consider the following iteration process, For p = 1, the point (4.8) is used in the composite gradient method [20]. For p = 2, this is a step of composite cubic Newton [6,9]. It can be shown that for M ≥ pL p (g) the auxiliary optimization problem in (4.8) is convex for all p ≥ 1 (see Theorem 1 in [22]). Therefore it can be efficiently solved by different techniques of convex optimization and linear algebra (see also [23,22]).
Let us mention some properties of point T ≡ T M (h; x). Its characteristic condition is as follows: Therefore,

This inclusion justifies notation
In order to work with these objects, we use the following result (see Lemma 2 in [4]).
In particular, if β = p, then The next lemma describes the global behavior of method (4.9).
Lemma 4.3. Let β ≥ 1 and M = βL p (g). Then for any x, y ∈ dom h we have Now, we are ready to prove a convergence result on the iteration process (4.9).
Theorem 4.4 (convergence of tensor method). Let M = pL p (g). Then, for every t ≥ 0 and y ∈ dom h we have Proof. Let us consider the point z t+1 = T M (z t ). By (4.12), we have for any y ∈ dom h.
Denote x * h def = argmin y∈E h(y) and consider y = z t +α(x * h −z t ) for α ∈ [0, 1]. Then we have The minimum of the right-hand side is attained at Plugging it into (4.15) gives Therefore, for every t ≥ 0 we have for every y ∈ dom h. It remains to use Lemma 4.2 and finish the proof: Thus, we can see that, applying tensor method (4.9) of degree p ≥ 1 on step 4 of the general contracting proximal method (Algorithm 1), we obtain fast linear convergence for the norms of subgradients. Hence, we can estimate the total number of inner steps t k at iteration k ≥ 0 as follows.
using M := pL p (g k+1 ) and z 0 := v k . Then we have Proof. By definition, for all x ∈ dom ψ, we have Therefore, Then for y ≡ x * def = argmin y∈E F (y) we obtain It remains to use this bound together with (4.13) and the following estimation of the strong convexity parameter: By representation (4.5), we have a simple relations between Lipschitz constants of the derivatives for function g k+1 (·) and f (·): Therefore, we can control the condition number of our objective. Indeed, by (4.17), the main complexity factor in the minimization process for h k+1 (·) is the ratio We are able to keep this ratio small by applying an appropriate growth strategy for coefficients A k . Let us consider two cases: σ d (ψ) = 0 and σ d (ψ) > 0.
and we get Thus we obtain 2. σ d (ψ) > 0. For k = 0 we pick a 1 ≡ c(p + 1) as in the previous case. Now consider k ≥ 1. Denote and choose a k+1 from the equation Thus, in both cases, at every upper-level step we need to perform a logarithmic number of iterations of the inner method, multiplied by a small constant.
We are ready to specify the whole optimization procedure.
Let us present global complexity bounds for this method in convex and strongly convex cases.
Theorem 4.6 (convex case). Let for a given ε > 0, the inner accuracy δ be fixed as follows: Then, in order to achieve F (x K ) − F * ≤ ε it is enough to perform iterations of Algorithm 2. The total number of oracle calls N K def = K k=1 t k is bounded as (4.27) N K ≤ K · 3 + p+1 p log 4 1 + 1 γ0 (p + 1) Proof. Estimate (4.26) follows directly from (3.13), by substituting the value c = p!γ0 . Now, let us prove (4.27). By (4.17), we have In order to finish the proof, we need to bound the value under the logarithm. By the choice of a k , we have an upper bound for A k : Therefore, for every 0 ≤ k ≤ K: This completes the proof. Now, let us discuss the overall dependence of δ and K on p, given by the claim of Theorem 4.6. For simplicity, we fix x * ) = 1, and γ 0 = 1. Thus, we observe the functions One can see that log 2 δ(p) ≤ −p. Therefore, increasing the order of the method, it requires at least to double the precision of solving the subproblem. At the same time, we have (using Stirling's formula) lim p→+∞ K(p) = 1 + 2 exp lim p→+∞ (p+2) log(p+1)−log p! p+1 = 1 + 2 exp(1).
Hence, the value of K(p) is bounded from above by an absolute constant. The graphs of the dependence (4.29) are shown in Figure 1. Note that in practice, we are interested rather in small values of p.   .24). Let for a given ε > 0 the inner accuracy δ be fixed as follows: Then, in order to achieve F (x K ) − F * ≤ ε, it is enough to perform (4.31) The total number of oracle calls N K is bounded as follows: (4.32) Therefore it holds that λ 1 = 1/(1 + exp(α)) and λ n = 1/(1 + exp(−α)), so parameter α is related to the condition number of the problem.
In Table 1 we demonstrate the number of iterations and the total number of matrix-vector products, which are required for the methods to solve the problem up to ε = 10 −7 accuracy in functional residual.  Table 1: Minimization of quadratic function, q = λ min (A)/λ max (A).
We see that the contracting proximal method is always better than the usual proximal algorithm. It requires about the same number of iterations as the accelerated gradient methods, but it needs to spend more oracle calls per iteration, which confirms the theory.

Log-Sum-Exp.
In the next example we compare a performance of secondorder methods for unconstrained minimization of the following objective: where µ > 0 is a parameter, while coefficients of the vectors {a i } m i=1 and b are randomly generated, and we set m = 6n.
We compare the cubically regularized Newton method [23] and its accelerated variant from [19] with the contracting proximal cubic Newton (Algorithm 2 with p = 2) for minimizing the objective up to ε = 10 −8 accuracy in functional residual. In these algorithms we use the following Euclidean norm for the primal space, x = Bx, x 1/2 , with matrix B = m i=1 a i a T i , and fix the regularization parameter equal to 1. The results are shown in Table 2  We see that the contracting proximal method outperforms the direct methods in the number of iterations, but usually requires additional oracle calls for solving the subproblem.
6. Conclusion. In this work, we propose a general acceleration scheme, based on proximal iterations. There are two distinguishing features of our methods: employing the contraction of the smooth component of the objective (this provides the acceleration) and flexibility of prox-function (its choice should take into account both the geometry of the problem and the order of the smoothness).
One of the recent important applications of the accelerated proximal point methods in machine learning is the universal framework Catalyst, applicable to the firstorder methods [13,14]. This is a powerful approach for accelerating many specific optimization methods in a common way. We believe that the results of this paper can help in advancing in this direction, resulting in the faster high-order methods for many practical applications.