J'ai essayé d'apprendre l'angle du péché et du cos avec le chainer

introduction

Jusqu'à précédent, je n'ai appris qu'une entrée et une sortie de sin like angle (theta), mais cette fois, j'ai appris seulement 1 entrée et 1 sortie de sin et cos. Je voudrais apprendre 2 entrées et 1 sortie.

environnement

contenu de l'étude

Apprenez l'angle (thêta) à partir de sin et cos (0-2π).

[training data]

Données d'entraînement


def get_dataset(N):
    theta = np.linspace(0, 2 * np.pi, N)
    sin = np.sin(theta)
    cos = np.cos(theta)

    x = np.c_[sin, cos]
    y = theta

    return x, y

la mise en oeuvre

Réglage du nombre d'unités

Étant donné que le nombre d'unités dans la couche d'entrée (in_units) et la couche de sortie (out_units) est défini, la polyvalence est légèrement augmentée par rapport au code précédent.

Apprentissage par lots


class MyChain(Chain):
    def __init__(self, in_units=1, n_units=10, out_units=1):
        super(MyChain, self).__init__(
             l1=L.Linear(in_units, n_units),
             l2=L.Linear(n_units, n_units),
             l3=L.Linear(n_units, out_units))
        self.in_units = in_units
        self.out_units = out_units

Paramètres d'apprentissage

Tous les paramètres sont appropriés.

Code entier

L'ensemble


# -*- coding: utf-8 -*-

#Importer depuis une extrémité pour le moment
import numpy as np
import chainer
from chainer import cuda, Function, gradient_check, Variable, optimizers, serializers, utils
from chainer import Link, Chain, ChainList
import chainer.functions as F
import chainer.links as L
import time
from matplotlib import pyplot as plt

#Les données
def get_dataset(N):
    theta = np.linspace(0, 2 * np.pi, N)
    sin = np.sin(theta)
    cos = np.cos(theta)

    x = np.c_[sin, cos]
    y = theta

    return x, y

