#!/usr/bin/python3
# -*- coding: utf-8 -*-
"""
Perceptrón para reconocer imágenes de cifras. 
"""
import httpimport

analizarpixels=False
proporcionajuste=0.7
ocultos=[20,20,20]
nolineal='ReLU'
funcionfinal='Sigmoid'
inicio='inibase'
algoritmo='SGD'
velocidad=0.001
loteajuste=0
iteraciones=30
fallosval=5
control=None
ajusteveloc=1
regularizacion=0
verejemplo=True

####################################
with httpimport.remote_repo('https://personales.unican.es/crespoj/redes/redespytorch.zip'):
    import lecturaurl
    import lectura
    import particion
    import tipored
    import ajuste
    import registro
    import torch
    import numpy
    import error
    import random
    import inicializacion
    from torch import nn
    import activaciones

GPU= torch.cuda.is_available()

datos,datpru=lecturaurl.leemat('mnist_uint8.mat','train_x','train_y','test_x','test_y')

numvarent=len(datos[0])-10
numuestras=len(datos)

#Son 784 píxels: no podemos analizar cada variable pixel por separado, pero podemos usar su distribucion
frel,vals=lectura.grafica(list(range(numvarent)),datos,False)

#Podemos analizar el conjunto de píxels
if analizarpixels:
    pixels=datos[:,:-10][:].reshape((-1,1))
    lectura.estadistica(['pixels'],pixels)

    #o bien un par de variables mapeadas
    lectura.mapa(datos[:,:-10],[numpy.mean,numpy.std])

#los pixels son homógeneos entre sí: no los vamos a preprocesar

"""
Cosas que tienes que definir y probar:

Ratio ajuste/validación
Número de procesadores ocultos
Parámetros del método de ajuste
Criterio de parada por validación
"""

#Son demasiadas variables para hacer estratificación
tea,tsa,tev,tsv=particion.ajazar(datos,numuestras,proporcionajuste)

tep,tsp=lectura.numpytorch(datpru,10)
convol= type(ocultos[0]) is str and 'c' in ocultos[0]
if convol:
        tea=lectura.pasa2d(tea,28)
        tev=lectura.pasa2d(tev,28)
        tep=lectura.pasa2d(tep,28).requires_grad_()
        numvarent=1
    
#definir red
def modula(mod,modulos):
    for n in modulos:
        if mod in dir(n):
            if n is error:
                return error.Errorpropio(mod)
            return getattr(nn,mod)
    return mod
modsactiv=[nn,activaciones]
nolineal=modula(nolineal,modsactiv)
funcionfinal=modula(funcionfinal,modsactiv)
red=tipored.perceptron(numvarent,ocultos,10,nolineal,funcionfinal)
if GPU:
    tea=tea.cuda()
    tsa=tsa.cuda()
    tev=tev.cuda()
    tsv=tsv.cuda()
    tep=tep.cuda()
    tsp=tsp.cuda()
    red=red.cuda()
red(tep)
print(red)
inicializacion.reinicia(red,getattr(inicializacion,inicio))
ajuste.ajustar(red,tea,tsa,tev,tsv,tep,tsp,regiter=registro.clasiter,regfin=registro.clasprueba,algo=getattr(torch.optim,algoritmo),kaj=velocidad,
               numiter=iteraciones,minibatch=loteajuste,decay=regularizacion,
               topeval=fallosval,control=control,funpaso=ajusteveloc)

#Como los resultados son clases discretas, no entramos a los residuos numéricos. Se supone que la matriz de confusión ya nos informa
red.eval()
#Vemos un caso concreto
if verejemplo:
    print('\nEjemplo')
    quien=random.randrange(len(tsp))
    caso=tep[quien].cpu()
    registro.imagen(caso.detach(),'Ejemplo',not convol)
    entrapru=tep[quien]
    entrapru=entrapru.unsqueeze(0)
    dice=red(entrapru)
    print('Red dice',error.clases(dice))

#Las explicaciones se basan en remuestrear. En un espacio de tan alta dimensión lleva mucho tiempo