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

import httpimport

analizarpixels=False
#
proporcionajuste=0.7
propvalid=0.15
estimacion='bootstrap'
numpruebas=1
todofinal='mean'
#
ocultos=['5c9','r4',['x',['c5','c3'],['c3'],['c3'],['c7'],['c5']],'r2',['i',['5c3'],['5c5']],'5c11','r4','b']
nolineal='LeakyReLU'
funcionfinal='Tanh'
#
inicio='inibase'
algoritmo='Adam'
funerror='SmoothL1'
velocidad=0.0001
loteajuste=10
iteraciones=10
fallosval=5
control=None
ajusteveloc=1
regularizacion=0
#
analizaresiduos=True
#
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
    from matplotlib import pyplot
    import error
    import random
    from torch import nn
    import activaciones
    import inicializacion
    import math
    import statistics

GPU= torch.cuda.is_available()

te,ts=lecturaurl.leetorch('profundas3/datos30.bin')
numuestras,canales,ancho,alto=te.shape


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

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

    #o bien un par de variables mapeadas
    lectura.mapa(te.squeeze(1),[torch.mean,torch.std],False)
#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
convol= type(ocultos[0]) is str and 'c' in ocultos[0]
if convol:
        numvarent=canales
else:
    te=lectura.pasa1d(te)
    numvarent=canales*ancho*alto

#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,1,nolineal,funcionfinal)
#).cuda(device)

if GPU:
    te=te.cuda()
    ts=ts.cuda()
    red=red.cuda()
if estimacion =='bootstrap':
    #Partición para bootstrap
    gener,tep,tsp=particion.genclaseremuest(te,ts,proporcionajuste+propvalid)
if estimacion=='cruzada':
    #Partición para validación cruzada
    gener=iter(particion.DatosVC(te,ts,numpruebas))

red(te)
print(red)

presens={'MSE':math.sqrt,'L1':abs,'SmoothL1':abs}
def module(mod):
    global presenerror
    if mod+'Loss' in dir(nn):
        m= getattr(nn,mod+'Loss')()
        presenerror=presens[mod]
        return m
    if mod in dir(error):
            m=error.ErrorPropio(mod)
            presenerror=m.presen
            return m
    return m()
ferr=module(funerror)
errorps=[]
erroras=[]
diferror=[]
errmin=1000
for _ in range(numpruebas):
    if estimacion in ['particion','partición']:
    #Conjuntos de ajuste, validación y muestra. Parte al azar y parte por agrupamiento
        tea,tsa,tev,tsv,tep,tsp=particion.torchazar(te,ts,proporcionajuste,propvalid)
    else:
        if estimacion=='bootstrap':
                teav,tsav=next(iter(gener))
        if estimacion=='cruzada':
            tep,tsp,teav,tsav=next(gener)
        tea,tsa,tev,tsv,_,_=particion.torchazar(teav.detach(),tsav.detach(),proporcionajuste/(proporcionajuste+propvalid),propvalid/(proporcionajuste+propvalid))
    inicializacion.reinicia(red,getattr(inicializacion,inicio))
    err,red,erraj=ajuste.ajustar(red,tea.requires_grad_(),tsa,tev,tsv,tep,tsp,kaj=velocidad,error=ferr,algo=getattr(torch.optim,algoritmo),control=control,
                                 numiter=iteraciones,funpaso=ajusteveloc,muestraerror=presenerror,topeval=fallosval,decay=regularizacion,minibatch=loteajuste) 
    errorps.append(err.item())
    erroras.append(erraj)
    diferror.append(err.item()-erraj)
    if err.item()<errmin:
        errmin=err.item()
        registro.guardared(red,'tempytorch')

red=registro.cogered('tempytorch')
if numpruebas>1:
    pyplot.hist(errorps)
    pyplot.show()

if todofinal is not None:
    finaj=getattr(statistics,todofinal)(erroras)
    inicializacion.reinicia(red,getattr(inicializacion,inicio))
    red,erraj=ajuste.ajustar(red,te.requires_grad_(),ts,None,None,None,None,kaj=velocidad,error=ferr,algo=getattr(torch.optim,algoritmo),control=control,
                                 numiter=iteraciones,funpaso=ajusteveloc,muestraerror=presenerror,limerr=finaj,decay=regularizacion,minibatch=loteajuste)
    print('Estimación de error de generalizacion',erraj+getattr(statistics,todofinal)(diferror))


red.eval()
if analizaresiduos:
    registro.residuos(te.cpu().detach(),ts.cpu().detach(),red.cpu())

#Vemos un caso concreto
if verejemplo:
    print('\nEjemplo')
    quien=random.randrange(len(ts))
    caso=te[quien].cpu().detach()
    if convol:
        registro.imagen(caso,'Ejemplo')
    else:
        registro.imagen(caso,'Ejemplo',(ancho,alto))
    dice=red(te.cpu()[quien:quien+1])
    print('Red dice',dice)
    print('En teoría es',ts[quien])

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