[PYTHON] Simple neural network implementation using Chainer

Until the last time, I wrote about the basic objects that make up Chainer. From this time, I would like to actually implement a neural network using those objects.

Overall view of neural network

When writing a program that composes a neural network, the overall view is roughly composed of the following five.

1. Data preparation

It is a program that prepares data for training the model. There are various types of data such as sentences, images, and voices, but we process them into the form of data suitable for the neural network to be constructed.

2. Model description

Describe a class that inherits the Chain class. For details, refer to here.

class MyChain(Chain):
    def __init__(self):
        super(MyChain, self).__init__(
Declaration of a function containing parameters
        )
    def __call__(self, x, y):
Loss (error) function

3. Optimization algorithm settings (SDG, Adam, etc.)

Describes the process of optimizing the model (minimizing the error). For more information, see here

model = MyChain()
optimizer = optimizer.Adam()
optimizer.setup(model)

4. Learning

Learning is performed a specified number of times. Depending on the item, early termination may be performed, but this time we will simply specify epoch (number of learnings). It seems that the code is almost promised from gradient initialization to parameter update.

for epoch in range(Number of repetitions):
    model.zerograds()           #Gradient initialization
    loss = model(train, target) #Error calculation
    loss.backward()             #Gradient calculation
    optimizer.update()          #Parameter update

5. Result output

Save the model of the training result and perform the test.

Direction from the next time

I don't want to stuff this information into one article, so from the next time

1. Data preparation
2. Model description
3. Optimization algorithm settings
4. Learning
5. Result output

I will write about it in small parts. Up to here for this time

reference

Takayoshi Yamashita Deep learning Kodansha that can be seen in the illustration Hiroyuki Shinno Practical deep learning with Chainer-How to implement complex NN-Ohmsha