Exemplo n.º 1
0
    def csv_output(self):
        
        """This method is used to report the results of
        a subscription test to a csv file"""

        # determine the file name
        csv_filename = "subscription-%s-%siter-%s-%s.csv" % (self.subscriptiontype,
                                                      self.iterations,
                                                      self.chart_type.lower(),
                                                      self.testdatetime)

        # initialize the csv file
        csvfile_stream = open(csv_filename, "w")
        csvfile_writer = csv.writer(csvfile_stream, delimiter=',', quoting=csv.QUOTE_MINIMAL)

        # iterate over the SIBs
        for sib in self.results.keys():                    
                                     
            row = [sib]
            
            # add all the times
            for value in self.results[sib]:
                row.append(value)

            # add the mean, min, max and variance value of the times to the row
            row.append(round(nmean(self.results[sib]),3))                
            row.append(round(nmin(self.results[sib]),3))                
            row.append(round(nmax(self.results[sib]),3))                
            row.append(round(nvar(self.results[sib]),3))                

            # write the row
            csvfile_writer.writerow(row)
                
        # close the csv file
        csvfile_stream.close()
def checkValidity_MultiFrquency(X1, Y1, f1, NFFT1):
    d1_list = []
    d2_list = []
    g2_list = []

    peak1 = np.sort(findPeakPyVersion((2. * X1[0:int(NFFT1 / 2. + 1.)])),
                    'descend')
    peak1Len = peak1.shape[1]
    chk_val1 = nzeros([peak1Len, 1])
    index1 = nzeros([peak1Len, 1])
    for i in narange(1., (peak1Len + 1)):
        chk_val1[int(i) -
                 1, :] = peak1[int(i) - 1] / (nmean(peak1[int(i):peak1Len]))
        if chk_val1[int(i) - 1, :] > 2.:
            index1[int(i) - 1, :] = np.nonzero(
                X1[0:NFFT1 / 2. + 1.] == peak1[:, int(i) - 1] / 2.)
            d1_list.append(f1[index1[int(i) - 1, :]])

    mean1 = nmean(peak1[0:peak1Len])
    k = 1.
    peak2 = np.sort(findPeakPyVersion((2. * Y1[0:NFFT1 / 2. + 1.])), 'descend')
    peak2Len = peak2.shape[1]
    chk_val = nzeros([peak2Len, 1])
    index2 = nzeros([peak2Len, 1])
    for i in narange(1., peak2Len):
        chk_val[int(i) -
                1, :] = peak2[0, int(i) - 1] / nmean(peak2[int(i):peak2Len])
        if chk_val[int(i) - 1, :] > 3.:
            g2_list.append(chk_val[int(i) - 1, :])
            index2[int(i) - 1, :] = np.nonzero(
                (Y1[0:NFFT1 / 2. + 1.] == peak2[:, int(i) - 1] / 2.))
            d2_list.append(f1[index2[int(i) - 1, :]])

    d2 = np.array([d2_list])
    d1 = np.array([d1_list])
    g2 = np.array([g2_list])

    if g2 >= 0.:
        g1 = nmean(g2)
    else:
        g1 = nmean(g2)

    return [g1, d1, d2]
def FFT_MultiFrequency_update(s1, s2):
    Fs = np.array([[31.]])
    #% Sampling frequency
    T = 1. / Fs
    #% Sample time
    L = 512.
    #% Length of signal
    t = ndot(narange(0., L), T)

    NFFT1 = float(pow(2, pyNextPow2(L)))
    #% Next power of 2 from length of y
    s1[0, :] = s1[0, :] - nmean(s1[0, :])
    s2[0, :] = s2[0, :] - nmean(s2[0, :])
    X1 = nabs(np.fft(s1, NFFT1) / L)
    Y1 = nabs(np.fft(s2, NFFT1) / L)
    f1 = ndot(Fs / 2., np.linspace(0., 1., (NFFT1 / 2. + 1.)))

    [g1, d1, d2] = checkValidity_MultiFrquency(X1, Y1, f1, NFFT1)
    return [d1, X1, Y1, f1, NFFT1, d2, g1]
