Esempio n. 1
0
    # Keep track of loss
    print_loss_total += loss
    plot_loss_total += loss

    if epoch == 0:
        continue

    if epoch % print_every == 0:
        print_loss_avg = print_loss_total / print_every
        print_loss_total = 0
        time_since = helpers.time_since(start, epoch / n_epochs)
        print('%s (%d %d%%) %.4f' %
              (time_since, epoch, epoch / n_epochs * 100, print_loss_avg))

    if epoch % plot_every == 0:
        plot_loss_avg = plot_loss_total / plot_every
        plot_losses.append(plot_loss_avg)
        plot_loss_total = 0

# Save our models
torch.save(encoder.state_dict(),
           '../data/encoder_params_{}'.format(args.language))
torch.save(decoder.state_dict(),
           '../data/decoder_params_{}'.format(args.language))
torch.save(decoder.attention.state_dict(),
           '../data/attention_params_{}'.format(args.language))

# Plot loss
helpers.show_plot(plot_losses)
            'number': 0,
            'total_payment': 0
        },
        'C#': {
            'number': 0,
            'total_payment': 0
        },
        'Java': {
            'number': 0,
            'total_payment': 0
        },
        'PHP': {
            'number': 0,
            'total_payment': 0
        },
        'Other': {
            'number': 0,
            'total_payment': 0
        }
    }

    vacancies = work_with_file.read_from_file(
        input('Please input path to a source file: '))

    helpers.add_lang_to_vacancies(vacancies, languages)
    helpers.count_vacancies_per_lang(vacancies, languages)
    helpers.add_total_payment_per_lang(vacancies, languages)
    helpers.avg_payment_per_lang(languages)
    helpers.print_stats(languages)
    helpers.show_plot(languages)
Esempio n. 3
0
        #    )
        # )
    message = "epoch: {} current loss: {:.4f} time taken: {}s".format(
        epoch, loss_contrastive.item(),
        str(time.time() - start)[:5])
    try:
        slack_callback.write(message)
    except Exception as e:
        pass

    print("epoch: {} current loss: {:.4f} time taken: {}s".format(
        epoch, loss_contrastive.item(),
        str(time.time() - start)[:5]))
    # iteration_number += 10
    counter.append(epoch)
    loss_history.append(loss_contrastive.item())

    if epoch % 50 == 0 and epoch > 0:
        state_dict = {
            "epoch": epoch + 1,
            "state_dict": net.state_dict(),
            "optim_dict": optimizer.state_dict(),
            "loss_history": loss_history,
            "counter": counter,
        }
        torch.save(state_dict, f"models/model_state_dict_{epoch}.pt")
        print()
        print(f"model checkpoint saved to models/model_state_dict_{epoch}")

show_plot(counter, loss_history, save=True)