@scrypted/libav 1.0.170 → 1.0.171

package/opus/dnn/torch/lossgen/lossgen.py

@@ -1,29 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-class LossGen(nn.Module):
-    def __init__(self, gru1_size=16, gru2_size=16):
-        super(LossGen, self).__init__()
-
-        self.gru1_size = gru1_size
-        self.gru2_size = gru2_size
-        self.dense_in = nn.Linear(2, 8)
-        self.gru1 = nn.GRU(8, self.gru1_size, batch_first=True)
-        self.gru2 = nn.GRU(self.gru1_size, self.gru2_size, batch_first=True)
-        self.dense_out = nn.Linear(self.gru2_size, 1)
-
-    def forward(self, loss, perc, states=None):
-        #print(states)
-        device = loss.device
-        batch_size = loss.size(0)
-        if states is None:
-            gru1_state = torch.zeros((1, batch_size, self.gru1_size), device=device)
-            gru2_state = torch.zeros((1, batch_size, self.gru2_size), device=device)
-        else:
-            gru1_state = states[0]
-            gru2_state = states[1]
-        x = torch.tanh(self.dense_in(torch.cat([loss, perc], dim=-1)))
-        gru1_out, gru1_state = self.gru1(x, gru1_state)
-        gru2_out, gru2_state = self.gru2(gru1_out, gru2_state)
-        return self.dense_out(gru2_out), [gru1_state, gru2_state]

package/opus/dnn/torch/lossgen/process_data.sh

