コード例 #1
0
def combine_cmb_noise(config, n, cmb_dir, noise_dir, coupling_matrix, mask):
    combined_dir = os.path.join(config['toplevel_dir'],
                                'ffp8_mc_combined_{:04}'.format(n))
    if not os.path.exists(combined_dir):
        os.mkdir(combined_dir)

    logger = log.make_logger('ffp8_combined_{}'.format(n),
                             log_file=os.path.join(combined_dir, 'log.txt'),
                             toplevel_log_file=os.path.join(
                                 config['toplevel_dir'],
                                 'lgmca_postprocessing_combination_log.txt'))

    with log.Timer(logger,
                   'Combining CMB {0} and noise {0}'.format(n)).with_level(
                       logging.INFO):
        with log.Timer(logger, 'Reading CMB & noise maps and combining them'):
            cmb_map = hp.read_map(os.path.join(cmb_dir,
                                               'FFP8_v1_aggregated_cmb.fits'),
                                  verbose=False)
            noise_map = hp.read_map(os.path.join(
                noise_dir, 'FFP8_v1_aggregated_cmb.fits'),
                                    verbose=False)
            combined_map_ring = cmb_map + noise_map

        # No need to waste memory
        del cmb_map
        del noise_map

        combined_map = hp.reorder(combined_map_ring, r2n=True)
        cls = hp.anafast(combined_map_ring,
                         lmax=config['matmask_maxl'],
                         use_weights=True)

        hp.write_map(os.path.join(combined_dir, 'FFP8_v1_aggregated_map.fits'),
                     combined_map,
                     nest=True,
                     overwrite=True)
        hp.write_cl(os.path.join(combined_dir, 'FFP8_v1_aggregated_cls.fits'),
                    cls,
                    overwrite=True)
        shutil.copyfile(
            os.path.join(cmb_dir, 'FFP8_v1_aggregated_beam.txt'),
            os.path.join(combined_dir, 'FFP8_v1_aggregated_beam.txt'))

        with log.Timer(logger, 'Computing masked pspec and decoupling'):
            masked_powerspec = hp.anafast(combined_map_ring * mask,
                                          lmax=config['matmask_maxl'],
                                          use_weights=True)
            recovered_pspec = np.linalg.solve(coupling_matrix,
                                              masked_powerspec)
            hp.write_cl(os.path.join(combined_dir,
                                     'mask_corrected_spectra.fits'),
                        recovered_pspec,
                        overwrite=True)
コード例 #2
0
ファイル: main.py プロジェクト: yogstation13/MirrorBot
import mirror_engine
import log

logger = log.make_logger("log")
logger.info("Starting.")

while True:
    engine = mirror_engine.MirrorEngine()
    engine.initialize()
    try:
        engine.run()
    except:
        logger.exception("Uncaught exception!")

# TODO:
# compare diffs on up and downstream
# update downstream dme with upstream
コード例 #3
0
ファイル: app.py プロジェクト: brownman90/graph-explorer
import os
import traceback
from alerting import Db, rule_from_form


# contains all errors as key:(title,msg) items.
# will be used throughout the runtime to track all encountered errors
errors = {}

# will contain the latest data
last_update = None

config = make_config(config)

logger = make_logger('app', config)

logger.debug('app starting')
backend = Backend(config, logger)
s_metrics = structured_metrics.StructuredMetrics(config, logger)
graphs_manager = Graphs()
graphs_manager.load_plugins()
graphs_all = graphs_manager.list_graphs()

bottle.TEMPLATE_PATH.insert(0, os.path.dirname(__file__))


@route('<path:re:/assets/.*>')
@route('<path:re:/timeserieswidget/.*(js|css)>')
@route('<path:re:/timeserieswidget/timezone-js/src/.*js>')
@route('<path:re:/timeserieswidget/tz/.*>')
コード例 #4
0
def generate_episode(env: Blackjack, player_policy, ep_no):
    history = []
    done = False
    observation = env.reset()
    while not done:
        state = State(*observation)
        history.append(state)
        log.debug('Episode no {}: {}'.format(ep_no, state))
        observation, reward, done, auxiliary = env.step(
            player_policy[state.to_policy_key()])
    return history, reward


