import tensorflow as tf
import numpy as np
import random
import matplotlib.pyplot as plt
import time

def create_dataset(n_points, larghezza, altezza):

    '''
    funzione per creare un insieme di punti entro un limite di altezza e larghezza.
    Assieme ai punti vengono creati anche i risultati esatti per allenare la rete neurale

    1 se il punto appartiene o si trova al di sopra della retta y=x, altrimenti 0
    '''

    points = []
    labels = []

    random.seed(time.time())

    for i in range(n_points):
        xp = random.uniform(0, larghezza)
        yp = random.uniform(0, altezza)
        points.append([xp,yp])

        label = 1 if yp>=xp else 0
        labels.append([label])

    return np.array(points,dtype=np.float32), np.array(labels,dtype=np.float32)

#dati per l'allenamento
points, labels = create_dataset(50, 100, 100)
#dati per la verifica
x_test, y_test = create_dataset(50, 500, 500)

#segnaposti per i dati
x = tf.placeholder(tf.float32, shape=[None, 2])
y = tf.placeholder(tf.float32, shape=[None, 1])

def neural_network_model(data):

    '''
    funzione che definisce una rete neurale con 2 livelli intermedi e uno di output
    '''

    pesi1 = tf.Variable(tf.random_normal([2, 64]), name="pesi_livello_1")
    pesi2 = tf.Variable(tf.random_normal([64, 64]), name="pesi_livello_2")
    pesi_output = tf.Variable(tf.random_normal([64, 1]), name="pesi_livello_output")

    layer1 = tf.matmul(data, pesi1)  #input * pesi_livello_1
    layer1 = tf.nn.sigmoid(layer1)  #funzione di attivazione livello 1

    layer2 = tf.matmul(layer1, pesi2)  #output_livello_1 * pesi_livello_2
    layer2 = tf.nn.sigmoid(layer2)  #funzione di attivazione livello 1

    output = tf.matmul(layer2, pesi_output)

    return output

def allena_rete_neurale(x):

    #la rete neurale calcola l'output
    previsione = neural_network_model(x)
    #calcolo l'errore tra l'output esatto e quello calcolato dalla rete neurale
    errore = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = previsione, labels = y, name="calcola_errore"), name="errore")

    #ottimizzatore per minimizzare l'errore
    ottimizzatore = tf.train.AdamOptimizer().minimize(errore)

    #numero di volte da ripetere l'allenamento
    epoche = 5

    #crea una sessione necessaria per interfacciare il programma in python con tensorflow(C++)
    with tf.Session() as sess:

        writer = tf.summary.FileWriter("./", sess.graph)

        #inizializza tutte le variabili
        sess.run(tf.global_variables_initializer())

        for e in range(epoche):
            #errore di ogni epoca
            errore_epoca = 0

            #allena la rete con 50 punti alla volta
            i = 0
            while i < len(points):
                #punti
                data_x = points[i:i+50]
                #output esatto
                data_y = labels[i:i+50]
                #allena la rete con l'ottimizzatore e l'errore
                _, err = sess.run([ottimizzatore, errore], feed_dict={x:data_x, y:data_y})
                #somma l'errore all'errore dell'epoca
                errore_epoca += err
                i+=50

            print('Epoca', e, '\\',epoche,'  errore:',errore_epoca)

        #calcola la correttezza e la precisione della rete neurale con dati non usati nell'allenamento
        correttezza = tf.equal(tf.argmax(previsione, 1), tf.argmax(y, 1))

        precisione = tf.reduce_mean(tf.cast(correttezza, 'float'))
        print('Precisione:',precisione.eval({x:x_test, y:y_test}) * 100, '%')

        writer.close()

allena_rete_neurale(x)

prediction = 0 #??????

p = []
p.append(float(input("\nInserisici la coordinata X del punto:\n")))
p.append(float(input("\nInserisici la coordinata Y del punto:\n")))

txt = "Sotto" if prediction == 0 else "Sopra"
plt.scatter(p[0],p[1])
plt.annotate(txt, (p[0],p[1]))
plt.plot(range(0,100), range(0,100), color="green")
plt.show()