Essayez la régression avec TensorFlow

Depuis que TensorFlow est sorti, j'ai essayé d'apprendre autrement que MNIST. Nous allons effectuer une régression pour créer une corrélation. (Ajout) Puisque la sortie de la couche intermédiaire était trop grande pour le nombre de données, la valeur de la couche intermédiaire a été corrigée.

Aperçu

--Les données utilisées sont le diavète

Code source

import sklearn
import tensorflow as tf
from sklearn import datasets
import numpy as np

diabetes = datasets.load_diabetes()

#Charger des données
print "load diabetes data"
data = diabetes["data"].astype(np.float32)
target = diabetes['target'].astype(np.float32).reshape(len(diabetes['target']), 1)
#Divisé en données d'entraînement et données de test
N=342
x_train, x_test = np.vsplit(data, [N])
y_train, y_test = np.vsplit(target, [N])
N_test = y_test.size

x= tf.placeholder("float",shape=[None,10])

#1ère couche Entrée 10 Sortie 256
with tf.name_scope('l1') as scope:
    weightl1 = tf.Variable(tf.truncated_normal([10, 256], stddev=0.1),name="weightl1")
    biasel1 = tf.Variable(tf.constant(1.0, shape=[256]), name="biasel1")
    outputl1=tf.nn.relu(tf.matmul(x,weightl1) + biasel1)

#2e couche entrée 256 sortie 1
with tf.name_scope('l2') as scope:
    weightl2 = tf.Variable(tf.truncated_normal([256, 1], stddev=0.1),name="weightl2")
    biasel2 = tf.Variable(tf.constant(1.0, shape=[1]), name="biasel2")
    outputl2=tf.nn.relu(tf.matmul(outputl1,weightl2) + biasel2)


    
"""
Fonction de calcul d'erreur
Calculer l'erreur avec MSE
"""
def loss(output):
    with tf.name_scope('loss') as scope:
        loss = tf.reduce_mean(tf.square(output - y_train))
    return loss


loss_op = loss(outputl2)
optimizer = tf.train.AdagradOptimizer(0.04)
train_step = optimizer.minimize(loss_op)

#Erreur d'enregistrement
best = float("inf")

#Initialisation
init_op = tf.initialize_all_variables()

with tf.Session() as sess:
    #init
    sess.run(init_op)
    for i in range(20001):
        loss_train = sess.run(loss_op, feed_dict={x:x_train})
        sess.run(train_step, feed_dict={x:x_train})
        if loss_train < best:
            best = loss_train
            best_match = sess.run(outputl2, feed_dict={x:x_test})
        if i %1000 == 0:
            print "step {}".format(i)
            pearson = np.corrcoef(best_match.flatten(), y_test.flatten())
            print 'train loss = {} ,test corrcoef={}'.format(best,pearson[0][1])
               

résultat

load diabetes data
step 0
train loss = 29000.1777344 ,test corrcoef=0.169487254139
step 1000
train loss = 3080.2097168 ,test corrcoef=0.717823972634
step 2000
train loss = 2969.1887207 ,test corrcoef=0.72972180486
step 3000
train loss = 2938.4609375 ,test corrcoef=0.73486349373
step 4000
train loss = 2915.63330078 ,test corrcoef=0.737497869454
step 5000
train loss = 2896.14331055 ,test corrcoef=0.739029181368
step 6000
train loss = 2875.51708984 ,test corrcoef=0.74006814362
step 7000
train loss = 2856.36816406 ,test corrcoef=0.741115477047
step 8000
train loss = 2838.77026367 ,test corrcoef=0.742113966068
step 9000
train loss = 2822.453125 ,test corrcoef=0.743066699589
step 10000
train loss = 2807.88916016 ,test corrcoef=0.743988699821
step 11000
train loss = 2795.09057617 ,test corrcoef=0.744917437376
step 12000
train loss = 2783.8828125 ,test corrcoef=0.745871358086
step 13000
train loss = 2773.68457031 ,test corrcoef=0.747112534114
step 14000
train loss = 2764.80224609 ,test corrcoef=0.748115829411
step 15000
train loss = 2756.6628418 ,test corrcoef=0.748800330555
step 16000
train loss = 2749.1340332 ,test corrcoef=0.749471871992
step 17000
train loss = 2741.78881836 ,test corrcoef=0.750184567587
step 18000
train loss = 2734.56054688 ,test corrcoef=0.750722087518
step 19000
train loss = 2727.18579102 ,test corrcoef=0.751146409281
step 20000
train loss = 2719.29101562 ,test corrcoef=0.751330770654