if __name__ == '__main__':
    log = make_logger(__name__, logging.DEBUG)
    env = Blackjack()
    state_value = np.zeros(
        (N_DEALER_CARD_SUM_POSSIBILITIES, N_PLAYER_CARDS_SUM_POSSIBILITIES,
         N_USABLE_ACE_LAYERS))
    player_policy = np.ones(state_value.shape, dtype=np.int32)
    player_policy[:, (PLAYER_INIT_STICK_SUM - PLAYER_MIN):, :] = 0
    returns = defaultdict(list)
    for i in range(100000):
        episode, reward = generate_episode(env, player_policy, i)
        log.info('Episode no {} rewarded {:2}: {}'.format(i, reward, episode))
        for state in episode:
            key = state.to_policy_key()
            returns[key].append(reward)
            state_value[key] = np.mean(returns[key])
コード例 #5
0
import logging
import os
from enum import Enum
from itertools import product

import numpy as np
from gym import Env
from gym.spaces import Tuple, Discrete

from log import make_logger

log = make_logger(__name__, logging.INFO)

ACTIONS = list(product((-1, 0, 1), (-1, 0, 1)))


class CellType(Enum):
    OFF = 0
    ROAD = 1
    START = 2
    STOP = 3

    @staticmethod
    def values():
        return list(CellType)


class Reward(Enum):
    WIN = 1
    STEP = -1
    LOOSE = -5
コード例 #6
0
ファイル: lifx_bg.py プロジェクト: ancillarymagnet/lifx_circ
    put_request(c_s, pwr, duration)

def put_request(c_s, pwr, duration):
    """ take a formatted color string and duration float
    and put that request to the LIFX API """
    inf('**** put request: {}, {}, {}s'.format(c_s, pwr, duration))
    data = json.dumps(
        {'selector':'all',
         'power': pwr,
         'color': c_s,
         'duration': duration,
        })
    r = requests.put(config.state_url(), data, headers=creds.headers)
    inf(r)

logger = log.make_logger()
inf('<<<<<<<<<<<<<<<<<< SYSTEM RESTART >>>>>>>>>>>>>>>>>>>>>')

test_connection()

# update sunrise / sunset every day
MS_DAY = 60 * 60 * 24 * 1000
refresh_solar_info = tornado.ioloop.PeriodicCallback(LUT.refresh_solar(),                                                     MS_DAY)
refresh_solar_info.start()


switch('on', False)
print 'state now: ' + str(LUT.state_now())
print 'next state: ' + str(LUT.next_state())
print 'secs to next state: ' + str(LUT.secs_to_next_state())
コード例 #7
0
import dashboards

import os
import traceback
from alerting import Db, rule_from_form

# contains all errors as key:(title,msg) items.
# will be used throughout the runtime to track all encountered errors
errors = {}

# will contain the latest data
last_update = None

config = make_config(config)

logger = make_logger('app', config)

logger.debug('app starting')
backend = Backend(config, logger)
s_metrics = structured_metrics.StructuredMetrics(config, logger)
graphs_manager = Graphs()
graphs_manager.load_plugins()
graphs_all = graphs_manager.list_graphs()

bottle.TEMPLATE_PATH.insert(0, os.path.dirname(__file__))


@route('<path:re:/assets/.*>')
@route('<path:re:/timeserieswidget/.*(js|css)>')
@route('<path:re:/timeserieswidget/timezone-js/src/.*js>')
@route('<path:re:/timeserieswidget/tz/.*>')
コード例 #8
0
ファイル: app.py プロジェクト: jaanek/graph-explorer
from validation import RuleEditForm, RuleAddForm

import traceback
from alerting import Db, rule_from_form


