#!/usr/bin/python3

import torch
from torch import nn
import random
import numpy
import tipored
import ajuste
import registro
import activaciones
from torch.nn.utils.rnn import pack_sequence
import analizar
##################
numuestras=
lonmin=
lonmax=
maxnum=
escalasalida=
capocul=
nocul=
numpruebas=
limit=
#################

def prodal(numuestras,maxnum,lonmin,lonmax,escalasalida):
    rango=lonmax-lonmin
    listent=[]
    listsal=[]
    for _ in range(numuestras):
        lon=int(random.random()*rango+lonmin)
        entradas=numpy.array([random.random()*maxnum for num in range(lon)])
        listent.append(torch.tensor(entradas.reshape(-1,1),dtype=torch.float))#.cuda())
        listsal.append(torch.tensor(entradas.prod().reshape(-1,1)/escalasalida,dtype=torch.float))#.cuda())
    return listent,listsal


entradas,salidas=prodal(numuestras,maxnum,lonmin,lonmax,escalasalida)


error=nn.L1 o MSELoss()
red=tipored.Realimoc(1,capocul, nocul,1)
aj=torch.optim....(red.parameters(),lr=...)
for it in range(limit):
    mederr=0
    for ent, sal in zip(entradas,salidas):
        red.zero_grad()
        salred = red(ent)    
        eaj = error(salred, sal)
        eaj.backward()
        aj.step()
        mederr+=eaj.item()
    print(it,mederr/len(ent))

def ponreal(entradas,salidas1,salidas2):
    return entradas,salidas1*escalasalida,salidas2*escalasalida

# Saca algunos resultados de pruebas
entradas,salidas=prodal(numpruebas,maxnum,lonmin,lonmax,escalasalida)

#Analizar la red es retorcido cuando las entradas no son de la misma longitud
    

red.eval()
salr=[]
with torch.no_grad():
    for ent, sal in zip(entradas,salidas):
        salred=red(ent)
        salr.append(salred)
        print("Factores",ent,"Real",sal*escalasalida,"Red",salred*escalasalida)

#Pedimos explicaciones del último. Las derivadas en capas que están realimentadas son complicadas de ver
nombres=[f'Número {i+1}' for i in range(lonmax)]
registro.explicaciones0(nombres,ent.requires_grad_(),ent,red,[numpy.array([1]).T]*lonmax,[numpy.array([0,maxnum])]*lonmax,realizarg=ponreal)
        
#Analizar los residuos
salpruor=torch.vstack(salr)
registro.grafresid(torch.vstack(salidas)*escalasalida,torch.tensor(salpruor.detach())*escalasalida)