def __init__(self, model=None, fixed=False):
super(Decoder3, self).__init__()
self.fixed = fixed
self.conv31 = nn.Conv2d(256, 128, 3, 1, 0)
self.conv22 = nn.Conv2d(128, 128, 3, 1, 0)
self.conv21 = nn.Conv2d(128, 64, 3, 1, 0)
self.conv12 = nn.Conv2d(64, 64, 3, 1, 0)
self.conv11 = nn.Conv2d(64, 3, 3, 1, 0)
self.relu = nn.ReLU(inplace=True)
self.unpool = nn.UpsamplingNearest2d(scale_factor=2)
self.pad = nn.ReflectionPad2d((1, 1, 1, 1))
if model:
assert (os.path.splitext(model)[1] in {".t7", ".pth"})
if model.endswith(".t7"):
t7_model = torchfile.load(model)
load_param(t7_model, 1, self.conv31)
load_param(t7_model, 5, self.conv22)
load_param(t7_model, 8, self.conv21)
load_param(t7_model, 12, self.conv12)
load_param(t7_model, 15, self.conv11)
else:
self.load_state_dict(
torch.load(model,
map_location=lambda storage, location: storage))
if fixed:
for param in self.parameters():
param.requires_grad = False
def __init__(self, model=None, fixed=False):
super(Encoder1, self).__init__()
self.fixed = fixed
self.conv0 = nn.Conv2d(3, 3, 1, 1, 0)
self.conv11 = nn.Conv2d(3, 64, 3, 1, 0, dilation=1)
self.relu = nn.ReLU(inplace=True)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2, return_indices=False)
self.pad = nn.ReflectionPad2d((1, 1, 1, 1))
if model:
assert (os.path.splitext(model)[1] in {".t7", ".pth"})
if model.endswith(".t7"):
t7_model = torchfile.load(model)
load_param(t7_model, 0, self.conv0)
load_param(t7_model, 2, self.conv11)
else:
self.load_state_dict(
torch.load(model,
map_location=lambda storage, location: storage))
if fixed:
for param in self.parameters():
param.requires_grad = False
def get_rbf_mran_and_hist_len(study_folder, exe_mode):
param_file = study_folder + '/model/param.yaml'
train_file = study_folder + '/data/train.txt'
with open(train_file, mode='r') as f:
l = f.readlines()
train_datas = [list(map(float, s.strip().split())) for s in l]
param = load_param(param_file)
hist_len = param['past_sys_output_num']
rbf_mran = RBF_MRAN(
nu=int(train_datas[2][0]), # システム入力(制御入力)の次元
ny=int(train_datas[1][0]), # システム出力ベクトルの次元
past_sys_input_num=param['past_sys_input_num'], # 過去のシステム入力保存数
past_sys_output_num=hist_len, # 過去のシステム出力保存数
# init_h=param['init_h'], # スタート時の隠れニューロン数
init_h=0, # スタート時の隠れニューロン数
E1=param['E1'],
E2=param['E2'],
E3=param['E3'],
E3_max=param['E3_max'],
E3_min=param['E3_min'],
gamma=param['gamma'],
Nw=param['Nw'],
Sw=param['Sw'],
kappa=param['kappa'] if 'kappa' in param else 1.0,
p0=param['p'] if 'p' in param else 1.0,
q=param['q'] if 'q' in param else 0.1,
study_folder=study_folder,
use_exist_net=True, # 既存のネットワークを使うかどうか
exe_mode=exe_mode)
return rbf_mran, hist_len
def load_data(**kwargs):
"""
- **kwargs will add/overwrite any set parameters in param.
"""
param = utils.load_param(**kwargs)
if param['device'] == "cuda":
# Find optimal device and use it
sleeptime = random.randint(0, 3)
time.sleep(sleeptime)
if os.environ.get(
'interactive_v2'
) == "true": #only run this in interactive as production pods doesnt support it
param['device'] = utils.get_best_cuda()
torch.cuda.set_device(param['device'])
torch.set_default_tensor_type('torch.cuda.FloatTensor')
ind2val, itemattr, dataloaders = dataset.load_dataloaders(
data_dir=param['data_dir'],
batch_size=param['batch_size'],
split_trainvalid=param['split_trainvalid'],
t_testsplit=param['t_testsplit'],
sample_uniform_action=param.get('sample_uniform_action', False))
noclick_rate = (dataloaders['train'].dataset.data['click'] == 1).float(
).sum() / (dataloaders['train'].dataset.data['click'] > 0).float().sum()
logging.info(f"Loaded dataset has {noclick_rate*100:.1f}% of noClick.")
param['num_items'] = len(ind2val['itemId'])
param['num_groups'] = len(np.unique(itemattr['category']))
param['num_users'], param['maxlen_time'], _ = dataloaders[
'train'].dataset.data['action'].size()
param['num_users'] = dataloaders['train'].dataset.data['userId'].max() + 1
return param, ind2val, itemattr, dataloaders
def def_optimizer_param(**kw):
optimizer_type = "tp"
lr = 1.0e-2
lr_decoder = 10 * lr
sub_optimizer_type = "sgd"
lr_decay_method = "linear"
milestones = [[0.50, 1.0],[0.70, 1.0e-1], [0.85, 1.0e-2], [0.95, 1.0e-3]]
return load_param(locals())
def def_model_param(**kw): # define necessary model parameters here.
model_type = "RSLP_EI"
model_name = "RSLP_EI"
data_set = "cifar10"
batch_size = 64
optimize_method = "tp"
E_num = 400
I_num = 100
iter_time = 10
init_weight = {
"i":["input", 1.0e-3],
"f":["input", 1.0e-3],
"r":["input", 1.0e-3],
}
#loss coeffients
act_coeff = 0.0e-4
class_coeff = 1.00
class_loss_func = "CEL"
weight_coeff = 1.0e-5
hebb_coeff = 0.00 #Hebb loss
stab_coeff = 0.00 #loss that punishes divergence of neural activity along time.
noise_coeff = 0.0 #noise coefficient
separate_ei = True
cons_method = "abs" # methd to limit weight, which is used to implement Dale's Law.
class_loss_func = "CEL" # CEL: Cross Entropy Loss, MSE: Mean Square Error
if separate_ei:
act_func_e = ["relu", 1.0]
act_func_i = ["relu", 1.0]
time_const_e = 0.2
time_const_i = 0.4 # fast-spiking inhibitory neurons
Dale = ["r", "f"] # weights that conform to Dale's Law
else:
act_func = ["relu", 0.0]
time_const = 0.2
bias = False
return load_param(locals())
def main(**kwargs):
param = utils.load_param()
# Overwrite param with whatever is in kwargs:
try:
for key, val in kwargs.items():
logging.info(f"Overwriting parameter {key} to {val}.")
param[key] = val
except:
logging.info("ERROR: Did no overwrite of default param.")
if param['device'] == "cuda":
torch.set_default_tensor_type('torch.cuda.FloatTensor')
if param.get('real_data'):
logging.info("Loading real data")
ind2val, itemattr, dataloaders = prepare.load_dataloaders(
data_dir="data_real",
data_type="lake-noclickrate-0.2",
batch_size=param['batch_size'],
split_trainvalid=param['split_trainvalid'],
num_workers=0,
override_candidate_sampler="actual",
t_testsplit=param['t_testsplit'])
else:
sim_param = utils.load_sim_param()
#%% Place all items in a group:
item_group = 1 + (torch.arange(sim_param['num_items']) //
(sim_param['num_items'] /
(sim_param['num_groups'] - 1))).long()
item_group[:3] = 0 # first three items are special group
itemattr = {'category': item_group.cpu().numpy()}
# %% TRAIN: MODEL+CALLBACKS+TRAINER
pyro.clear_param_store()
env = models.PyroRecommender(**sim_param,
item_group=torch.tensor(
itemattr['category']))
env.init_set_of_real_parameters()
sim = simulator.Simulator(**sim_param, env=env)
ind2val, itemattr, dataloaders, sim = simulator.collect_simulated_data(
sim,
policy_epsilon=sim_param['collect_data_randompct'],
**sim_param)
param['num_items'] = len(ind2val['itemId'])
param['num_groups'] = len(np.unique(itemattr['category']))
param['num_users'], param['maxlen_time'], _ = dataloaders[
'train'].dataset.data['action'].size()
param['num_users'] = param['num_users'] + 1
#param['num_displayTypes'] = 3
# Move data to device
#for key, val in dataloaders['train'].dataset.data.items():
# dataloaders['train'].dataset.data[key] = val.to(param['device'])
#%%
pyro.clear_param_store()
pyro.validation_enabled(True)
torch.manual_seed(param['train_seed'])
import pyrotrainer
dummybatch = next(iter(dataloaders['train']))
dummybatch['phase_mask'] = dummybatch['mask_train']
dummybatch = {
key: val.long().to(param.get("device"))
for key, val in dummybatch.items()
}
model = models.PyroRecommender(**param,
item_group=torch.tensor(
itemattr['category']).long())
guide = models.MeanFieldGuide(model=model, batch=dummybatch, **param)
#%% START WITH TRUE PARAMETERS IF THIS IS TRUE:
if param.get("start_true"):
logging.info(f"Starting in true mean parameters...:")
pyro.clear_param_store()
for key, val in env.par_real.items():
pyro.param(f"{key}-mean", val)
pyro.param(f"{key}-scale", torch.zeros_like(val) + 1e-5)
print(key)
#%% Define callbacks:
# Common callbacks:
optim = pyrotrainer.SviStep(model=model, guide=guide, **param)
step_callbacks = [optim, pyrotrainer.calc_batch_stats]
phase_end_callbacks = [
pyrotrainer.report_phase_end,
pyrotrainer.ReportPyroParameters(),
pyrotrainer.EarlyStoppingAndCheckpoint(
stopping_criteria=param['stopping_criteria'],
patience=param['patience'],
name=param['name'])
]
after_training_callbacks = []
if param['real_data']:
plot_finn_ads = pyrotrainer.PlotFinnAdsRecommended(ind2val,
epoch_interval=3)
phase_end_callbacks.append(plot_finn_ads)
after_training_callbacks.append(pyrotrainer.VisualizeEmbeddings())
else:
test_sim = simulator.Simulator(**param, env=env)
step_callbacks.append(pyrotrainer.Simulator_batch_stats(test_sim))
after_training_callbacks.append(
pyrotrainer.VisualizeEmbeddings(sim=test_sim))
after_training_callbacks.append(
pyrotrainer.RewardComputation(param, test_sim))
after_training_callbacks.append(pyrotrainer.ReportHparam(param))
#%%
trainer = pyrotrainer.PyroTrainer(
model,
guide,
dataloaders,
before_training_callbacks=[pyrotrainer.checksum_data],
after_training_callbacks=after_training_callbacks,
step_callbacks=step_callbacks,
phase_end_callbacks=phase_end_callbacks,
max_epoch=param['max_epochs'],
**param)
return param, ind2val, trainer
def def_trainer_param(**kw):
epoch_num = 120
save_model = True
save_model_interval = 10
save_model_path = "../saved_models/"
return load_param(locals())
def def_data_loader_param(**kw):
data_set = "cifar10"
batch_size = 64
return load_param(locals())
def __init__(self, model=None, fixed=False):
super(Encoder5, self).__init__()
self.fixed = fixed
self.conv0 = nn.Conv2d(3, 3, 1, 1, 0)
self.conv0.weight = nn.Parameter(
torch.from_numpy(
np.array([[[[0]], [[0]], [[255]]], [[[0]], [[255]], [[0]]],
[[[255]], [[0]], [[0]]]])).float())
self.conv0.bias = nn.Parameter(
torch.from_numpy(np.array([-103.939, -116.779, -123.68])).float())
self.conv11 = nn.Conv2d(3, 64, 3, 1, 0) # conv1_1
self.conv12 = nn.Conv2d(64, 64, 3, 1, 0) # conv1_2
self.conv21 = nn.Conv2d(64, 128, 3, 1, 0) # conv2_1
self.conv22 = nn.Conv2d(128, 128, 3, 1, 0) # conv2_2
self.conv31 = nn.Conv2d(128, 256, 3, 1, 0) # conv3_1
self.conv32 = nn.Conv2d(256, 256, 3, 1, 0) # conv3_2
self.conv33 = nn.Conv2d(256, 256, 3, 1, 0) # conv3_3
self.conv34 = nn.Conv2d(256, 256, 3, 1, 0) # conv3_4
self.conv41 = nn.Conv2d(256, 512, 3, 1, 0) # conv4_1
self.conv42 = nn.Conv2d(512, 512, 3, 1, 0) # conv4_2
self.conv43 = nn.Conv2d(512, 512, 3, 1, 0) # conv4_3
self.conv44 = nn.Conv2d(512, 512, 3, 1, 0) # conv4_4
self.conv51 = nn.Conv2d(512, 512, 3, 1, 0) # conv5_1
self.relu = nn.ReLU(inplace=True)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2, return_indices=False)
self.pad = nn.ReflectionPad2d((1, 1, 1, 1))
if model:
assert (os.path.splitext(model)[1] in {".t7", ".pth"})
if model.endswith(".t7"):
t7_model = torchfile.load(model)
## load from my normalised t7 model, which has no conv0 layer.
# load_param(t7_model, 0, self.conv11)
# load_param(t7_model, 2, self.conv12)
# load_param(t7_model, 5, self.conv21)
# load_param(t7_model, 7, self.conv22)
# load_param(t7_model, 10, self.conv31)
# load_param(t7_model, 12, self.conv32)
# load_param(t7_model, 14, self.conv33)
# load_param(t7_model, 16, self.conv34)
# load_param(t7_model, 19, self.conv41)
# load_param(t7_model, 21, self.conv42)
# load_param(t7_model, 23, self.conv43)
# load_param(t7_model, 25, self.conv44)
# load_param(t7_model, 28, self.conv51)
# load_param(t7_model, 30, self.conv52)
load_param(t7_model, 0, self.conv0)
load_param(t7_model, 2, self.conv11)
load_param(t7_model, 5, self.conv12)
load_param(t7_model, 9, self.conv21)
load_param(t7_model, 12, self.conv22)
load_param(t7_model, 16, self.conv31)
load_param(t7_model, 19, self.conv32)
load_param(t7_model, 22, self.conv33)
load_param(t7_model, 25, self.conv34)
load_param(t7_model, 29, self.conv41)
load_param(t7_model, 32, self.conv42)
load_param(t7_model, 35, self.conv43)
load_param(t7_model, 38, self.conv44)
load_param(t7_model, 42, self.conv51)
else:
self.load_state_dict(
torch.load(model,
map_location=lambda storage, location: storage))
if fixed:
for param in self.parameters():
param.requires_grad = False
def __init__(self, model=None, fixed=False):
super(Encoder4, self).__init__()
self.fixed = fixed
self.conv0 = nn.Conv2d(3, 3, 1, 1, 0)
self.conv11 = nn.Conv2d(3, 64, 3, 1, 0) # conv1_1
self.conv12 = nn.Conv2d(64, 64, 3, 1, 0) # conv1_2
self.conv21 = nn.Conv2d(64, 128, 3, 1, 0) # conv2_1
self.conv22 = nn.Conv2d(128, 128, 3, 1, 0) # conv2_2
self.conv31 = nn.Conv2d(128, 256, 3, 1, 0) # conv3_1
self.conv32 = nn.Conv2d(256, 256, 3, 1, 0) # conv3_2
self.conv33 = nn.Conv2d(256, 256, 3, 1, 0) # conv3_3
self.conv34 = nn.Conv2d(256, 256, 3, 1, 0) # conv3_4
self.conv41 = nn.Conv2d(256, 512, 3, 1, 0) # conv4_1
self.relu = nn.ReLU(inplace=True)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2, return_indices=False)
self.pad = nn.ReflectionPad2d((1, 1, 1, 1))
if model:
assert (os.path.splitext(model)[1] in {".t7", ".pth"})
if model.endswith(".t7"):
t7_model = torchfile.load(model)
load_param(t7_model, 0, self.conv0)
load_param(t7_model, 2, self.conv11)
load_param(t7_model, 5, self.conv12)
load_param(t7_model, 9, self.conv21)
load_param(t7_model, 12, self.conv22)
load_param(t7_model, 16, self.conv31)
load_param(t7_model, 19, self.conv32)
load_param(t7_model, 22, self.conv33)
load_param(t7_model, 25, self.conv34)
load_param(t7_model, 29, self.conv41)
else:
self.load_state_dict(
torch.load(model,
map_location=lambda storage, location: storage))
if fixed:
for param in self.parameters():
param.requires_grad = False
def start():
# Get Pythings version
env.pythings_version = common.get_pythings_version()
print('\n|--------------------------|')
print('| Starting PythingsOS :) |')
print('|--------------------------|')
print(' Version: {}'.format(env.pythings_version))
print(' Platform: {}'.format(platform))
try: print(' Thing ID: {}\n'.format(hal.get_tid()))
except: pass
# Init hardware and platform
hal.init()
pal.init()
# Start setup mode if required
if hal.HW_SUPPORTS_RESETCAUSE and hal.HW_SUPPORTS_WLAN and hal.get_reset_cause() in hal.WEBSETUP_RESETCAUSES:
setup_timeout = int(load_param('setup_timeout', 60))
if setup_timeout:
if hal.HW_SUPPORTS_LED: hal.LED.on()
from websetup import websetup
gc.collect()
websetup(timeout_s=setup_timeout)
if hal.HW_SUPPORTS_LED: hal.LED.off()
logger.info('Resetting...')
hal.reboot()
# Disable AP mode, Enable and configure STA mode
if hal.HW_SUPPORTS_WLAN:
hal.WLAN.ap_active(False)
hal.WLAN.sta_active(True)
# Start loading settings and parameters
from utils import load_settings
env.settings = load_settings()
env.payload_encrypter = None # Initalization
# Load backend: the local param wins
env.backend = load_param('backend', None)
if not env.backend:
backend_overrided = False
if 'backend' in env.settings and env.settings['backend']:
env.backend = env.settings['backend']
else:
env.backend = 'backend.pythings.io'
else:
backend_overrided = True
# Load aid and tid: only local param or default
env.aid = load_param('aid', None)
if env.aid is None:
logger.critical('AID not provided, stopping here. Please set it up!')
import time
while True:
time.sleep(1)
env.tid = load_param('tid', None)
if env.tid is None: env.tid = hal.get_tid()
# Load pool: the local param wins
env.pool = load_param('pool', None)
if not env.pool:
if 'pool' in env.settings and env.settings['pool']:
env.pool = env.settings['pool']
env.frozen = hal.is_frozen()
# Tasks placeholders
env.app_workerTask = None
env.app_managementTask = None
# Report
logger.info('Running with backend="{}" and aid="{}"'.format(env.backend, env.aid))
# Get app version:
env.app_version = common.get_app_version()
# Register and perform the first management task call on "safe" backend, if not overrided
if not backend_overrided:
backend_set = env.backend
env.backend ='backend.pythings.io'
# Pre-register if payload encryption activated
use_payload_encryption = env.settings['payload_encryption'] if 'payload_encryption' in env.settings else hal.USE_ENCRYPTION_DEFAULT
if use_payload_encryption and hal.HW_SUPPORTS_ENCRYPTION and pal.get_payload_encrypter():
logger.info('Enabling Payload Encryption and preregistering')
env.payload_encrypter = pal.get_payload_encrypter()(comp_mode=True)
from preregister import preregister
token = preregister()
env.token = token
logger.info('Got token: {}'.format(env.token))
del preregister
gc.collect()
# Register yourself, and start a new session
from register import register
token, epoch = register()
if not env.payload_encrypter:
env.token = token
logger.info('Got token: {}'.format(env.token))
del register
gc.collect()
# Sync time and add to env
chronos = hal.Chronos(epoch)
env.chronos = chronos
# Call system management (will update App/Pythings versions and settings if required)
logger.info('Calling system management (preloop)')
from management import system_management_task
system_management_task(chronos)
del system_management_task
gc.collect()
# Set back host to the proper one
if not backend_overrided:
env.backend=backend_set
del backend_set
gc.collect()
# Init app
try:
from worker_task import WorkerTask
env.app_workerTask = WorkerTask()
except Exception as e:
logger.error('Error in importing/loading app\'s worker tasks: {} {}'.format(e.__class__.__name__, e))
logger.debug(pal.get_traceback(e))
from api import report
common.run_controlled(2,report,what='worker', status='KO', message='{} {} ({})'.format(e.__class__.__name__, e, pal.get_traceback(e)))
try:
from management_task import ManagementTask
env.app_managementTask = ManagementTask()
except Exception as e:
logger.error('Error in importing/loading app\'s management tasks: {} {}'.format(e.__class__.__name__, e))
logger.debug(pal.get_traceback(e))
from api import report
common.run_controlled(2,report,what='management', status='KO', message='{} {} ({})'.format(e.__class__.__name__, e, pal.get_traceback(e)))
# Setup intervals
worker_interval = int(env.settings['worker_interval']) if 'worker_interval' in env.settings else 300
management_interval = int(env.settings['management_interval']) if 'management_interval' in env.settings else 60
# Start main loop
loop_count = 0
while True:
if loop_count % management_interval == 0:
logger.info('Calling management (loop={})'.format(loop_count))
if hal.HW_SUPPORTS_LED:
hal.LED.on(); sleep(0.05); hal.LED.off()
from management import system_management_task
system_management_task(chronos)
del system_management_task
gc.collect()
logger.info('Done management')
if loop_count % worker_interval == 0:
logger.info('Calling worker (loop={})'.format(loop_count))
from worker import system_worker_task
system_worker_task(chronos)
del system_worker_task
gc.collect()
logger.info('Done worker')
loop_count+=1
sleep(1)
# Imports
from time import sleep
import gc
import env
import common
import hal
import pal
from utils import load_param
from platform import platform
# Logger
import logger
logger.level = int(load_param('loglevel', logger.INFO))
# Start
def start():
# Get Pythings version
env.pythings_version = common.get_pythings_version()
print('\n|--------------------------|')
print('| Starting PythingsOS :) |')
print('|--------------------------|')
print(' Version: {}'.format(env.pythings_version))
print(' Platform: {}'.format(platform))
try: print(' Thing ID: {}\n'.format(hal.get_tid()))
except: pass
# Init hardware and platform
hal.init()
gen_res = gen_data(
sys_type=args.sys, train_file=train_file, test_file=test_file,
data_len=args.data_len, ncx=args.n_change_x, ncu=args.n_change_u,
xb=args.x_before, xa=args.x_after, ub=args.u_before, ua=args.u_after)
if gen_res < 0 :
exit()
assert os.path.isfile(train_file), 'No train.txt!!!! exit.'
assert os.path.isfile(test_file), 'No test.txt!!! exit.'
# パラメータファイル生成or読み込み
param_file = study_folder+'/model/'+args.param_file
if args.param_file == 'param.yaml' and not os.path.isfile(param_file) :
gen_param_file_from_cmd(param_file)
param = load_param(param_file)
with open(train_file, mode='r') as f:
l = f.readlines()
datas = [list(map(float, s.strip().split())) for s in l]
rbf_mran = RBF_MRAN(
nu=int(datas[2][0]), # システム入力(制御入力)の次元
ny=int(datas[1][0]), # システム出力ベクトルの次元
past_sys_input_num=param['past_sys_input_num'], # 過去のシステム入力保存数
past_sys_output_num=param['past_sys_output_num'], # 過去のシステム出力保存数
# init_h=param['init_h'], # スタート時の隠れニューロン数
init_h=args.init_h, # スタート時の隠れニューロン数
E1=param['E1'],
E2=param['E2'],
E3=param['E3'],
E3_max=param['E3_max'],
import pyro
import logging
import simulator
import torch
import matplotlib.pyplot as plt
from torch.nn import functional as F
import pyro
import pyro.distributions as dist
import models
import numpy as np
logging.basicConfig(format='%(asctime)s %(message)s', level='INFO')
import prepare
from prepare import SequentialDataset
# %%
param = utils.load_param()
# Overwrite param with whatever is in kwargs:
try:
for key, va.l in kwargs.items():
logging.info(f"Overwriting parameter {key} to {val}.")
param[key] = val
except:
logging.info("Did no overwrite of default param.")
if param['device'] == "cuda":
torch.set_default_tensor_type('torch.cuda.FloatTensor')
if param.get('real_data'):
logging.info("Loading real data")
ind2val, itemattr, dataloaders = prepare.load_dataloaders(
def at_post(url, data, dest=None):
# Do we have the Modem ready?
try:
env.modem
except AttributeError:
# Do we have to load custom pins?
modem_pins = load_param('modem_pins', None)
if modem_pins:
MODEM_PWKEY_PIN, MODEM_RST_PIN, MODEM_POWER_ON_PIN, MODEM_TX_PIN, MODEM_RX_PIN = [
int(pin) if pin != 'None' else None
for pin in modem_pins.split(',')
]
# Create new modem object on the right Pins
if platform.startswith('esp8266'):
from machine import SOFTUART
uart = Uart(
SOFTUART(tx=MODEM_TX_PIN if modem_pins else hal.MODEM_TX_PIN,
rx=MODEM_RX_PIN if modem_pins else hal.MODEM_RX_PIN,
baudrate=9600))
env.modem = Modem(uart)
else:
env.modem = Modem(
MODEM_PWKEY_PIN=MODEM_PWKEY_PIN
if modem_pins else hal.MODEM_PWKEY_PIN,
MODEM_RST_PIN=MODEM_RST_PIN
if modem_pins else hal.MODEM_RST_PIN,
MODEM_POWER_ON_PIN=MODEM_POWER_ON_PIN
if modem_pins else hal.MODEM_POWER_ON_PIN,
MODEM_TX_PIN=MODEM_TX_PIN if modem_pins else hal.MODEM_TX_PIN,
MODEM_RX_PIN=MODEM_RX_PIN if modem_pins else hal.MODEM_RX_PIN)
env.modem.initialize()
# Always connect, as if it is already connected won't do anything
env.modem.connect(apn=env.apn)
#----------------------
# Post start
#----------------------
try:
token = env.token
except AttributeError:
token = None
if token: data['token'] = token
logger.debug('Calling POST "{}" with data'.format(url), data)
# If POST fails do not have an exception when closing file in the finally
if dest: f = None
try:
if dest: f = open(dest, 'w')
# Execute POST
response = env.modem.http_request('http://' + url, 'POST',
json.dumps(data), 'application/json')
logger.debug('Received status code', response.status_code)
logger.debug('Received content', response.content)
status = response.status_code
content = response.content
if dest and status == 200:
f.write(content)
else:
if content is None:
content = ''
return {
'version': None,
'status': status,
'msg': None,
'content': content
}
except:
raise
finally:
if dest and f:
f.close()
def readline(self):
line = bytes()
while True:
char = chr(self.softuart.get())
if char == '\x00':
return line
line += char.encode('utf8')
if char == '\n':
return line
# Do we have a modem configured?
try:
env.apn
except AttributeError:
env.apn = load_param('apn', None)
# Should we use AT-based, modem POST?
if (not network.WLAN(network.STA_IF).isconnected()) and env.apn:
logger.debug('Using AT post')
use_at_post = True
else:
logger.debug('Using socket post')
use_at_post = False
# Define AT-based post for AT modems
def at_post(url, data, dest=None):
# Do we have the Modem ready?
try:
Vocabulary = freq_of_words.most_common(vocabulary_size-1)
#Make Index - to - Word Vector
idx_to_wd = [v[0] for v in Vocabulary]
idx_to_wd.append(not_known)
#Make Word - to - Index Vector
wd_to_idx = dict([(word, idx) for idx, word in enumerate(idx_to_wd)])
print "The current length of vocab = %d." % vocabulary_size
print "The least frequent word = %s." % Vocabulary[-1][0]
print "The number of times of appearance of the least frequent word = %d." % Vocabulary[-1][1]
#The words not present in our vocab are changed to 'not_known' token
for i, s in enumerate(sen_token):
sen_token[i] = [Word if Word in wd_to_idx else not_known for Word in s]
train_data = np.asarray([[wd_to_idx[Word] for Word in s[:-1]] for s in sen_token])
train_label = np.asarray([[wd_to_idx[Word] for Word in s[1:]] for s in sen_token])
model = RNNLanguageModel(vocabulary_size, hidden_size=_Hidden)
samay1 = time.time()
model.grad_descent(train_data[10], train_label[10], _Alpha)
samay2 = time.time()
print "Time of Gradient Descent step = %f ms" % ((samay2 - samay1) * 1000.)
if _Model != None:
utils.load_param(_Model, model)
train(model, train_data, train_label, epochs = _Epochs, alpha = _Alpha)