problème

--Pour une raison quelconque, parfois corrcoef = nan (sous enquête). --outputl2 est tout 0. -> Il y a peut-être un problème d'explosion de gradient.

Il semble que vous puissiez le définir assez librement. Il semble qu'il faudra du temps pour le maîtriser.

Recommended Posts

Essayez la régression avec TensorFlow
Essayez l'apprentissage en profondeur avec TensorFlow
Essayez TensorFlow MNIST avec RNN
Essayez l'apprentissage en profondeur avec TensorFlow Partie 2
Essayez les données en parallèle avec TensorFlow distribué
Essayez Distributed Tensor Flow
Zundokokiyoshi avec TensorFlow
Casser des blocs avec Tensorflow
Essayez TensorFlow RNN avec un modèle de base
Essayez de gratter avec Python.
Régression linéaire avec statsmodels
Essayez Tensorflow avec une instance GPU sur AWS
Prévisions de courses de bateaux avec TensorFlow
Essayez SNN avec BindsNET
Régression avec un modèle linéaire
Effectuer une analyse de régression avec NumPy
Régression du noyau avec Numpy uniquement
Traduire Premiers pas avec TensorFlow
Essayez de défier le sol par récursif
Utiliser TensorFlow avec Intellij IDEA
Essayez d'utiliser PythonTex avec Texpad.
Essayez d'implémenter RBM avec chainer.
Analyse de régression multiple avec Keras
Essayez Google Mock avec C
Fonction sinueuse approximative avec TensorFlow
Essayez d'utiliser matplotlib avec PyCharm
Essayez de programmer avec un shell!
Essayez la programmation GUI avec Hy
Essayez Auto Encoder avec Pytorch
Essayez la sortie Python avec Haxe 3.2
Essayez l'opération matricielle avec NumPy
Ridge retour avec Mllib à Pyspark
Essayez d'implémenter XOR avec PyTorch
Essayez différentes choses avec PhantomJS
Essayez le Deep Learning avec FPGA
Prévision du cours de l'action avec tensorflow
Essayez d'exécuter Python avec Try Jupyter
Essayez d'implémenter le parfum avec Go
Essayez Selenium Grid avec Docker
Essayez OpenCV avec Google Colaboratory
Essayez le machine learning à la légère avec Kaggle
Essayez de créer Jupyter Hub avec Docker
Essayez d'utiliser le folium avec anaconda
Implémentation de la régression logistique avec NumPy
Régression linéaire robuste avec scikit-learn
Essayez d'implémenter la régression linéaire à l'aide de Pytorch avec Google Colaboratory
[Statistiques] [R] Essayez d'utiliser la régression par points de division.
Assurer la reproductibilité avec tf.keras dans Tensorflow 2.3
Essayez le Deep Learning avec les concombres FPGA-Select
Essayez de gratter avec Python + Beautiful Soup
Renforcer l'apprentissage 13 Essayez Mountain_car avec ChainerRL.
Essayez la visualisation d'incorporation ajoutée dans TensorFlow 0.12
Personnaliser le modèle / la couche / la métrique avec TensorFlow
Affichage des inférences et des résultats avec Tensorflow + matplotlib
Classifier "Wine" avec le code MLP TensorFlow
Essayez d'exploiter Facebook avec Python
[TensorFlow 2] Apprendre RNN avec perte CTC
Essayez la décomposition de valeurs singulières avec Python
Les débutants en apprentissage automatique essaient la régression linéaire