# contains all errors as key:(title,msg) items.
# will be used throughout the runtime to track all encountered errors
errors = {}

# will contain the latest data
last_update = None

config = make_config(config)

logger = make_logger("app", config)

logger.debug("app starting")
backend = Backend(config, logger)
s_metrics = structured_metrics.StructuredMetrics(config, logger)
graphs_manager = Graphs()
graphs_manager.load_plugins()
graphs_all = graphs_manager.list_graphs()


@route("<path:re:/assets/.*>")
@route("<path:re:/timeserieswidget/.*(js|css)>")
@route("<path:re:/timeserieswidget/timezone-js/src/.*js>")
@route("<path:re:/timeserieswidget/tz/.*>")
@route("<path:re:/DataTables/media/js/.*js>")
@route("<path:re:/DataTablesPlugins/integration/bootstrap/.*(js|css)>")
コード例 #9
0
def put_request(c_s, pwr, duration):
    """ take a formatted color string and duration float
    and put that request to the LIFX API """
    inf('**** put request: {}, {}, {}s'.format(c_s, pwr, duration))
    data = json.dumps({
        'selector': 'all',
        'power': pwr,
        'color': c_s,
        'duration': duration,
    })
    r = requests.put(config.state_url(), data, headers=creds.headers)
    inf(r)


logger = log.make_logger()
inf('<<<<<<<<<<<<<<<<<< SYSTEM RESTART >>>>>>>>>>>>>>>>>>>>>')

test_connection()

# update sunrise / sunset every day
MS_DAY = 60 * 60 * 24 * 1000
refresh_solar_info = tornado.ioloop.PeriodicCallback(LUT.refresh_solar(),
                                                     MS_DAY)
refresh_solar_info.start()

switch('on', False)
print 'state now: ' + str(LUT.state_now())
print 'next state: ' + str(LUT.next_state())
print 'secs to next state: ' + str(LUT.secs_to_next_state())
コード例 #10
0
#!/usr/bin/env python2
import os
import sys

import config
from backend import Backend, make_config
from log import make_logger
import structured_metrics

config = make_config(config)

os.chdir(os.path.dirname(os.path.abspath(__file__)))

logger = make_logger('update_metrics', config)

try:
    backend = Backend(config, logger)
    s_metrics = structured_metrics.StructuredMetrics(config, logger)
    errors = s_metrics.load_plugins()
    if len(errors) > 0:
        logger.warn('errors encountered while loading plugins:')
        for e in errors:
            print '\t%s' % e
    logger.info("fetching/saving metrics from graphite...")
    backend.download_metrics_json()
    logger.info("generating structured metrics data...")
    backend.update_data(s_metrics)
    logger.info("success!")
except Exception, e:  # pylint: disable=W0703
    logger.error("sorry, something went wrong: %s", e)
    from traceback import print_exc
コード例 #11
0
from gym import Env

from envs.CliffWalkingEnv import CliffWalking
from log import make_logger
from windy_gridworld import Sarsa, generate_episode

log = make_logger(__name__)


class QLearning(Sarsa):
    def __init__(self, env: Env, alpha=0.5, gamma=1, epsilon=0.1):
        super().__init__(env, alpha, gamma, epsilon)

    def greedy_value(self, state):
        return self.action_value[state].max()

    def on_new_state(self, prev_state, action, reward, next_state, done):
        q = self.action_value[prev_state][action]
        q_next = self.greedy_value(next_state)
        self.action_value[prev_state][action] += self.alpha * (reward + self.gamma * q_next - q)


if __name__ == '__main__':
    env = CliffWalking()
    algorithm = QLearning(env, alpha=0.5, gamma=1, epsilon=0.1)
    for ep in range(int(1e2)):  # 1e4 for Sarsa
        moves = generate_episode(env, algorithm)
        log.info('Episode no. {} done in moves {}'.format(ep, moves))

    log.info('Done learning!')
    algorithm.epsilon = 0