Exemplo n.º 4
0
    def plot_chart(self):
        
        """This method is used to plot the chart"""
            
        # determine the type of the chart
        if self.chart_type == "Bar":
            
            # determine the file name
            chart_filename = "update-%s-%sstep-%smax-%siter-%s-%s.svg" % (self.updatetype,
                                                                          self.step,
                                                                          self.limit,
                                                                          self.iterations,
                                                                          self.chart_type.lower(),
                                                                          self.testdatetime)

            # initialise the chart
            chart = Bar()
            chart.title = self.chart_title
            chart.x_title = self.chart_x_title
            chart.y_title = self.chart_y_title
            chart.style = eval(self.chart_style)

            # iterate over the SIBs
            for sib in self.results.keys():                    
                
                # iterate over the possible block lengths
                values = []
                for triple_length in sorted(self.results[sib].keys(), key=int):
                    values.append(nmean(self.results[sib][triple_length]))                

                # add the values to the chart
                chart.add(sib, values)
            
            # add the labels for the x axis
            x_labels = []
            for triple_length in sorted(self.results[self.results.keys()[0]].keys(), key=int):
                x_labels.append(triple_length)
            chart.x_labels = x_labels

            # plot the chart
            chart.render_to_file(chart_filename)

        else:

            # chart type not available
            raise UpdateTestException("Chart type %s not available" % self.chart_type)
Exemplo n.º 5
0
    def csv_output(self):
        
        """This method is used to report the results of
        an update test to a csv file"""

        # determine the file name
        csv_filename = "update-%s-%sstep-%smax-%siter-%s-%s.csv" % (self.updatetype,
                                                                    self.step,
                                                                    self.limit,
                                                                    self.iterations,
                                                                    self.chart_type.lower(),
                                                                    self.testdatetime)

        # initialize the csv file
        csvfile_stream = open(csv_filename, "w")
        csvfile_writer = csv.writer(csvfile_stream, delimiter=',', quoting=csv.QUOTE_MINIMAL)

        # iterate over the SIBs
        for sib in self.results.keys():                    
                         
            # iterate over the possible block lengths
            for triple_length in sorted(self.results[sib].keys(), key=int):
            
                row = [sib]
    
                # add the length of the block to the row
                row.append(triple_length)

                # add all the times
                for value in self.results[sib][triple_length]:
                    row.append(value)

                # add the mean value of the times to the row
                row.append(round(nmean(self.results[sib][triple_length]),3))                
                row.append(round(nmin(self.results[sib][triple_length]),3))                
                row.append(round(nmax(self.results[sib][triple_length]),3))                
                row.append(round(nvar(self.results[sib][triple_length]),3))                

                # write the row
                csvfile_writer.writerow(row)

        # close the csv file
        csvfile_stream.close()
