Shinichi Shirakawa

Evolutionary image segmentation based on multiobjective clustering

In the fields of image processing and recognition, image segmentation is an important basic technique in which an image is partitioned into multiple regions (sets of pixels). In this paper, we propose a method for evolutionary image segmentation based on multiobjective clustering. In this method, two objectives, overall deviation and edge value, are optimized simultaneously using a multiobjective evolutionary algorithm. These objectives are important factors for image segmentation. The proposed method finds various solutions (image segmentation results) by the use of an evolutionary process. We apply the proposed method to several image segmentation problems and confirm that various solutions are obtained. In addition, we use a simple heuristic method to select one solution from the original Pareto solutions and show that a good image segmentation result is selected.

Graph structured program evolution

In recent years a lot of Automatic Programming techniques have developed. A typical example of Automatic Programming is Genetic Programming (GP), and various extensions and representations for GP have been proposed so far. However, it seems that more improvements are necessary to obtain complex programs automatically. In this paper we proposed a new method called Graph Structured Program Evolution (GRAPE). The representation of GRAPE is graph structure, therefore it can represent complex programs (e.g. branches and loops) using its graph structure. Each program is constructed as an arbitrary directed graph of nodes and data set. The GRAPE program handles multiple data types using the data set for each type, and the genotype of GRAPE is the form of a linear string of integers. We apply GRAPE to four test problems, factorial, Fibonacci sequence, exponentiation and reversing a list, and demonstrate that the optimum solution in each problem is obtained by the GRAPE system.

A genetic programming approach to designing convolutional neural network architectures

The convolutional neural network (CNN), which is one of the deep learning models, has seen much success in a variety of computer vision tasks. However, designing CNN architectures still requires expert knowledge and a lot of trial and error. In this paper, we attempt to automatically construct CNN architectures for an image classification task based on Cartesian genetic programming (CGP). In our method, we adopt highly functional modules, such as convolutional blocks and tensor concatenation, as the node functions in CGP. The CNN structure and connectivity represented by the CGP encoding method are optimized to maximize the validation accuracy. To evaluate the proposed method, we constructed a CNN architecture for the image classification task with the CIFAR-10 dataset. The experimental result shows that the proposed method can be used to automatically find the competitive CNN architecture compared with state-of-the-art models.

Genetic Image Network for Image Classification

Automatic construction methods for image processing proposed till date approximate adequate image transformation from original images to their target images using a combination of several known image processing filters by evolutionary computation techniques. Genetic Image Network (GIN) is a recent automatic construction method for image processing. The representation of GIN is a network structure. In this paper, we propose a method of automatic construction of image classifiers based on GIN, designated as Genetic Image Network for Image Classification (GIN-IC). The representation of GIN-IC is a feed-forward network structure. GIN-IC transforms original images to easier-to-classify images using image transformation nodes, and selects adequate image features using feature extraction nodes. We apply GIN-IC to test problems involving multi-class categorization of texture images, and show that the use of image transformation nodes is effective for image classification problems.

Evolution of sorting algorithm using graph structured program evolution

In this paper, we apply graph structured program evolution (GRAPE) to evolution of general sorting algorithm. GRAPE is a new Automatic Programming technique. The representation of GRAPE is graph structure, therefore it can express complex programs (e.g. branches and loops) using its graph structure. Each program is constructed as an arbitrary directed graph of nodes and data set. GRAPE handles multiple data types using data set for each type, and the genotype of GRAPE is the form of a linear string of integers. The aim of this work is to evolve a program which correctly sort any sequence of numbers. We demonstrate that GRAPE constructs general sorting algorithm automatically.

Graph structured program evolution with automatically defined nodes

Currently, various automatic programming techniques have been proposed and applied in various fields. Graph Structured Program Evolution (GRAPE) is a recent automatic programming technique with graph structure. This technique can generate complex programs automatically. In this paper, we introduce the concept of automatically defined functions, called automatically defined nodes (ADN), in GRAPE. The proposed GRAPE program has a main program and several subprograms. We verified the effectiveness of ADN through several program evolution experiments, and report the results of evolution of recursive programs using GRAPE modified with ADN.

Automatic construction of image transformation algorithms using feature based genetic image network

Image processing and recognition technologies are becoming increasingly important. Automatic construction methods for image transformation algorithms proposed to date approximate adequate image transformation from original images to their target images using a combination of several known image processing filters by evolutionary computation techniques. In this paper, we introduce the adaptive image processing filters that process according to the features of an input image. The processing of the adaptive filters is decided based on the local features of an input image. We implement them to feed-forward genetic image network (FFGIN) that is one of the automatic construction methods for image transformations. Then we apply our method to the problems of segmentation of organs and tissues in medical images. Experimental results show that our method constructs the effective segmentation algorithms that extract multiple regions respectively.

The effect of metaphoric gestures on schematic understanding of instruction performed by a pedagogical conversational agent

In this paper, we examine the impact of metaphoric gestures performed by Pedagogical Conversational Agent (PCA) on learners’ memorization of technical terms, understanding of relationships between abstract concepts, learning experience, and perception of the PCA. The study employed a one-factor three-level between-participants design where we manipulated gesture factor (speech-gesture match vs. speech-gesture mismatch vs. no-gesture). The data of 97 students were acquired in on-line learning environment. As the results, while there was no effect found on memorization of technical terms, we found that students showed accurate schematic understanding of the relationship between abstract concepts when the PCA used metaphoric gestures matched to speech content than when used gestures mismatched, and no gesture. Contrary to the result, we also found that students judged the PCA useful, helpful, and felt the PCA looked like a teacher when performed mismatched gestures to speech content than when performed matched gesture.

Evolving search spaces to emphasize the performance difference of real-coded crossovers using genetic programming

When we evaluate the search performance of an evolutionary computation (EC) technique, we usually apply it to typical benchmark functions and evaluate its performance in comparison to other techniques. In experiments on limited benchmark functions, it can be difficult to understand the features of each technique. In this paper, the search spaces that emphasize the performance difference of EC techniques are evolved by Cartesian genetic programming. We focus on a real-coded genetic algorithm, which is a type of genetic algorithm that has a real-valued vector as a chromosome. In particular, we generate search spaces using the performance difference of real-coded crossovers. In the experiments, we evolve the search spaces using the combination of three types of real-coded crossovers. As a result of our experiments, the search spaces that exhibit the largest performance difference of two crossovers are generated for all the combinations.

GRAPH STRUCTURED PROGRAM EVOLUTION: EVOLUTION OF LOOP STRUCTURES

Recently, numerous automatic programming techniques have been developed and applied in various fields. A typical example is genetic programming (GP), and various extensions and representations of GP have been proposed thus far. Complex programs and hand-written programs, however, may contain several loops and handle multiple data types. In this chapter, we propose a new method called Graph Structured Program Evolution (GRAPE). The representation of GRAPE is a graph structure; therefore, it can represent branches and loops using this structure. Each programis constructed as an arbitrary directed graph of nodes and a data set. The GRAPE program handles multiple data types using the data set for each type, and the genotype of GRAPE takes the form of a linear string of integers. We apply GRAPE to three test problems, factorial, exponentiation, and list sorting, and demonstrate that the optimum solution in each problem is obtained by the GRAPE system.