@@ -1,17 +0,0 @@
-#!/bin/sh
-
-#directory containing the loss files
-datadir=$1
-
-for i in $datadir/*_is_lost.txt
-do
-	perc=`cat $i | awk '{a+=$1}END{print a/NR}'`
-	echo $perc $i
-done > percentage_list.txt
-
-sort -n percentage_list.txt | awk '{print $2}' > percentage_sorted.txt
-
-for i in `cat percentage_sorted.txt`
-do
-	cat $i
-done > loss_sorted.txt

package/opus/dnn/torch/lossgen/test_lossgen.py

@@ -1,42 +0,0 @@
-import lossgen
-import os
-import argparse
-import torch
-import numpy as np
-
-
-parser = argparse.ArgumentParser()
-
-parser.add_argument('model', type=str, help='CELPNet model')
-parser.add_argument('percentage', type=float, help='percentage loss')
-parser.add_argument('output', type=str, help='path to output file (ascii)')
-
-parser.add_argument('--length', type=int, help="length of sequence to generate", default=500)
-
-args = parser.parse_args()
-
-
-
-checkpoint = torch.load(args.model, map_location='cpu')
-model = lossgen.LossGen(*checkpoint['model_args'], **checkpoint['model_kwargs'])
-model.load_state_dict(checkpoint['state_dict'], strict=False)
-
-states=None
-last = torch.zeros((1,1,1))
-perc = torch.tensor((args.percentage,))[None,None,:]
-seq = torch.zeros((0,1,1))
-
-one = torch.ones((1,1,1))
-zero = torch.zeros((1,1,1))
-
-if __name__ == '__main__':
-    for i in range(args.length):
-        prob, states = model(last, perc, states=states)
-        prob = torch.sigmoid(prob)
-        states[0] = states[0].detach()
-        states[1] = states[1].detach()
-        loss = one if np.random.rand() < prob else zero
-        last = loss
-        seq = torch.cat([seq, loss])
-
-np.savetxt(args.output, seq[:,:,0].numpy().astype('int'), fmt='%d')

package/opus/dnn/torch/lossgen/train_lossgen.py

@@ -1,99 +0,0 @@
-import numpy as np
-import torch
-from torch import nn
-import torch.nn.functional as F
-import tqdm
-from scipy.signal import lfilter
-import os
-import lossgen
-
-class LossDataset(torch.utils.data.Dataset):
-    def __init__(self,
-                loss_file,
-                sequence_length=997):
-
-        self.sequence_length = sequence_length
-
-        self.loss = np.loadtxt(loss_file, dtype='float32')
-
-        self.nb_sequences = self.loss.shape[0]//self.sequence_length
-        self.loss = self.loss[:self.nb_sequences*self.sequence_length]
-        self.perc = lfilter(np.array([.001], dtype='float32'), np.array([1., -.999], dtype='float32'), self.loss)
-
-        self.loss = np.reshape(self.loss, (self.nb_sequences, self.sequence_length, 1))
-        self.perc = np.reshape(self.perc, (self.nb_sequences, self.sequence_length, 1))
-
-    def __len__(self):
-        return self.nb_sequences
-
-    def __getitem__(self, index):
-        r0 = np.random.normal(scale=.1, size=(1,1)).astype('float32')
-        r1 = np.random.normal(scale=.1, size=(self.sequence_length,1)).astype('float32')
-        perc = self.perc[index, :, :]
-        perc = perc + (r0+r1)*perc*(1-perc)
-        return [self.loss[index, :, :], perc]
-
-
-adam_betas = [0.8, 0.98]
-adam_eps = 1e-8
-batch_size=256
-lr_decay = 0.001
-lr = 0.003
-epsilon = 1e-5
-epochs = 2000
-checkpoint_dir='checkpoint'
-os.makedirs(checkpoint_dir, exist_ok=True)
-checkpoint = dict()
-
-device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
-
-checkpoint['model_args']    = ()
-checkpoint['model_kwargs']  = {'gru1_size': 16, 'gru2_size': 32}
-model = lossgen.LossGen(*checkpoint['model_args'], **checkpoint['model_kwargs'])
-dataset = LossDataset('loss_sorted.txt')
-dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, drop_last=True, num_workers=4)
-
-
-optimizer = torch.optim.AdamW(model.parameters(), lr=lr, betas=adam_betas, eps=adam_eps)
-
-
-# learning rate scheduler
-scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer=optimizer, lr_lambda=lambda x : 1 / (1 + lr_decay * x))
-
-
-if __name__ == '__main__':
-    model.to(device)
-    states = None
-    for epoch in range(1, epochs + 1):
-
-        running_loss = 0
-
-        print(f"training epoch {epoch}...")
-        with tqdm.tqdm(dataloader, unit='batch') as tepoch:
-            for i, (loss, perc) in enumerate(tepoch):
-                optimizer.zero_grad()
-                loss = loss.to(device)
-                perc = perc.to(device)
-
-                out, states = model(loss, perc, states=states)
-                states = [state.detach() for state in states]
-                out = torch.sigmoid(out[:,:-1,:])
-                target = loss[:,1:,:]
-
-                loss = torch.mean(-target*torch.log(out+epsilon) - (1-target)*torch.log(1-out+epsilon))
-
-                loss.backward()
-                optimizer.step()
-
-                scheduler.step()
-
-                running_loss += loss.detach().cpu().item()
-                tepoch.set_postfix(loss=f"{running_loss/(i+1):8.5f}",
-                                   )
-
-        # save checkpoint
-        checkpoint_path = os.path.join(checkpoint_dir, f'lossgen_{epoch}.pth')
-        checkpoint['state_dict'] = model.state_dict()
-        checkpoint['loss'] = running_loss / len(dataloader)
-        checkpoint['epoch'] = epoch
-        torch.save(checkpoint, checkpoint_path)

package/opus/dnn/torch/lpcnet/README.md

@@ -1,27 +0,0 @@
-# LPCNet
-
-Incomplete pytorch implementation of LPCNet
-
-## Data preparation
-For data preparation use dump_data in github.com/xiph/LPCNet. To turn this into
-a training dataset, copy data and feature file to a folder and run
-
-python add_dataset_config.py my_dataset_folder
-
-
-## Training
-To train a model, create and adjust a setup file, e.g. with
-
-python make_default_setup.py my_setup.yml --path2dataset my_dataset_folder
-
-Then simply run
-
-python train_lpcnet.py my_setup.yml my_output
-
-## Inference
-Create feature file with dump_data from github.com/xiph/LPCNet. Then run e.g.
-
-python test_lpcnet.py features.f32 my_output/checkpoints/checkpoint_ep_10.pth out.wav
-
-Inference runs on CPU and takes usually between 3 and 20 seconds per generated second of audio,
-depending on the CPU.

package/opus/dnn/torch/lpcnet/add_dataset_config.py

@@ -1,77 +0,0 @@
-"""
-/* Copyright (c) 2023 Amazon
-   Written by Jan Buethe */
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-"""
-
-import argparse
-import os
-
-import yaml
-
-
-from utils.templates import dataset_template_v1, dataset_template_v2
-
-
-
-
-parser = argparse.ArgumentParser("add_dataset_config.py")
-
-parser.add_argument('path', type=str, help='path to folder containing feature and data file')
-parser.add_argument('--version', type=int, help="dataset version, 1 for classic LPCNet with 55 feature slots, 2 for new format with 36 feature slots.", default=2)
-parser.add_argument('--description', type=str, help='brief dataset description', default="I will add a description later")
-args = parser.parse_args()
-
-
-if args.version == 1:
-    template = dataset_template_v1
-    data_extension = '.u8'
-elif args.version == 2:
-    template = dataset_template_v2
-    data_extension = '.s16'
-else:
-    raise ValueError(f"unknown dataset version {args.version}")
-
-# get folder content
-content = os.listdir(args.path)
-
-features = [c for c in content if c.endswith('.f32')]
-
-if len(features) != 1:
-    print("could not determine feature file")
-else:
-    template['feature_file'] = features[0]
-
-data = [c for c in content if c.endswith(data_extension)]
-if len(data) != 1:
-    print("could not determine data file")
-else:
-    template['signal_file'] = data[0]
-
-template['description'] = args.description
-
-with open(os.path.join(args.path, 'info.yml'), 'w') as f:
-    yaml.dump(template, f)

package/opus/dnn/torch/lpcnet/data/__init__.py

@@ -1 +0,0 @@
-from .lpcnet_dataset import LPCNetDataset

package/opus/dnn/torch/lpcnet/data/lpcnet_dataset.py

@@ -1,227 +0,0 @@
-"""
-/* Copyright (c) 2023 Amazon
-   Written by Jan Buethe */
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-"""
-
-""" Dataset for LPCNet training """
-import os
-
-import yaml
-import torch
-import numpy as np
-from torch.utils.data import Dataset
-
-
-scale = 255.0/32768.0
-scale_1 = 32768.0/255.0
-def ulaw2lin(u):
-    u = u - 128
-    s = np.sign(u)
-    u = np.abs(u)
-    return s*scale_1*(np.exp(u/128.*np.log(256))-1)
-
-
-def lin2ulaw(x):
-    s = np.sign(x)
-    x = np.abs(x)
-    u = (s*(128*np.log(1+scale*x)/np.log(256)))
-    u = np.clip(128 + np.round(u), 0, 255)
-    return u
-
-
-def run_lpc(signal, lpcs, frame_length=160):
-    num_frames, lpc_order = lpcs.shape
-
-    prediction = np.concatenate(
-        [- np.convolve(signal[i * frame_length : (i + 1) * frame_length + lpc_order - 1], lpcs[i], mode='valid') for i in range(num_frames)]
-    )
-    error = signal[lpc_order :] - prediction
-
-    return prediction, error
-
-class LPCNetDataset(Dataset):
-    def __init__(self,
-                 path_to_dataset,
-                 features=['cepstrum', 'periods', 'pitch_corr'],
-                 input_signals=['last_signal', 'prediction', 'last_error'],
-                 target='error',
-                 frames_per_sample=15,
-                 feature_history=2,
-                 feature_lookahead=2,
-                 lpc_gamma=1):
-
-        super(LPCNetDataset, self).__init__()
-
-        # load dataset info
-        self.path_to_dataset = path_to_dataset
-        with open(os.path.join(path_to_dataset, 'info.yml'), 'r') as f:
-            dataset = yaml.load(f, yaml.FullLoader)
-
-        # dataset version
-        self.version = dataset['version']
-        if self.version == 1:
-            self.getitem = self.getitem_v1
-        elif self.version == 2:
-            self.getitem = self.getitem_v2
-        else:
-            raise ValueError(f"dataset version {self.version} unknown")
-
-        # features
-        self.feature_history      = feature_history
-        self.feature_lookahead    = feature_lookahead
-        self.frame_offset         = 1 + self.feature_history
-        self.frames_per_sample    = frames_per_sample
-        self.input_features       = features
-        self.feature_frame_layout = dataset['feature_frame_layout']
-        self.lpc_gamma            = lpc_gamma
-
-        # load feature file
-        self.feature_file = os.path.join(path_to_dataset, dataset['feature_file'])
-        self.features = np.memmap(self.feature_file, dtype=dataset['feature_dtype'])
-        self.feature_frame_length = dataset['feature_frame_length']
-
-        assert len(self.features) % self.feature_frame_length == 0
-        self.features = self.features.reshape((-1, self.feature_frame_length))
-
-        # derive number of samples is dataset
-        self.dataset_length = (len(self.features) - self.frame_offset - self.feature_lookahead - 1) // self.frames_per_sample
-
-        # signals
-        self.frame_length               = dataset['frame_length']
-        self.signal_frame_layout        = dataset['signal_frame_layout']
-        self.input_signals              = input_signals
-        self.target                     = target
-
-        # load signals
-        self.signal_file  = os.path.join(path_to_dataset, dataset['signal_file'])
-        self.signals  = np.memmap(self.signal_file, dtype=dataset['signal_dtype'])
-        self.signal_frame_length  = dataset['signal_frame_length']
-        self.signals = self.signals.reshape((-1, self.signal_frame_length))
-        assert len(self.signals) == len(self.features) * self.frame_length
-
-    def __getitem__(self, index):
-        return self.getitem(index)
-
-    def getitem_v2(self, index):
-        sample = dict()
-
-        # extract features
-        frame_start = self.frame_offset + index       * self.frames_per_sample - self.feature_history
-        frame_stop  = self.frame_offset + (index + 1) * self.frames_per_sample + self.feature_lookahead
-
-        for feature in self.input_features:
-            feature_start, feature_stop = self.feature_frame_layout[feature]
-            sample[feature] = self.features[frame_start : frame_stop, feature_start : feature_stop]
-
-        # convert periods
-        if 'periods' in self.input_features:
-            sample['periods'] = (0.1 + 50 * sample['periods'] + 100).astype('int16')
-
-        signal_start = (self.frame_offset + index       * self.frames_per_sample) * self.frame_length
-        signal_stop  = (self.frame_offset + (index + 1) * self.frames_per_sample) * self.frame_length
-
-        # last_signal and signal are always expected to be there
-        sample['last_signal'] = self.signals[signal_start : signal_stop, self.signal_frame_layout['last_signal']]
-        sample['signal'] = self.signals[signal_start : signal_stop, self.signal_frame_layout['signal']]
-
-        # calculate prediction and error if lpc coefficients present and prediction not given
-        if 'lpc' in self.feature_frame_layout and 'prediction' not in self.signal_frame_layout:
-            # lpc coefficients with one frame lookahead
-            # frame positions (start one frame early for past excitation)
-            frame_start = self.frame_offset + self.frames_per_sample * index - 1
-            frame_stop  = self.frame_offset + self.frames_per_sample * (index + 1)
-
-            # feature positions
-            lpc_start, lpc_stop = self.feature_frame_layout['lpc']
-            lpc_order = lpc_stop - lpc_start
-            lpcs = self.features[frame_start : frame_stop, lpc_start : lpc_stop]
-
-            # LPC weighting
-            lpc_order = lpc_stop - lpc_start
-            weights = np.array([self.lpc_gamma ** (i + 1) for i in range(lpc_order)])
-            lpcs = lpcs * weights
-
-            # signal position (lpc_order samples as history)
-            signal_start = frame_start * self.frame_length - lpc_order + 1
-            signal_stop  = frame_stop  * self.frame_length + 1
-            noisy_signal = self.signals[signal_start : signal_stop, self.signal_frame_layout['last_signal']]
-            clean_signal = self.signals[signal_start - 1 : signal_stop - 1, self.signal_frame_layout['signal']]
-
-            noisy_prediction, noisy_error = run_lpc(noisy_signal, lpcs, frame_length=self.frame_length)
-
-            # extract signals
-            offset = self.frame_length
-            sample['prediction'] = noisy_prediction[offset : offset + self.frame_length * self.frames_per_sample]
-            sample['last_error'] = noisy_error[offset - 1 : offset - 1 + self.frame_length * self.frames_per_sample]
-            # calculate error between real signal and noisy prediction
-
-
-            sample['error'] = sample['signal'] - sample['prediction']
-
-
-        # concatenate features
-        feature_keys = [key for key in self.input_features if not key.startswith("periods")]
-        features = torch.concat([torch.FloatTensor(sample[key]) for key in feature_keys], dim=-1)
-        signals = torch.cat([torch.LongTensor(lin2ulaw(sample[key])).unsqueeze(-1) for key in self.input_signals], dim=-1)
-        target  = torch.LongTensor(lin2ulaw(sample[self.target]))
-        periods = torch.LongTensor(sample['periods'])
-
-        return {'features' : features, 'periods' : periods, 'signals' : signals, 'target' : target}
-
-    def getitem_v1(self, index):
-        sample = dict()
-
-        # extract features
-        frame_start = self.frame_offset + index       * self.frames_per_sample - self.feature_history
-        frame_stop  = self.frame_offset + (index + 1) * self.frames_per_sample + self.feature_lookahead
-
-        for feature in self.input_features:
-            feature_start, feature_stop = self.feature_frame_layout[feature]
-            sample[feature] = self.features[frame_start : frame_stop, feature_start : feature_stop]
-
-        # convert periods
-        if 'periods' in self.input_features:
-            sample['periods'] = (0.1 + 50 * sample['periods'] + 100).astype('int16')
-
-        signal_start = (self.frame_offset + index       * self.frames_per_sample) * self.frame_length
-        signal_stop  = (self.frame_offset + (index + 1) * self.frames_per_sample) * self.frame_length
-
-        # last_signal and signal are always expected to be there
-        for signal_name, index in self.signal_frame_layout.items():
-            sample[signal_name] = self.signals[signal_start : signal_stop, index]
-
-        # concatenate features
-        feature_keys = [key for key in self.input_features if not key.startswith("periods")]
-        features = torch.concat([torch.FloatTensor(sample[key]) for key in feature_keys], dim=-1)
-        signals = torch.cat([torch.LongTensor(sample[key]).unsqueeze(-1) for key in self.input_signals], dim=-1)
-        target  = torch.LongTensor(sample[self.target])
-        periods = torch.LongTensor(sample['periods'])
-
-        return {'features' : features, 'periods' : periods, 'signals' : signals, 'target' : target}
-
-    def __len__(self):
-        return self.dataset_length

package/opus/dnn/torch/lpcnet/engine/lpcnet_engine.py

@@ -1,141 +0,0 @@
-"""
-/* Copyright (c) 2023 Amazon
-   Written by Jan Buethe */
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-"""
-
-import torch
-from tqdm import tqdm
-import sys
-
-def train_one_epoch(model, criterion, optimizer, dataloader, device, scheduler, log_interval=10):
-
-    model.to(device)
-    model.train()
-
-    running_loss = 0
-    previous_running_loss = 0
-
-    # gru states
-    gru_a_state = torch.zeros(1, dataloader.batch_size, model.gru_a_units, device=device).to(device)
-    gru_b_state = torch.zeros(1, dataloader.batch_size, model.gru_b_units, device=device).to(device)
-    gru_states = [gru_a_state, gru_b_state]
-
-    with tqdm(dataloader, unit='batch', file=sys.stdout) as tepoch:
-
-        for i, batch in enumerate(tepoch):
-
-            # set gradients to zero
-            optimizer.zero_grad()
-
-            # zero out initial gru states
-            gru_a_state.zero_()
-            gru_b_state.zero_()
-
-            # push batch to device
-            for key in batch:
-                batch[key] = batch[key].to(device)
-
-            target = batch['target']
-
-            # calculate model output
-            output = model(batch['features'], batch['periods'], batch['signals'], gru_states)
-
-            # calculate loss
-            loss = criterion(output.permute(0, 2, 1), target)
-
-            # calculate gradients
-            loss.backward()
-
-            # update weights
-            optimizer.step()
-
-            # update learning rate
-            scheduler.step()
-
-            # call sparsifier
-            model.sparsify()
-
-            # update running loss
-            running_loss += float(loss.cpu())
-
-            # update status bar
-            if i % log_interval == 0:
-                tepoch.set_postfix(running_loss=f"{running_loss/(i + 1):8.7f}", current_loss=f"{(running_loss - previous_running_loss)/log_interval:8.7f}")
-                previous_running_loss = running_loss
-
-
-    running_loss /= len(dataloader)
-
-    return running_loss
-
-def evaluate(model, criterion, dataloader, device, log_interval=10):
-
-    model.to(device)
-    model.eval()
-
-    running_loss = 0
-    previous_running_loss = 0
-
-    # gru states
-    gru_a_state = torch.zeros(1, dataloader.batch_size, model.gru_a_units, device=device).to(device)
-    gru_b_state = torch.zeros(1, dataloader.batch_size, model.gru_b_units, device=device).to(device)
-    gru_states = [gru_a_state, gru_b_state]
-
-    with torch.no_grad():
-        with tqdm(dataloader, unit='batch', file=sys.stdout) as tepoch:
-
-            for i, batch in enumerate(tepoch):
-
-
-                # zero out initial gru states
-                gru_a_state.zero_()
-                gru_b_state.zero_()
-
-                # push batch to device
-                for key in batch:
-                    batch[key] = batch[key].to(device)
-
-                target = batch['target']
-
-                # calculate model output
-                output = model(batch['features'], batch['periods'], batch['signals'], gru_states)
-
-                # calculate loss
-                loss = criterion(output.permute(0, 2, 1), target)
-
-                # update running loss
-                running_loss += float(loss.cpu())
-
-                # update status bar
-                if i % log_interval == 0:
-                    tepoch.set_postfix(running_loss=f"{running_loss/(i + 1):8.7f}", current_loss=f"{(running_loss - previous_running_loss)/log_interval:8.7f}")
-                    previous_running_loss = running_loss
-
-
-        running_loss /= len(dataloader)
-
-        return running_loss