def __init__(self): super().__init__() self._stub = self.connect() self.network = Network(self) self.update_blockheight() self.set_info() self.public_active_channels = self.get_open_channels(public_only=True, active_only=True)
def __init__(self, num_layers, heads, head_conv, down_ratio, weight_path): self.device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") self.net = Network(num_layers, heads, head_conv, down_ratio).to(self.device) self.net.load_state_dict(torch.load(weight_path)) self.net.eval() self.down_ratio = down_ratio
def test_save_and_load_model(self): self.network.define_model() first_prediction = self.network.batch_prediction(np.array([[1,1]])) self.network.save_network('saved_model') self.second_network = Network(2,2) self.second_network.load_network('saved_model') second_prediction = self.second_network.batch_prediction(np.array([[1,1]])) self.assertTrue((first_prediction == second_prediction).all())
def __init__(self, smarthome): super().__init__() if '.'.join(VERSION.split('.', 2)[:2]) <= '1.5': self.logger = logging.getLogger(__name__) try: self.shtime = Shtime.get_instance() self.handle_login = self.get_parameter_value('handle_login') try: self.dl = Http(timeout=self.get_parameter_value('timeout'), hide_login=self.handle_login) except: self.dl = Http(hide_login=self.handle_login) self._items = [] self._icals = {} self._ical_aliases = {} self._cycle = self.get_parameter_value('cycle') calendars = self.get_parameter_value('calendars') config_dir = self.get_parameter_value('directory') except Exception as err: self.logger.error('Problems initializing: {}'.format(err)) self._init_complete = False return try: self._directory = '{}/{}'.format(self.get_vardir(), config_dir) except Exception: self._directory = '{}/var/{}'.format(smarthome.get_basedir(), config_dir) self._directory = os.path.normpath(self._directory) try: os.makedirs(self._directory) self.logger.debug('Created {} subfolder in var'.format(config_dir)) except OSError as e: if e.errno != errno.EEXIST: self.logger.error( 'Problem creating {} folder in {}/var'.format( config_dir, smarthome.get_basedir())) self._init_complete = False return for calendar in calendars: if isinstance(calendar, dict): calendar = list("{!s}:{!s}".format(k, v) for (k, v) in calendar.items())[0] if ':' in calendar and 'http' != calendar[:4]: name, _, cal = calendar.partition(':') calendar = cal.strip() self.logger.info( 'Registering calendar {} with alias {}.'.format( Network.clean_uri(calendar, self.handle_login), name)) self._ical_aliases[name.strip()] = calendar else: self.logger.info( 'Registering calendar {} without alias.'.format( Network.clean_uri(calendar, self.handle_login))) calendar = calendar.strip() self._icals[calendar] = self._read_events(calendar) self.shtime = Shtime.get_instance()
def classifier(self, sx, qx, is_train, trainable=False, eps=1e-8, scale=1e+1, normalized=True): proto_vec = Network.base_net(sx, is_train, reuse=False, trainable=trainable) query_vec = Network.base_net(qx, is_train, reuse=True, trainable=trainable) if normalized: proto_vec = proto_vec / (tf.norm(proto_vec, axis=1, keepdims=True) + 1e-8) * scale query_vec = query_vec / (tf.norm(query_vec, axis=1, keepdims=True) + 1e-8) * scale
def __init__(self, GameState): # Initialise pygame pygame.init() pygame.font.init() pygame.mixer.init() pygame.display.set_caption(self.caption) self.screen = pygame.display.set_mode( self.dimensions, pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.RESIZABLE) # Delegate self.net = Network() self.GameState = GameState self.state = MenuState(self)
def init(self): self.net = Network('localhost') pygame.init() self.build_board() self.build_main_menu() pygame.display.flip() self.main_menu()
def __init__(self, server_address, blockchain): super().__init__(server_address, MasterHandler) self.blockchain = blockchain rs = Network.get_relays() self.relays = [r[0] for r in rs] print('Server started on ' + server_address[0] + ':' + str(server_address[1]))
def test_from_json(self): fn = os.path.join(os.path.dirname(__file__), './test_network.json') with open(fn) as data_file: network_json = json.load(data_file) network = Network.from_json(network_json) self.check_network_and_json(network, network_json)
def _mac_check(self, item, item_type: str, leaf_item=None): if not Network.is_mac(self.get_iattr_value(item.conf, item_type)): self._log_item_error( item, "invalid {} attribute provided from {}".format( item_type, item.path())) return False return True
def _update_calendars(self): for uri in self._icals: self._icals[uri] = self._read_events(uri) self.logger.debug('Updated calendar {0}'.format( Network.clean_uri(uri, self.handle_login))) if len(self._icals): self._update_items()
def __init__(self, relay=None): """initialize an http client to request the relay server if relay is None, random relay is chosen from Network """ servers = Network.get_relays() if relay is None: relay = servers[randint(0, len(servers)-1)] self.url = 'http://'+relay[0]+':'+str(relay[1])+'/'
def __init__(self, frameset_size, num_actions, last_actions_size): super().__init__(num_actions) self.sample_size = 200 self.num_epochs = 1 self.epsilon = 1.0 #exploration rate self.epsilon_decay = 0.996 self.epsilon_min = 0.01 self.gamma = 0.95 #discount rate self.frameset_size = frameset_size self.learn_count = 0 self.last_actions_size = last_actions_size self.num_actions = num_actions self.policy_network = Network(frameset_size, num_actions, last_actions_size=last_actions_size) self.target_network = Network(frameset_size, num_actions, last_actions_size=last_actions_size) self.target_network.weights = self.policy_network.weights self.target_network_update_rate = 5 self.replay_memory = ReplayMemory(capacity=50000)
def __init__(self, server_address, blockchain): super().__init__(server_address, RelayHandler) self.blockchain = blockchain self.master = MasterClient() self.transactions = [] # HTTP client relays, used to broadcast transactions self.relays = [] for r in Network.get_relays(): if r != server_address: self.relays.append(RelayClient(r)) print('Server started on ' + server_address[0] + ':' + str(server_address[1]))
def main(): logging.basicConfig(format=u'%(levelname)-8s [%(asctime)s] %(message)s', level=logging.DEBUG) ######################################################## n = Network() vk = VK(n) print('Token is: ' + vk.auth_direct(Config.USER_LOGIN, Config.USER_PASSWORD, Config.APP_ID, Config.APP_SECRET)) ######################################################## logging.info("--- APP END ---") return
def _read_events(self, ics, username=None, password=None, prio=1, verify=True): if ics.startswith('http'): _, _, cal = ics.partition('//') name = '{}.ics'.format(cal.split('/')[0].replace('.', '_')) for entry in self._ical_aliases: name = '{}.ics'.format( entry) if ics == self._ical_aliases[entry] else name filename = '{}/{}'.format(self._directory, name) auth = 'HTTPBasicAuth' if username else None downloaded = self.dl.download(url=ics, local=filename, params={ username: username, password: password }, verify=verify, auth=auth) if downloaded is False: self.logger.error( 'Could not download online ics file {0}.'.format(ics)) return {} self.logger.debug( 'Online ics {} successfully downloaded to {}'.format( Network.clean_uri(ics, self.handle_login), filename)) ics = os.path.normpath(filename) try: ics = ics.replace('\\', os.sep).replace('/', os.sep) ics = '{}/{}'.format(self._directory, ics) if self._directory not in ics else ics with open(ics, 'r') as f: ical = f.read() self.logger.debug('Read offline ical file {}'.format(ics)) except IOError as e: self.logger.error( 'Could not open local ics file {0} (directory {1}): {2}'. format(ics, self._directory, e)) return {} return self._parse_ical(ical, ics, prio)
def test_from_json(self): return fn = os.path.join(os.path.dirname(__file__), './test_network.json') settings = { 'momentum': 0.99, 'epoch': 5000, 'log': 100, 'error': 0.1, 'rate': 0.2, 'cost': Cost.SE } with open(fn) as data_file: network_json = json.load(data_file) network = Network.from_json(network_json) trainer = Trainer(network) start = time.time() error, epoch = trainer.XOR(settings) stop = time.time() print(stop - start)
def __init__(self, networkdb: 'NetworkDb', config: Config): self.networkdb: 'NetworkDb' = networkdb self.config: Config = config self.time: int = 0 self.network: Network = Network(networkdb) self.trains: List[Train] = [] self.start_minutes = {} if not self.config.deduce_schedule: self.read_trains() else: self.deduce_trains() self.all_routes = [] self.passengers = None if config.num_passengers_per_route > 0: self.create_passengers() self.graph = None self.positions = None self.xlim = None self.ylim = None self.minute = -1
def __init__(self, window): self.window = window ## objects ## self.netevent = None self.apic = Calls() self.processor = ProcessEvent() self.network = Network(self.window) self.login = LoginDialog(self) self.friend = FriendDialog(self.apic, self.login) self.chat = Chat(self.window, self.network, self.apic, loop, self.login) self.classroom_buttons = {} self.previous = None self.commands = { 'button_login': self.login.show, 'button_new': self.friend.show, 'emoji_dialog': self.chat.dialog_emoji.start, 'chat_send': self.chat.addMsgSelf, 'emojize': self.chat.emojize }
def run(args): x_dim = [76, 91, 75] y_dim = 10 splits = [0.8, 0.1, 0.1] X_data = [] Y_data = [] num_examples = 10 for i in range(1, num_examples + 1): f_x = os.path.join(args.dataset, f'X_Img_Values{i}.npy') f_y = os.path.join(args.dataset, f'YValues{i}.npy') X_data.append(torch.tensor(np.load(f_x))) Y_data.append(torch.tensor(np.load(f_y))) # (batch, channel, width, height) X_data = torch.cat(X_data, dim=0).view([-1, x_dim[2], *x_dim[:2]]) Y_data = torch.cat(Y_data, dim=0).view([-1, y_dim]) assert X_data.shape[0] == Y_data.shape[0] total_size = X_data.shape[0] X_train = X_data[:int(total_size * splits[0]), ...] Y_train = Y_data[:int(total_size * splits[0]), ...] X_dev = X_data[int(total_size * splits[0]):int(total_size * (splits[0] + splits[1])), ...] Y_dev = Y_data[int(total_size * splits[0]):int(total_size * (splits[0] + splits[1])), ...] X_test = X_data[int(total_size * (splits[0] + splits[1])):, ...] Y_test = Y_data[int(total_size * (splits[0] + splits[1])):, ...] train_dataset = Data.TensorDataset(X_train, Y_train) dev_dataset = Data.TensorDataset(X_dev, Y_dev) test_dataset = Data.TensorDataset(X_test, Y_test) train_loader = Data.DataLoader(dataset=train_dataset, batch_size=16, shuffle=True) dev_loader = Data.DataLoader(dataset=dev_dataset, batch_size=16, shuffle=False) test_loader = Data.DataLoader(dataset=test_dataset, batch_size=16, shuffle=False) net = Network(in_channels=x_dim[2], out_size=y_dim) if torch.cuda.is_available(): net = nn.DataParallel(net) net.cuda() opt = torch.optim.Adam(net.parameters(), lr=0.001) loss_func = nn.MSELoss(reduction='mean') for epoch_index in range(20): st = time.time() torch.set_grad_enabled(True) net.train() for train_batch_index, (img_batch, label_batch) in enumerate(train_loader): if torch.cuda.is_available(): img_batch = img_batch.cuda() label_batch = label_batch.cuda() predict = net(img_batch) loss = loss_func(predict.float(), label_batch.float()) net.zero_grad() loss.backward() opt.step() print('(LR:%f) Time of a epoch:%.4fs' % (opt.param_groups[0]['lr'], time.time() - st)) # evaluation torch.set_grad_enabled(False) net.eval() total_loss = [] total_sample = 0 for dev_batch_index, (img_batch, label_batch) in enumerate(dev_loader): if torch.cuda.is_available(): img_batch = img_batch.cuda() label_batch = label_batch.cuda() predict = net(img_batch) loss = loss_func(predict.float(), label_batch.float()) total_loss.append(loss) total_sample += img_batch.size(0) mean_loss = sum(total_loss) / len(total_loss) print('[Test] epoch[%d/%d] loss:%.4f\n' % (epoch_index, 100, mean_loss.item()))
return param_group['lr'] logging.basicConfig(level=logging.INFO, format='(%(asctime)s %(levelname)s) %(message)s', datefmt='%d %b %H:%M:%S', filename='logs/region_layer.log', filemode='w') console = logging.StreamHandler() console.setLevel(logging.INFO) formatter = logging.Formatter('(%(levelname)s) %(message)s') console.setFormatter(formatter) logging.getLogger('').addHandler(console) net = Network(cfg.class_number) #network parameters # print(net) if torch.cuda.is_available(): net.cuda(cfg.cuda_num) dataset = DataSet(cfg) #train samples train_sample_nb = len(dataset.train_dataset) #batch numbers train_batch_nb = len(dataset.train_loader) test_sample_nb = len(dataset.test_dataset) test_batch_nb = len(dataset.test_loader) logging.info('Train batch[%d] sample[%d]' % (train_batch_nb, train_sample_nb))
train=True, transform=torchvision.transforms.ToTensor(), download=True) test_data = torchvision.datasets.MNIST( root='./mnist/', transform=torchvision.transforms.ToTensor(), train=False) train_loader = Data.DataLoader(dataset=train_data, batch_size=128, shuffle=True) test_loader = Data.DataLoader(dataset=test_data, batch_size=128, shuffle=False) train_batch_num = len(train_loader) test_batch_num = len(test_loader) net = Network(adjustable_mode=True, adj_kernel_size=4, adj_stride=4, adj_avgpool=True) if torch.cuda.is_available(): net = nn.DataParallel(net) net.cuda() opt = torch.optim.Adam(net.parameters(), lr=0.001) loss_func = nn.CrossEntropyLoss() for epoch_index in range(10): st = time.time() torch.set_grad_enabled(True) net.train() for train_batch_index, (img_batch, label_batch) in enumerate(train_loader): if torch.cuda.is_available():
def setUp(self): self.network = Network(2, 2)
du_dt = g.batch_jacobian(u, tx)[..., 0] return du_dt if __name__ == '__main__': """ Test the physics informed neural network (PINN) model for the wave equation. """ # number of training samples num_train_samples = 10000 # number of test samples num_test_samples = 1000 # build a core network model network = Network.build() network.summary() # build a PINN model pinn = PINN(network).build() # create training input tx_eqn = np.random.rand(num_train_samples, 2) tx_eqn[..., 0] = 4 * tx_eqn[..., 0] # t = 0 ~ +4 tx_eqn[..., 1] = 2 * tx_eqn[..., 1] - 1 # x = -1 ~ +1 tx_ini = np.random.rand(num_train_samples, 2) tx_ini[..., 0] = 0 # t = 0 tx_ini[..., 1] = 2 * tx_ini[..., 1] - 1 # x = -1 ~ +1 tx_bnd = np.random.rand(num_train_samples, 2) tx_bnd[..., 0] = 4 * tx_bnd[..., 0] # t = 0 ~ +4 tx_bnd[..., 1] = 2 * np.round(tx_bnd[..., 1]) - 1 # x = -1 or +1 # create training output
train_data = torchvision.datasets.MNIST(root='./mnist', train=True, transform=torchvision.transforms.ToTensor(), download=True) test_data = torchvision.datasets.MNIST(root='./mnist/', transform=torchvision.transforms.ToTensor(), train=False) train_loader = Data.DataLoader(dataset=train_data, batch_size=128, shuffle=True) test_loader = Data.DataLoader(dataset=test_data, batch_size=128, shuffle=False) train_batch_num = len(train_loader) test_batch_num = len(test_loader) net = Network() if torch.cuda.is_available(): net = nn.DataParallel(net) net.cuda() opt = torch.optim.Adam(net.parameters(), lr=0.001) loss_func = nn.CrossEntropyLoss() for epoch_index in range(20): st = time.time() for train_batch_index, (img_batch, label_batch) in enumerate(train_loader): img_batch = Variable(img_batch) label_batch = Variable(label_batch) if torch.cuda.is_available():
train=True, transform=torchvision.transforms.ToTensor(), download=True) test_data = torchvision.datasets.MNIST( root='./mnist/', transform=torchvision.transforms.ToTensor(), train=False) train_loader = Data.DataLoader(dataset=train_data, batch_size=cfg.batch_size, shuffle=True) test_loader = Data.DataLoader(dataset=test_data, batch_size=cfg.batch_size, shuffle=False) train_batch_num = len(train_loader) test_batch_num = len(test_loader) net = Network() if torch.cuda.is_available(): net.cuda() opt = torch.optim.Adam(net.parameters(), lr=cfg.LR, weight_decay=cfg.weight_decay) loss_func = nn.CrossEntropyLoss() if cfg.load_model: net.load_state_dict(torch.load(cfg.model_path)) for epoch_index in range(cfg.epoch): for train_batch_index, (img_batch, label_batch) in enumerate(train_loader): img_batch = Variable(img_batch) label_batch = Variable(label_batch)
from flask import Flask from lib.chain import Chain from lib.network import Network from lib.qbc_utils import QbcUtils from modules.transactions.controllers import transactions_blueprint from modules.mining.controllers import mining_blueprint from modules.network.controllers import network_blueprint from modules.chain.controllers import chain_blueprint node = Flask(__name__) QBC = Chain() QBCN = Network() QBCU = QbcUtils() port = QBCU.get_port() # Registering all the modules node.register_blueprint(transactions_blueprint) node.register_blueprint(mining_blueprint) node.register_blueprint(network_blueprint) node.register_blueprint(chain_blueprint) # Discover full network and register on each of the nodes network = QBCN.discover_network() live_nodes = network["registered_nodes"]
import torch from torch import nn import config as cfg from lib.test_loader import TestDataSet from tqdm import tqdm from lib.metric import roc, f1_score_calc import os from lib.network import Network import time from lib.utils import count_parameters_in_MB torch.cuda.set_device(cfg.CUDA_NUM) test_set = TestDataSet(cfg) net = Network() print('Net contain %.2fMB' % count_parameters_in_MB(net)) net.cuda() weight_path = os.path.join(cfg.weights_dir, 'net.pth') net.load_state_dict(torch.load(weight_path)) # ------------------- Testing ------------------------ torch.set_grad_enabled(False) net.eval() pre_list = [] label_list = [] for test_img, test_label \
class LndNode(Node): """ Implements an interface to an lnd node. """ def __init__(self): super().__init__() self._stub = self.connect() self.network = Network(self) self.update_blockheight() self.set_info() self.public_active_channels = self.get_open_channels(public_only=True, active_only=True) @staticmethod def connect(): """ Establishes a connection to lnd using the hostname, tls certificate, and admin macaroon defined in settings. """ macaroons = True os.environ['GRPC_SSL_CIPHER_SUITES'] = '' + \ 'ECDHE-RSA-AES128-GCM-SHA256:' + \ 'ECDHE-RSA-AES128-SHA256:' + \ 'ECDHE-RSA-AES256-SHA384:' + \ 'ECDHE-RSA-AES256-GCM-SHA384:' + \ 'ECDHE-ECDSA-AES128-GCM-SHA256:' + \ 'ECDHE-ECDSA-AES128-SHA256:' + \ 'ECDHE-ECDSA-AES256-SHA384:' + \ 'ECDHE-ECDSA-AES256-GCM-SHA384' cert = open(os.path.expanduser(_settings.config['network']['tls_cert_file']), 'rb').read() if macaroons: with open(os.path.expanduser(_settings.config['network']['admin_macaroon_file']), 'rb') as f: macaroon_bytes = f.read() macaroon = codecs.encode(macaroon_bytes, 'hex') def metadata_callback(context, callback): # for more info see grpc docs callback([('macaroon', macaroon)], None) cert_creds = grpc.ssl_channel_credentials(cert) auth_creds = grpc.metadata_call_credentials(metadata_callback) creds = grpc.composite_channel_credentials(cert_creds, auth_creds) else: creds = grpc.ssl_channel_credentials(cert) channel = grpc.secure_channel(_settings.config['network']['lnd_grpc_host'], creds, options=[ ('grpc.max_receive_message_length', 50 * 1024 * 1024) # necessary to circumvent standard size limitation ]) return lnrpc.LightningStub(channel) def update_blockheight(self): info = self._stub.GetInfo(ln.GetInfoRequest()) self.blockheight = int(info.block_height) def get_channel_info(self, channel_id): channel = self._stub.GetChanInfo(ln.ChanInfoRequest(chan_id=channel_id)) channel_dict = MessageToDict(channel, including_default_value_fields=True) channel_dict = convert_dictionary_number_strings_to_ints(channel_dict) return channel_dict @staticmethod def lnd_hops(hops): return [ln.Hop(**hop) for hop in hops] def lnd_route(self, route): """ Converts a cleartext route to an lnd route. :param route: :class:`lib.route.Route` :return: """ hops = self.lnd_hops(route.hops) return ln.Route( total_time_lock=route.total_time_lock, total_fees=route.total_fee_msat // 1000, total_amt=route.total_amt_msat // 1000, hops=hops, total_fees_msat=route.total_fee_msat, total_amt_msat=route.total_amt_msat ) def self_payment(self, routes, amt_msat): """ Do a self-payment along routes with amt_msat. :param routes: list of :class:`lib.route.Route` objects :param amt_msat: :return: payment result """ invoice = self._stub.AddInvoice(ln.Invoice(value=amt_msat // 1000)) result = self.send_to_route(routes, invoice.r_hash) logger.debug(result) return result def self_payment_zero_invoice(self, routes, memo): """ Do a self-payment along routes with an invoice of zero satoshis. This helps to use one invoice for several rebalancing attempts. Adds a memo to the invoice, which can later be parsed for bookkeeping. :param routes: list of :class:`lib.route.Route` objects :param memo: str, Comment field for an invoice. :return: payment result """ invoice = self._stub.AddInvoice(ln.Invoice(value=0, memo=memo)) result = self.send_to_route(routes, invoice.r_hash) logger.debug(result) return result def get_invoice(self, amt_msat): """ Fetches an already created invoice from lnd. :param amt_msat: :return: Hash of invoice preimage. """ invoice = self._stub.AddInvoice(ln.Invoice(value=amt_msat // 1000)) return invoice.r_hash def get_rebalance_invoice(self, memo): """ Creates a zero amount invoice and gives back it's hash. :param memo: Comment for the invoice. :return: Hash of the invoice preimage. """ invoice = self._stub.AddInvoice(ln.Invoice(value=0, memo=memo)) return invoice.r_hash def send_to_route(self, routes, r_hash_bytes): """ Takes bare route (list) and tries to send along it, trying to fulfill the invoice labeled by the given hash. :param routes: (list) of :class:`lib.routes.Route` :param r_hash_bytes: invoice identifier :return: """ if type(routes) == list: lnd_routes = [self.lnd_route(route) for route in routes] else: lnd_routes = [self.lnd_route(routes)] request = ln.SendToRouteRequest( routes=lnd_routes, payment_hash_string=r_hash_bytes.hex(), ) try: return self._stub.SendToRouteSync(request, timeout=5*60) # timeout after 5 minutes except _Rendezvous: raise PaymentTimeOut def get_raw_network_graph(self): graph = self._stub.DescribeGraph(ln.ChannelGraphRequest()) return graph def get_raw_info(self): """ Returns specific information about this node. :return: node information """ return self._stub.GetInfo(ln.GetInfoRequest()) def set_info(self): """ Fetches information about this node and computes total capacity, local and remote total balance, how many satoshis were sent and received, and some networking peer stats. """ raw_info = self.get_raw_info() self.pub_key = raw_info.identity_pubkey self.alias = raw_info.alias self.num_active_channels = raw_info.num_active_channels self.num_peers = raw_info.num_peers # TODO: remove the following code and implement an advanced status all_channels = self.get_open_channels(active_only=False, public_only=False) for k, c in all_channels.items(): self.total_capacity += c['capacity'] self.total_local_balance += c['local_balance'] self.total_remote_balance += c['remote_balance'] self.total_satoshis_received += c['total_satoshis_received'] self.total_satoshis_sent += c['total_satoshis_sent'] if c['active']: self.total_active_channels += 1 if c['private']: self.total_private_channels += 1 def get_open_channels(self, active_only=False, public_only=False): """ Fetches information (fee settings of the counterparty, channel capacity, balancedness) about this node's open channels and saves it into the channels dict attribute. :param active_only: bool, only take active channels into account (default) :param public_only: bool, only take public channels into account (off by default) :return: list of channels sorted by remote pubkey """ raw_channels = self._stub.ListChannels(ln.ListChannelsRequest(active_only=active_only, public_only=public_only)) channels_data = raw_channels.ListFields()[0][1] channels = OrderedDict() for c in channels_data: # calculate age from blockheight blockheight, _, _ = convert_channel_id_to_short_channel_id(c.chan_id) age_days = (self.blockheight - blockheight) * 10 / (60 * 24) # calculate last update (days ago) try: last_update = (time.time() - self.network.edges[c.chan_id]['last_update']) / (60 * 60 * 24) except TypeError: last_update = float('nan') except KeyError: last_update = float('nan') sent_received_per_week = int((c.total_satoshis_sent + c.total_satoshis_received) / (age_days / 7)) # determine policy try: edge_info = self.network.edges[c.chan_id] if edge_info['node1_pub'] == self.pub_key: # interested in node2 policy = edge_info['node2_policy'] else: # interested in node1 policy = edge_info['node1_policy'] except KeyError: # TODO: if channel is unknown in describegraph we need to set the fees to some error value policy = {'fee_base_msat': -1, 'fee_rate_milli_msat': -1} # define unbalancedness |ub| large means very unbalanced commit_fee = 0 if not c.initiator else c.commit_fee unbalancedness = -(float(c.local_balance + commit_fee) / c.capacity - 0.5) * 2 # inverse of above formula: # c.local_balance = c.capacity * 0.5 * (-unbalancedness + 1) - commit_fee channels[c.chan_id] = { 'active': c.active, 'age': age_days, 'alias': self.network.node_alias(c.remote_pubkey), 'amt_to_balanced': int(unbalancedness * c.capacity / 2 - commit_fee), 'capacity': c.capacity, 'chan_id': c.chan_id, 'channel_point': c.channel_point, 'commit_fee': c.commit_fee, 'fee_per_kw': c.fee_per_kw, 'peer_base_fee': policy['fee_base_msat'], 'peer_fee_rate': policy['fee_rate_milli_msat'], 'initiator': c.initiator, 'last_update': last_update, 'local_balance': c.local_balance, 'num_updates': c.num_updates, 'private': c.private, 'remote_balance': c.remote_balance, 'remote_pubkey': c.remote_pubkey, 'sent_received_per_week': sent_received_per_week, 'total_satoshis_sent': c.total_satoshis_sent, 'total_satoshis_received': c.total_satoshis_received, 'unbalancedness': unbalancedness, } sorted_dict = OrderedDict(sorted(channels.items(), key=lambda x: x[1]['alias'])) return sorted_dict def get_inactive_channels(self): channels = self.get_open_channels(public_only=False, active_only=False) return {k: c for k, c in channels.items() if not c['active']} def get_unbalanced_channels(self, unbalancedness_greater_than=0.0): """ Gets all channels which have an absolute unbalancedness (-1...1, -1 for outbound unbalanced, 1 for inbound unbalanced) larger than unbalancedness_greater_than. :param unbalancedness_greater_than: unbalancedness interval, default returns all channels :return: all channels which are more unbalanced than the specified interval """ unbalanced_channels = { k: c for k, c in self.public_active_channels.items() if abs(c['unbalancedness']) >= unbalancedness_greater_than } return unbalanced_channels @staticmethod def timestamp_from_now(offset_days=0): """ Determines the Unix timestamp from offset_days ago. :param offset_days: int :return: int, Unix timestamp """ now = datetime.datetime.now() then = now - datetime.timedelta(days=offset_days) then = time.mktime(then.timetuple()) return int(then) def get_forwarding_events(self, offset_days=300): """ Fetches all forwarding events between now and offset_days ago. :param offset_days: int :return: lnd fowarding events """ now = self.timestamp_from_now() then = self.timestamp_from_now(offset_days) forwardings = self._stub.ForwardingHistory(ln.ForwardingHistoryRequest( start_time=then, end_time=now, num_max_events=NUM_MAX_FORWARDING_EVENTS)) events = [{ 'timestamp': f.timestamp, 'chan_id_in': f.chan_id_in, 'chan_id_out': f.chan_id_out, 'amt_in': f.amt_in, 'amt_out': f.amt_out, 'fee_msat': f.fee_msat, 'effective_fee': f.fee_msat / (f.amt_in * 1000) } for f in forwardings.forwarding_events] return events def get_closed_channels(self): """ Fetches all closed channels. :return: dict, channel list """ request = ln.ClosedChannelsRequest() closed_channels = self._stub.ClosedChannels(request) closed_channels_dict = {} for c in closed_channels.channels: closed_channels_dict[c.chan_id] = { 'channel_point': c.channel_point, 'chain_hash': c.chain_hash, 'closing_tx_hash': c.closing_tx_hash, 'remote_pubkey': c.remote_pubkey, 'capacity': c.capacity, 'close_height': c.close_height, 'settled_balance': c.settled_balance, 'time_locked_balance': c.time_locked_balance, 'close_type': c.close_type, } return closed_channels_dict @staticmethod def handle_payment_error(payment_error): """ Handles payment errors and determines the failed channel. :param payment_error: :return: int, channel_id of the failed channel. """ if "TemporaryChannelFailure" in payment_error: logger.error(" Encountered temporary channel failure.") short_channel_groups = extract_short_channel_id_from_string(payment_error) channel_id = convert_short_channel_id_to_channel_id(*short_channel_groups) return channel_id def queryroute_external(self, source_pubkey, target_pubkey, amt_msat, ignored_nodes=(), ignored_channels=()): """ Queries the lnd node for a route. Channels and nodes can be ignored if they failed before. :param source_pubkey: str :param target_pubkey: str :param amt_msat: int :param ignored_nodes: list of node pub keys :param ignored_channels: list of channel_ids :return: list of channel_ids """ amt_sat = amt_msat // 1000 # we want to see all routes: max_fee = 10000 # convert ignored nodes to api format if ignored_nodes: ignored_nodes_api = [bytes.fromhex(n) for n in ignored_nodes] else: ignored_nodes_api = [] # convert ignored channels to api format if ignored_channels: ignored_channels_api = [ln.EdgeLocator(channel_id=c) for c in ignored_channels] else: ignored_channels_api = [] logger.debug(f"Ignored for queryroutes: channels: {ignored_channels_api}, nodes: {ignored_nodes_api}") request = ln.QueryRoutesRequest( pub_key=target_pubkey, amt=amt_sat, num_routes=1, final_cltv_delta=0, fee_limit=ln.FeeLimit(fixed=max_fee), ignored_nodes=ignored_nodes_api, ignored_edges=ignored_channels_api, source_pub_key=source_pubkey, ) try: response = self._stub.QueryRoutes(request) except _Rendezvous: raise NoRouteError # print(response) # We give back only one route, as multiple routes will be deprecated channel_route = [h.chan_id for h in response.routes[0].hops] return channel_route def print_status(self): logger.info("-------- Node status --------") balancedness_local = self.total_local_balance / self.total_capacity balancedness_remote = self.total_remote_balance / self.total_capacity logger.info(f"alias: {self.alias}") logger.info(f"pub key: {self.pub_key}") logger.info(f"blockheight: {self.blockheight}") logger.info(f"peers: {self.num_peers}") logger.info(f"channels: {self.total_channels}") logger.info(f"active channels: {self.total_active_channels}") logger.info(f"private channels: {self.total_private_channels}") logger.info(f"capacity: {self.total_capacity}") logger.info(f"balancedness: l:{balancedness_local:.2%} r:{balancedness_remote:.2%}") logger.info(f"total satoshis received (current channels): {self.total_satoshis_received}") logger.info(f"total satoshis sent (current channels): {self.total_satoshis_sent}")
train_data = torchvision.datasets.MNIST(root='./mnist', train=True, transform=torchvision.transforms.ToTensor(), download=True) test_data = torchvision.datasets.MNIST(root='./mnist/', transform=torchvision.transforms.ToTensor(), train=False) train_loader = Data.DataLoader(dataset=train_data, batch_size=128, shuffle=True) test_loader = Data.DataLoader(dataset=test_data, batch_size=128, shuffle=False) train_batch_num = len(train_loader) test_batch_num = len(test_loader) net = Network() print('net: ', net) # if torch.cuda.is_available(): if False: net = nn.DataParallel(net) net.cuda() opt = torch.optim.Adam(net.parameters(), lr=0.001) loss_func = nn.CrossEntropyLoss() for epoch_index in range(10): st = time.time() torch.set_grad_enabled(True) net.train() for train_batch_index, (img_batch, label_batch) in enumerate(train_loader):