#réseau neuronal
class MyChain(Chain):
    def __init__(self, in_units=1, n_units=10, out_units=1):
        super(MyChain, self).__init__(
             l1=L.Linear(in_units, n_units),
             l2=L.Linear(n_units, n_units),
             l3=L.Linear(n_units, out_units))
        self.in_units = in_units
        self.out_units = out_units

    def __call__(self, x_data, y_data):
        x = Variable(x_data.astype(np.float32).reshape(len(x_data),self.in_units)) #Convertir en objet variable
        y = Variable(y_data.astype(np.float32).reshape(len(y_data),self.out_units)) #Convertir en objet variable
        return F.mean_squared_error(self.predict(x), y)

    def  predict(self, x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        h3 = self.l3(h2)
        return h3

    def get_predata(self, x):
        return self.predict(Variable(x.astype(np.float32).reshape(len(x),self.in_units))).data

# main
if __name__ == "__main__":

    #Données d'entraînement
    N = 1000
    x_train, y_train = get_dataset(N)

    #données de test
    N_test = 900
    x_test, y_test = get_dataset(N_test)

    #Paramètres d'apprentissage
    batchsize = 10
    n_epoch = 500
    in_units = 2
    n_units = 100
    out_units = 1

    #La modélisation
    model = MyChain(in_units, n_units, out_units)
    optimizer = optimizers.Adam()
    optimizer.setup(model)

    #Boucle d'apprentissage
    print "start..."
    train_losses =[]
    test_losses =[]
    start_time = time.time()
    for epoch in range(1, n_epoch + 1):

        # training
        perm = np.random.permutation(N)
        sum_loss = 0
        for i in range(0, N, batchsize):
            x_batch = x_train[perm[i:i + batchsize]]
            y_batch = y_train[perm[i:i + batchsize]]
            model.zerograds()
            loss = model(x_batch,y_batch)
            sum_loss += loss.data * batchsize
            loss.backward()
            optimizer.update()

        average_loss = sum_loss / N
        train_losses.append(average_loss)

        # test
        loss = model(x_test, y_test)
        test_losses.append(loss.data)

        #Processus d'apprentissage des extrants
        if epoch % 10 == 0:
            print "epoch: {}/{} train loss: {} test loss: {}".format(epoch, n_epoch, average_loss, loss.data)

    interval = int(time.time() - start_time)
    print "Temps d'exécution(normal): {}sec".format(interval)
    print "end"

    #Graphique d'erreur
    plt.plot(train_losses, label = "train_loss")
    plt.plot(test_losses, label = "test_loss")
    plt.yscale('log')
    plt.legend()
    plt.grid(True)
    plt.title("loss")
    plt.xlabel("epoch")
    plt.ylabel("loss")
    plt.show()

    #Créer un graphique des résultats d'apprentissage
    sin, cos = np.hsplit(x_test ,in_units)
    theta = y_test
    test = model.get_predata(x_test)

    plt.subplot(3, 1, 1)
    plt.plot(theta, sin, "b", label = "sin")
    plt.legend(loc = "upper left")
    plt.grid(True)
    plt.xlim(0, 2 * np.pi)
    plt.ylim(-1.2, 1.2)

    plt.subplot(3, 1, 2)
    plt.plot(theta, cos, "g", label = "cos")
    plt.legend(loc = "upper left")
    plt.grid(True)
    plt.xlim(0, 2 * np.pi)
    plt.ylim(-1.2, 1.2)

    plt.subplot(3, 1, 3)
    plt.plot(theta, theta, "r", label = "theta")
    plt.plot(theta, test, "c", label = "test")
    plt.legend(loc = "upper left")
    plt.grid(True)
    plt.xlim(0, 2 * np.pi)
    plt.ylim(-0.5, 7)

    plt.tight_layout()
    plt.show()

Résultat d'exécution

Erreur

Si le nombre d'époques est de 500, l'erreur est importante. De plus, étant donné que le degré de diminution de l'erreur devient saturé, il est peu probable que l'on puisse s'attendre à une réduction supplémentaire à moins que le nombre d'époques ne soit significativement augmenté.

resolver_simple_loss.png

Résultat d'apprentissage

Étant donné que la sortie est linéaire, elle ne semble pas avoir d'erreur importante.

resolver_simple_test.png

Lorsque l'entrée est multipliée par la porteuse

J'ai également confirmé le cas où les entrées sin et cos ont été multipliées par le transporteur. (3 entrées et 1 sortie avec porteuse) C'est le même principe que le résolveur qui détecte l'angle du moteur.

Données d'entraînement avec transporteur


def get_dataset(N):
    theta = np.linspace(0, 2 * np.pi, N)
    ref = np.sin(40 * theta) #Transporteur
    sin = np.sin(theta) * ref
    cos = np.cos(theta) * ref

    x = np.c_[sin, cos, ref]
    y = theta

    return x, y

# in_Changer les unités en 3

Il peut être confirmé que l'erreur est importante même en apparence car la saisie est compliquée. Les composants harmoniques restent.

resolver_real_test.png

Résumé

Bien que l'erreur soit importante, j'ai pu apprendre l'angle de sin et cos. (2 entrées et 1 sortie) Nous avons également pu apprendre l'angle de la forme d'onde du résolveur multiplié par la porteuse. Cependant, une composante harmonique a été générée. Ce n'était pas un gros problème, alors j'ai pensé que je pourrais apprendre plus précisément, mais j'ai été surpris que l'erreur soit importante. Dans le futur, je veux apprendre des contenus plus compliqués, pour pouvoir penser à l'avenir ...

Recommended Posts

J'ai essayé d'apprendre l'angle du péché et du cos avec le chainer
J'ai essayé d'entraîner la fonction péché avec chainer
J'ai essayé d'implémenter et d'apprendre DCGAN avec PyTorch
J'ai essayé d'approcher la fonction sin en utilisant le chainer
J'ai essayé d'approcher la fonction sin en utilisant chainer (re-challenge)
J'ai essayé d'apprendre le fonctionnement logique avec TF Learn
J'ai essayé d'exprimer de la tristesse et de la joie face au problème du mariage stable.
J'ai essayé de sauvegarder les données avec discorde
765 J'ai essayé d'identifier les trois familles professionnelles par CNN (avec Chainer 2.0.0)
J'ai essayé de contrôler la bande passante et le délai du réseau avec la commande tc
[Introduction à AWS] J'ai essayé de porter une application de conversation et de jouer avec text2speech @ AWS ♪
J'ai essayé de passer le test G et la qualification E en m'entraînant à partir de 50
J'ai essayé de lire et d'enregistrer automatiquement avec VOICEROID2 2
J'ai essayé de détecter l'iris à partir de l'image de la caméra
J'ai essayé de toucher un fichier CSV avec Python
J'ai essayé de résoudre Soma Cube avec python
J'ai essayé de lire et d'enregistrer automatiquement avec VOICEROID2
J'ai essayé de résoudre le problème avec Python Vol.1
J'ai essayé d'implémenter Grad-CAM avec keras et tensorflow
J'ai lu la référence Chainer (mise à jour de temps en temps)
J'ai essayé d'apprendre PredNet
J'ai essayé d'automatiser la mise à jour de l'article du blog Livedoor avec Python et sélénium.
J'ai essayé de comparer la vitesse de traitement avec dplyr de R et pandas de Python
J'ai essayé de prédire et de soumettre les survivants du Titanic avec Kaggle
J'ai essayé de trouver l'entropie de l'image avec python
J'ai essayé de simuler la propagation de l'infection avec Python
J'ai essayé d'analyser les émotions de tout le roman "Weather Child" ☔️
J'ai essayé d'utiliser la bibliothèque Python de Ruby avec PyCall
J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow
J'ai essayé d'illustrer le temps et le temps du langage C
J'ai essayé d'afficher l'heure et la météo d'aujourd'hui w
J'ai essayé d'implémenter ListNet d'apprentissage de rang avec Chainer
J'ai essayé d'énumérer les différences entre java et python
J'ai essayé de créer une interface graphique à trois yeux côte à côte avec Python et Tkinter
J'ai essayé de changer le script python de 2.7.11 à 3.6.0 sur Windows10
J'ai essayé d'obtenir diverses informations de l'API codeforces
J'ai essayé de publier automatiquement sur ChatWork au moment du déploiement avec Fabric et ChatWork Api
J'ai créé un serveur avec socket Python et ssl et j'ai essayé d'y accéder depuis le navigateur
Analyse des émotions avec traitement du langage naturel! J'ai essayé de prédire l'évaluation à partir du texte de l'avis
J'ai aussi essayé d'imiter la fonction monade et la monade d'état avec le générateur en Python
J'ai essayé de résumer les langues que les débutants devraient désormais apprendre par but
J'ai essayé de déplacer le ballon
J'ai essayé d'estimer la section.
Introduction à la création d'IA avec Python! Partie 1 J'ai essayé de classer et de prédire le nombre à partir de l'image du numéro manuscrit
J'ai essayé de décrire le trafic en temps réel avec WebSocket
Répétez avec While. Script pour tweeter ou rechercher depuis le terminal
J'ai essayé d'automatiser l'arrosage du pot avec Raspberry Pi
J'ai essayé de traiter l'image en "style croquis" avec OpenCV
J'ai essayé de faire un processus d'exécution périodique avec Selenium et Python
J'ai essayé de démarrer avec Bitcoin Systre le week-end
J'ai essayé d'envoyer du courrier depuis le serveur Sakura avec flask-mail
J'ai fait apprendre à RNN la vague de péché et j'ai essayé de prédire
J'ai essayé de créer des taureaux et des vaches avec un programme shell
J'ai essayé de traiter l'image dans un "style de dessin au crayon" avec OpenCV
J'ai essayé d'agrandir la taille du volume logique avec LVM
Apprenez les méthodes M-H et HMC en lisant les statistiques bayésiennes à partir des bases
J'ai essayé de couper une image fixe de la vidéo
J'ai essayé de détecter facilement les points de repère du visage avec python et dlib
J'ai essayé d'exécuter la partie DNN d'OpenPose avec le processeur Chainer
J'ai essayé d'extraire des noms de joueurs et de compétences d'articles sportifs