Python SBOLog Examples

Example #1

File: run_year_data.py Project: elijah1027/stratified_bayesian_optimization

from problems.arxiv.process_raw_data import ProcessRawData

import argparse

from stratified_bayesian_optimization.initializers.log import SBOLog

logger = SBOLog(__name__)

if __name__ == '__main__':
    # python -m problems.arxiv.scripts.run_year_data '1'
    parser = argparse.ArgumentParser()
    parser.add_argument('month', help='e.g. 23')
    args = parser.parse_args()
    month = args.month

    files = ProcessRawData.generate_filenames_month(2016, int(args.month))

    logger.info("Files to be processed: ")
    logger.info(files)

    ProcessRawData.get_click_data(
        files, "problems/arxiv/data/2016_%s_processed_data.json" % month)

Example #2

from __future__ import absolute_import

import numpy as np
import os
from scipy.stats import norm
from scipy.stats import foldnorm

from stratified_bayesian_optimization.initializers.log import SBOLog
from stratified_bayesian_optimization.util.json_file import JSONFile

logger = SBOLog(__name__)


class RandomPolicy(object):

    def __init__(self, dict_stat_models, name_model, problem_name, type_model='grad_epoch', n_epochs=1,
                 stop_iteration_per_point=100, random_seed=None, n_restarts=None):
        self.dict_stat_models = dict_stat_models
        self.points_index = range(len(self.dict_stat_models))
        self.current_index = 0

        self.type_model = type_model
        self.problem_name = problem_name

        self.name_model = name_model
        self.n_epochs = n_epochs

        self.chosen_points = {}
        self.evaluations_obj = {}

        self.stop_iteration_per_point = stop_iteration_per_point

Example #3

import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.optim as optim
import torch.utils.data
import torchvision.datasets as datasets
import torchvision.transforms as transforms
import torchvision.utils as vutils
from torch.autograd import Variable
import torch.nn.functional as F
import math

import numpy as np
from stratified_bayesian_optimization.initializers.log import SBOLog
from stratified_bayesian_optimization.util.json_file import JSONFile

logger = SBOLog(__name__)


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
       # self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))
        x = F.relu(F.max_pool2d(self.conv2(x), 2))
        x = x.view(-1, 320)

Example #4

File: maximum_runs.py Project: elijah1027/stratified_bayesian_optimization

from __future__ import absolute_import

import argparse
import os
import numpy as np

from stratified_bayesian_optimization.util.json_file import JSONFile
from stratified_bayesian_optimization.initializers.log import SBOLog

logger = SBOLog(__name__)

if __name__ == '__main__':
    # Example usage:
    # python -m problems.cnn_cifar10.scripts.maximum_runs 500 600

    parser = argparse.ArgumentParser()
    parser.add_argument('min_rs', help='e.g. 500')
    parser.add_argument('max_rs', help='e.g. 600')

    args = parser.parse_args()
    min_rs = int(args.min_rs)
    max_rs = int(args.max_rs)

    max_values = []
    for i in xrange(min_rs, max_rs):
        file_name = 'problems/cnn_cifar10/runs_random_seeds/' + 'rs_%d' % i + '.json'
        if not os.path.exists(file_name):
            continue
        data = JSONFile.read(file_name)
        max_values.append(data['test_error_images'])

Example #5

from __future__ import absolute_import

import numpy as np
import os
import argparse

from stratified_bayesian_optimization.util.json_file import JSONFile
from stratified_bayesian_optimization.initializers.log import SBOLog
from multi_start.parametric_functions import ParametricFunctions

logger = SBOLog(__name__)


def SGD(start,
        gradient,
        n,
        function,
        exact_gradient=None,
        args=(),
        kwargs={},
        bounds=None,
        learning_rate=0.1,
        momentum=0.0,
        maxepoch=250,
        adam=True,
        betas=None,
        eps=1e-8,
        simplex_domain=None,
        name_model='1',
        method='real_gradient',
        n_epochs=1,

Example #6

from __future__ import absolute_import

from stratified_bayesian_optimization.initializers.log import SBOLog
from stratified_bayesian_optimization.services.validate_gp_model import ValidateGPService
from stratified_bayesian_optimization.lib.constant import (
    PRODUCT_KERNELS_SEPARABLE,
    MATERN52_NAME,
    TASKS_KERNEL_NAME,
    SAME_CORRELATION,
)

logger = SBOLog(__name__)

if __name__ == '__main__':
    # Example:
    # python -m scripts.run_validate_gp_model

    type_kernel = [PRODUCT_KERNELS_SEPARABLE, MATERN52_NAME, TASKS_KERNEL_NAME]
    n_training = 200
    problem_name = "arxiv"
    bounds_domain = [[0.01, 1.01], [0.1, 2.1], [1, 21], [1, 201], [0, 1, 2, 3, 4]]
    type_bounds = [0, 0, 0, 0, 1]
    dimensions = [5, 4, 5]
    thinning = 5
    n_burning = 100
    max_steps_out = 1000
    random_seed = 5
    training_name = None
    points = None
    noise = False
    n_samples = 0

Example #7

 def test_info(self):
     logger = SBOLog(__name__)
     logger.info('testing')