Exemplo n.º 6
0
def fit(model: Union[Module, List[Module]],
        optimiser: Optimizer,
        loss_fn: Callable,
        epochs: int,
        dataloader: DataLoader,
        prepare_batch: Callable,
        metrics: List[Union[str, Callable]] = None,
        callbacks: List[Callback] = None,
        verbose: bool = True,
        fit_function: Callable = gradient_step,
        n_models: int = 1,
        fit_function_kwargs: dict = {}):
    """Function to abstract away training loop.

    The benefit of this function is that allows training scripts to be much more readable and allows for easy re-use of
    common training functionality provided they are written as a subclass of voicemap.Callback (following the
    Keras API).

    # Arguments
        model: Model to be fitted.
        optimiser: Optimiser to calculate gradient step from loss
        loss_fn: Loss function to calculate between predictions and outputs
        epochs: Number of epochs of fitting to be performed
        dataloader: `torch.DataLoader` instance to fit the model to
        prepare_batch: Callable to perform any desired preprocessing
        metrics: Optional list of metrics to evaluate the model with
        callbacks: Additional functionality to incorporate into training such as logging metrics to csv, model
            checkpointing, learning rate scheduling etc... See voicemap.callbacks for more.
        verbose: All print output is muted if this argument is `False`
        fit_function: Function for calculating gradients. Leave as default for simple supervised training on labelled
            batches. For more complex training procedures (meta-learning etc...) you will need to write your own
            fit_function
        fit_function_kwargs: Keyword arguments to pass to `fit_function`
    """
    # Determine number of samples:
    num_batches = len(dataloader)
    batch_size = dataloader.batch_size

    fit_function_kwargs_logs = dict(fit_function_kwargs)

    fit_function_kwargs_logs['train'] = False
    fit_function_kwargs_logs['pred_fn'] = logmeanexp_preds

    callbacks = CallbackList([
        DefaultCallback(),
    ] + (callbacks or []) + [
        ProgressBarLogger(),
    ])
    callbacks.set_model(model)
    callbacks.set_params({
        'num_batches': num_batches,
        'batch_size': batch_size,
        'verbose': verbose,
        'metrics': (metrics or []),
        'prepare_batch': prepare_batch,
        'loss_fn': loss_fn,
        'optimiser': optimiser,
        'n_models': n_models
    })

    if verbose:
        print('Begin training...')

    callbacks.on_train_begin()

    for epoch in range(1, epochs + 1):
        callbacks.on_epoch_begin(epoch)

        epoch_logs = {}
        for batch_index, batch in enumerate(dataloader):
            batch_logs = dict(batch=batch_index, size=(batch_size or 1))

            callbacks.on_batch_begin(batch_index, batch_logs)

            x, y = prepare_batch(batch)

            # result = {
            #     "meta_batch_loss": meta_batch_loss,
            #     "task_predictions": task_predictions,
            #     "models_losses": models_losses,
            #     "models_predictions": models_predictions,
            #     "mean_support_loss": mean_support_loss
            # }

            result = fit_function(model, optimiser, loss_fn, x, y,
                                  **fit_function_kwargs)

            loss = result['meta_batch_loss']
            y_pred = result['task_predictions']
            models_losses = result['models_losses']
            models_preds = result['models_predictions']
            support_loss = result['mean_support_loss']

            batch_logs['loss'] = loss.item()
            batch_logs['support_loss'] = support_loss

            # Loops through all metrics
            batch_logs = batch_metrics(model, y_pred, y, metrics, batch_logs)

            task_preds = defaultdict(list)
            for model_pred in models_preds:
                for i, task in enumerate(model_pred):
                    task_preds[i].append(task)

            # task_preds : {task_idx : [model_1_pred, model_2_pred, ....] }
            logprobs_pred = []
            logprobs_loss = []
            for task_idx, task_pred in task_preds.items():
                y_pred_ = logmeanexp_preds(task_pred)
                logprobs_pred.append(y_pred_)

            y_pred_logprobs = torch.cat(logprobs_pred)
            # TODO: make it work with MixturePredLoss
            # with torch.no_grad():
            #     loss_logprobs = loss_fn(y_pred_logprobs, y).item()
            #
            # batch_logs['logprobs_loss'] = loss_logprobs
            batch_logs['logprobs_nll'] = nll_loss(y_pred_logprobs,
                                                  y,
                                                  reduction="mean").item()
            batch_logs = batch_metrics(model, y_pred_logprobs, y, metrics,
                                       batch_logs, 'logprobs')

            for i, (loss, y_pred) in enumerate(zip(models_losses,
                                                   models_preds)):
                batch_logs[f'loss_{i}'] = nmean(loss)
                batch_logs[f'categorical_accuracy_{i}'] = NAMED_METRICS[
                    'categorical_accuracy'](y, torch.cat(y_pred))

            callbacks.on_batch_end(batch_index, batch_logs)

        # Run on epoch end
        callbacks.on_epoch_end(epoch, epoch_logs)

    # Run on train end
    if verbose:
        print('Finished.')

    callbacks.on_train_end()