class mc_mat(gym.Env):
def __init__(self):
self.mlab = Matlab(matlab='/Applications/MATLAB_R2014a.app/bin/matlab')
self.mlab.stop()
self.mlab.start()
self.action_space = spaces.Discrete(4)
self.observation_space = spaces.Discrete(4)
self.round = 2
self.LAM = round(random.uniform(0.1, 20), 3)
self.D = round(np.random.uniform(5, 40), 2)
self.N_n = np.random.randint(5, 20)
self.N_0 = round(random.uniform(5, 20), 3)
# self.observation = np.array([self.LAM, self.D, self.N_n, self.N_0])#.reshape(1,4)
self.observation = (self.LAM, self.D, self.N_n, self.N_0
) #.reshape(1,4)
self._reset()
def _step(self, action):
assert self.action_space.contains(action)
res = self.mlab.run(
'/Users/zonemercy/Documents/MATLAB/mc_gym/Copy_of_oraginal.m', {
'arg1': 1,
'arg2': self.LAM,
'arg3': self.D,
'arg4': self.N_0,
'arg5': self.N_n
})
# esb = res['result']
esb = [round(elm, self.round) for elm in res['result']]
result = np.where(esb == np.min(esb))[0]
if action in result:
reward = 10
done = True
else:
reward = 0
done = False
# return self.observation, reward, done, {"action": action, "result": result,'esb':esb}
return self.observation, reward, done, {}
def _reset(self):
self.LAM = round(random.uniform(0.1, 20), 3)
self.D = round(np.random.uniform(5, 40), 2)
self.N_n = np.random.randint(5, 20)
self.N_0 = round(random.uniform(5, 20), 3)
# self.observation = np.array([self.LAM, self.D, self.N_n, self.N_0])#.reshape(1,4)
self.observation = (self.LAM, self.D, self.N_n, self.N_0)
return self.observation
def _configure(self, nround=3, close_mat=False):
self.round = nround
if close_mat == True:
self.mlab.stop()
class MatlabCaller:
"""
bridging class with matlab
"""
def __init__(self, port=14001, id=None):
if id is None:
id = numpy.random.RandomState(1234)
# Initialise MATLAB
self.mlab = Matlab(port=port, id=id)
def start(self):
# Start the server
self.mlab.start()
def stop(self):
self.mlab.stop()
os.system('pkill MATLAB')
def call_fn(self, path=None, params=None):
"""
path: the path to your .m function
params: dictionary contains all parameters
"""
assert path is not None
assert isinstance(params, dict)
return self.mlab.run(path, params)['result']
def worker(cls, args):
mlab_path, reqid, respath, srcpath, subnets = args
mlab = Matlab(executable=mlab_path)
mlab.start()
try:
# setting variables
log.error(msg="Setting Matlab variables", context="HTTP")
success = True
success &= mlab_setvar(mlab, "DH_Simulator_AllSubnets",
','.join(subnets))
success &= mlab_setvar(mlab, "DH_Simulator_SimulationID", reqid)
success &= mlab_setvar(mlab, "DH_Simulator_ResultsPath", respath)
success &= mlab_setvar(mlab, "DH_Simulator_ScriptPath", srcpath)
if not success:
log.error(msg="Unable to set some variables", context="HTTP")
else:
# running simulation
log.error(msg="Starting simulation", context="HTTP")
mlab.run_code("cd mlab")
mlab.run_code("peak")
log.error(msg="Simulation ended", context="HTTP")
finally:
mlab.stop()
archive_dir = os.path.join(respath, reqid)
shutil.make_archive(archive_dir, "zip", archive_dir)
return reqid
class MATLAB:
def __init__(self):
print "Initializing MATLAB."
self.mlab = Matlab()
print "Done initializing MATLAB."
def connect(self):
self.mlab.start()
def disconnect(self):
if(self.mlab.started):
self.mlab.stop()
else:
print "Tried to disconnect from MATLAB without being connected."
def run_code(self, code):
try:
r = self.mlab.run_code(code)
except Exception as exc:
raise RuntimeError("Problem executing matlab code: %s" % exc)
else:
if(not r['success']):
raise RuntimeError(
"Problem executing matlab code: %s: %s" % (code, r['content']))
def getvalue(self, var):
return self.mlab.get_variable(var)
def tucker(self, coreNway, lam, init=None):
# 初始化
if init is None:
A0, C0 = self.tucker_init(*coreNway)
else:
assert len(init) == 4
A0 = init[:3]
C0 = init[-1]
mlab = Matlab()
mlab.start()
while True:
res = mlab.run_func(
'tucker.m', self.R, coreNway, {
'hosvd': 1,
'lam': lam,
'maxit': 4000,
'A0': A0,
'C0': C0,
'tol': 1e-5
})
if res['success']:
break
mlab.stop()
O, D, T, C = res['result']
return TuckerResult(self.R, O, D, T, C)
def fix_model(self,
W,
intMat,
drugMat,
targetMat,
num,
cvs,
dataset,
seed=None):
self.dataset = dataset
self.num = num
self.cvs = cvs
self.seed = seed
R = W * intMat
drugMat = (drugMat + drugMat.T) / 2
targetMat = (targetMat + targetMat.T) / 2
mlab = Matlab()
mlab.start()
# print os.getcwd()
# self.predictR = mlab.run_func(os.sep.join([os.getcwd(), "kbmf2k", "kbmf.m"]), {'Kx': drugMat, 'Kz': targetMat, 'Y': R, 'R': self.num_factors})['result']
res = mlab.run_func(
os.path.realpath(os.sep.join(['kbmf2k', "kbmf.m"])), {
'Kx': drugMat,
'Kz': targetMat,
'Y': R,
'R': self.num_factors
})
self.predictR = res['result']
# print os.path.realpath(os.sep.join(['../kbmf2k', "kbmf.m"]))
mlab.stop()
class MatlabProcessor(PwebProcessor):
"""Runs Matlab code usinng python-matlab-brigde"""
def __init__(self, parsed, source, mode, formatdict):
from pymatbridge import Matlab
self.matlab = Matlab()
self.matlab.start()
PwebProcessor.__init__(self, parsed, source, mode, formatdict)
def getresults(self):
self.matlab.stop()
return copy.copy(self.executed)
def loadstring(self,
code_string,
chunk=None,
scope=PwebProcessorGlobals.globals):
result = self.matlab.run_code(code_string)
if chunk is not None and len(result["content"]["figures"]) > 0:
chunk["matlab_figures"] = result["content"]["figures"]
return result["content"]["stdout"]
def loadterm(self, code_string, chunk=None):
result = self.loadstring(code_string)
return result
def init_matplotlib(self):
pass
def savefigs(self, chunk):
if not "matlab_figures" in chunk:
return []
if chunk['name'] is None:
prefix = self.basename + '_figure' + str(chunk['number'])
else:
prefix = self.basename + '_' + chunk['name']
figdir = os.path.join(self.cwd, rcParams["figdir"])
if not os.path.isdir(figdir):
os.mkdir(figdir)
fignames = []
i = 1
for fig in reversed(
chunk["matlab_figures"]
): #python-matlab-bridge returns figures in reverse order
#TODO See if its possible to get diffent figure formats. Either fork python-matlab-bridge or use imagemagick
name = figdir + "/" + prefix + "_" + str(
i) + ".png" #self.formatdict['figfmt']
shutil.copyfile(fig, name)
fignames.append(name)
i += 1
return fignames
def add_echo(self, code_str):
"""Format inline chunk code to show results"""
return "disp(%s)" % code_str
class MatlabEngine(object):
def __init__(self):
if 'OCTAVE_EXECUTABLE' in os.environ:
self._engine = Octave(os.environ['OCTAVE_EXECUTABLE'])
self._engine.start()
self.name = 'octave'
elif matlab_native:
self._engine = matlab.engine.start_matlab()
self.name = 'matlab'
else:
executable = os.environ.get('MATLAB_EXECUTABLE', 'matlab')
self._engine = Matlab(executable)
self._engine.start()
self.name = 'pymatbridge'
# add MATLAB-side helper functions to MATLAB's path
if self.name != 'octave':
kernel_path = os.path.dirname(os.path.realpath(__file__))
toolbox_path = os.path.join(kernel_path, 'toolbox')
self.run_code("addpath('%s');" % toolbox_path)
def run_code(self, code):
if matlab_native:
return self._run_native(code)
return self._engine.run_code(code)
def stop(self):
if matlab_native:
self._engine.exit()
else:
self._engine.stop()
def _run_native(self, code):
resp = dict(success=True, content=dict())
out = StringIO()
err = StringIO()
if sys.version_info[0] < 3:
code = str(code)
try:
self._engine.eval(code, nargout=0, stdout=out, stderr=err)
self._engine.eval('''
figures = {};
handles = get(0, 'children');
for hi = 1:length(handles)
datadir = fullfile(tempdir(), 'MatlabData');
if ~exist(datadir, 'dir'); mkdir(datadir); end
figures{hi} = [fullfile(datadir, ['MatlabFig', sprintf('%03d', hi)]), '.png'];
saveas(handles(hi), figures{hi});
if (strcmp(get(handles(hi), 'visible'), 'off')); close(handles(hi)); end
end''', nargout=0, stdout=out, stderr=err)
figures = self._engine.workspace['figures']
except (SyntaxError, MatlabExecutionError) as exc:
resp['content']['stdout'] = exc.args[0]
resp['success'] = False
else:
resp['content']['stdout'] = out.getvalue()
if figures:
resp['content']['figures'] = figures
return resp
def convertnctotiff(self):
self.cancelbtn.config(state="disabled")
matlabpath = "\"C:/Program Files/MATLAB/R2016b/bin/matlab\""
mlab = Matlab(executable=matlabpath)
ncfilefullpath = self.inputncdirtxtfield.get("1.0",
tk.END).encode("ascii")
ncfilefullpath = ncfilefullpath[0:-1]
#ncfilefullpathst = 'D:/NARSS/Research Project/2018-2019/01-01-2020/Task_NC-2-TIFF/input/GRCTellus.JPL.200204_201603.GLO.RL05M_1.MSCNv02CRIv02.nc'
#print('ncfilefullpathdyn: '+ncfilefullpath, type(ncfilefullpath))
tiffoutputdir = self.outputtiffdirtxtfield.get("1.0",
tk.END).encode("ascii")
tiffoutputdir = tiffoutputdir[0:-1]
tiffoutputdir = os.path.join(tiffoutputdir, '')
#tiffoutputdirst = 'D:/NARSS/Research Project/2018-2019/01-01-2020/Task_NC-2-TIFF/output/'
#print('tiffoutputdir: '+tiffoutputdir, type(tiffoutputdir))
ncvar = self.ncvartxtfield.get("1.0", tk.END).encode("ascii")
ncvar = ncvar[0:-1]
#ncvar = 'lwe_thickness'
#print('ncvar: '+ncvar, type(ncvar))
nctimes = self.nctimestxtfield.get("1.0", tk.END)
nctimes = int(nctimes)
#nctimes = 152
#print('nctimes: '+nctimes, type(nctimes))
mlab.start()
mlab.run_func(
'C:/Users/akotb/PycharmProjects/AGP_System/resources/netcdf_to_tiff.m',
{
'arg1': ncfilefullpath,
'arg2': ncvar,
'arg3': nctimes,
'arg4': tiffoutputdir
})
#self.conversionstartedlbl.grid_forget()
self.startconvertingnctotiffbtn.grid_forget()
self.cancelbtn.grid_forget()
# task status
self.conversioncompletedlbl = tk.Label(self.master,
text="Conversion Completed")
self.conversioncompletedlbl.grid(sticky='W',
padx=10,
pady=10,
row=5,
column=1)
self.closebtn = tk.Button(self.master,
text="Close",
width=15,
command=self.exit)
self.closebtn.grid(sticky='E', padx=10, pady=10, row=5, column=2)
mlab.stop()
def network_hill(panel, prior_graph=[], lambdas=[], max_indegree=3, reg_mode='full', stdise=1, silent=0, maxtime=120):
'''
run_hill(panel)
input: dataframe
should be a T x N dataframe with T time points and N samples.
output: dict containing key 'e' and key 'i' from Hill's code
'''
from scipy.io import savemat
from scipy.io import loadmat
# start matlab
mlab = Matlab(maxtime=maxtime)
mlab.start()
# .mat shuttle files
# add path check
inPath = os.path.join('..', 'cache', 'dbn_wrapper_in.mat')
outPath = os.path.join('..', 'cache', 'dbn_wrapper_out.mat')
D = np.transpose(panel.values)
num_rows = np.shape(D)[0]
num_cols = np.shape(D)[1]
D = np.reshape(D, (num_rows, num_cols, 1))
#D = np.transpose(panel, (2,1,0))
# save the matlab object that the DBN wrapper will load
# contains all the required parameters for the DBN code
savemat(inPath, {"D" : D,
"max_indegree" : max_indegree,
"prior_graph" : prior_graph,
"lambdas" : lambdas,
"reg_mode" : reg_mode,
"stdise" : stdise,
"silent" : silent})
# DBN wrapper just needs an input and output path
args = {"inPath" : inPath, "outPath" : outPath}
# call DBN code
res = mlab.run_func('dbn_wrapper.m', args, maxtime=maxtime)
mlab.stop()
out = loadmat(outPath)
edge_prob = pd.DataFrame(out['e'], index=panel.columns, columns=panel.columns)
edge_sign = pd.DataFrame(out['i'], index=panel.columns, columns=panel.columns)
#edge_prob = out['e']
#edge_sign = out['i']
return (edge_prob, edge_sign)
class MatlabProcessor(PwebProcessor):
"""Runs Matlab code usinng python-matlab-brigde"""
def __init__(self, parsed, source, mode, formatdict):
from pymatbridge import Matlab
self.matlab = Matlab()
self.matlab.start()
PwebProcessor.__init__(self, parsed, source, mode, formatdict)
def getresults(self):
self.matlab.stop()
return copy.copy(self.executed)
def loadstring(self, code_string, chunk=None, scope=PwebProcessorGlobals.globals):
result = self.matlab.run_code(code_string)
if chunk is not None and len(result["content"]["figures"]) > 0:
chunk["matlab_figures"] = result["content"]["figures"]
return result["content"]["stdout"]
def loadterm(self, code_string, chunk=None):
result = self.loadstring(code_string)
return result
def init_matplotlib(self):
pass
def savefigs(self, chunk):
if not "matlab_figures" in chunk:
return []
if chunk['name'] is None:
prefix = self.basename + '_figure' + str(chunk['number'])
else:
prefix = self.basename + '_' + chunk['name']
figdir = os.path.join(self.cwd, rcParams["figdir"])
if not os.path.isdir(figdir):
os.mkdir(figdir)
fignames = []
i = 1
for fig in reversed(chunk["matlab_figures"]): #python-matlab-bridge returns figures in reverse order
#TODO See if its possible to get diffent figure formats. Either fork python-matlab-bridge or use imagemagick
name = figdir + "/" + prefix + "_" + str(i) + ".png" #self.formatdict['figfmt']
shutil.copyfile(fig, name)
fignames.append(name)
i += 1
return fignames
def add_echo(self, code_str):
"""Format inline chunk code to show results"""
return "disp(%s)" % code_str
def test_init_end_to_end_distance(run_dir):
"""
Plot the end-to-end distance distribution for a set of runs' r0 versus the
theoretical distribution.
"""
if not os.path.isdir(os.path.join(run_dir, 'data', 'end_to_end_r0')):
wdata.aggregate_r0_group_NP_L0(run_dir)
m = Matlab()
m.start()
m.run_code("help pcalc")
m.stop()
def mask_to_region(self, path):
"""
Converts mask image into corresponding regions list
Arguments
---------
path : string
Path to mask image
Returns
-------
regions : list
"regions" for the dataset that the mask belongs to
"""
def remove_interiors(L, region):
"""
Removes interior pixels in neuron regions
Arguments
---------
L : 2D numpy array
Matrix containing labels for each neuron
region : list
List of all pixels in a neuron label
"""
for pixel in region:
# Creating grid around pixel
grid = L[pixel[0] - 1:pixel[0] + 2, pixel[1] - 1:pixel[1] + 2]
# Removing pixels which are surrounded by similar values
if np.unique(grid).size == 1:
region.remove(pixel)
return region
# Initializes Matlab to get labels for neurons using bwboundaries() method
cwd = os.getcwd()
matlab_file_path = os.path.join(cwd, 'utils',
'get_region_boundaries.m')
mlab = Matlab()
mlab.start()
matlab_result = mlab.run_func(matlab_file_path, {'arg1': path})
mlab.stop()
# `L` is 2D array with each neuron carrying a label 1 -> n
L = matlab_result['result']
n = int(L.max()) # Number of neurons
# Getting coordinates of pixels of neuron regions
# This includes interior pixels as well
regions = [{
"coordinates": list(zip(*np.where(L == float(i))))
} for i in range(1, n)]
# Removing interior pixels in neuron regions
for region in regions:
remove_interiors(L, region["coordinates"])
return regions
def fix_model(self, W, intMat, drugMat, targetMat, seed=None):
R = W*intMat
drugMat = (drugMat+drugMat.T)/2
targetMat = (targetMat+targetMat.T)/2
mlab = Matlab()
mlab.start()
# print os.getcwd()
# self.predictR = mlab.run_func(os.sep.join([os.getcwd(), "kbmf2k", "kbmf.m"]), {'Kx': drugMat, 'Kz': targetMat, 'Y': R, 'R': self.num_factors})['result']
self.predictR = mlab.run_func(os.path.realpath(os.sep.join(['../kbmf2k', "kbmf.m"])), {'Kx': drugMat, 'Kz': targetMat, 'Y': R, 'R': self.num_factors})['result']
# print os.path.realpath(os.sep.join(['../kbmf2k', "kbmf.m"]))
mlab.stop()
def plot_deltahist(fileName1, fileName2):
prog = find_executable('matlab')
if not prog:
sys.exit("Could not find MATLAB on the PATH. Exiting...")
else:
print("Found MATLAB in "+prog)
mlab = Matlab(executable=prog)
mlab.start()
results = mlab.run_func('./plot_deltahist.m', {'arg1': fileName1, 'arg2': fileName2})
mlab.stop()
def fix_model(self, W, intMat, drugMat, targetMat,num, cvs, dataset, seed=None):
self.dataset = dataset
self.num = num
self.cvs = cvs
self.seed = seed
R = W * intMat
#R = np.transpose(R)
drugMat = (drugMat + drugMat.T) / 2
targetMat = (targetMat + targetMat.T) / 2
mlab = Matlab()
mlab.start()
res = mlab.run_func(os.path.realpath(os.sep.join(['GRMF',"runGRMF.m"])),{'Kx': drugMat, 'Kz': targetMat, 'Y': R, 'cv': self.cv})
self.predictR = res['result']
mlab.stop()
1+1
def fix_model(self, W, intMat, drugMat, targetMat, seed=None):
R = W * intMat
drugMat = (drugMat + drugMat.T) / 2
targetMat = (targetMat + targetMat.T) / 2
mlab = Matlab('/Applications/MATLAB_R2014b.app/bin/matlab')
mlab.start()
# print os.getcwd()
# self.predictR = mlab.run_func(os.sep.join([os.getcwd(), "kbmf2k", "kbmf.m"]), {'Kx': drugMat, 'Kz': targetMat, 'Y': R, 'R': self.num_factors})['result']
self.predictR = mlab.run_func(
os.path.realpath(os.sep.join(['./kbmf2k', "kbmf.m"])), {
'Kx': drugMat,
'Kz': targetMat,
'Y': R,
'R': self.num_factors
})['result']
# print os.path.realpath(os.sep.join(['./kbmf2k', "kbmf.m"]))
mlab.stop()
def call_peak_picking(filepath, scriptpath):
""" Method connects to local Matlab via ZeroMQ and calls peak picking function there implemented in script path. """
start_time = time.time()
mlab = Matlab(
executable='/Applications/MATLAB_R2018a_floating.app/bin/matlab')
mlab.start()
response = mlab.run_func(scriptpath, {'path': filepath})
mlab.stop()
peaks = response['result']
print(time.time() - start_time, " seconds elapsed for peak picking")
print("Total number of peaks", len(peaks))
return peaks
def objective_function(self, x):
'''
matlabpath: we need the path to matlab since we need to run it.
IMPORTANT: walker_simulation.m must be included in the
WGCCM_three_link_walker_example file in order to work.
So simply modify the path below.
'''
mlab = Matlab(executable= matlabpath)
mlab.start()
output = mlab.run_func(os.path.join(self.matlab_code_directory, 'walker_simulation.m'),
{'arg1': x[:, 0],'arg2': x[:, 1],'arg3': x[:, 2],
'arg4': x[:, 3],'arg5':x[:, 4],'arg6': x[:, 5],
'arg7': x[:, 6],'arg8': x[:, 7],'arg9': self.num_steps})
answer = output['result']
simul_output = answer['speed']
mlab.stop()
class MatlabEngine(object):
def __init__(self):
if 'OCTAVE_EXECUTABLE' in os.environ:
self._engine = Octave(os.environ['OCTAVE_EXECUTABLE'])
self._engine.start()
self.name = 'octave'
elif matlab_native:
self._engine = matlab.engine.start_matlab()
self.name = 'matlab'
else:
executable = os.environ.get('MATLAB_EXECUTABLE', 'matlab')
self._engine = Matlab(executable)
self._engine.start()
self.name = 'pymatbridge'
# add MATLAB-side helper functions to MATLAB's path
if self.name != 'octave':
kernel_path = os.path.dirname(os.path.realpath(__file__))
toolbox_path = os.path.join(kernel_path, 'toolbox')
self.run_code("addpath('%s');" % toolbox_path)
def run_code(self, code):
if matlab_native:
return self._run_native(code)
return self._engine.run_code(code)
def stop(self):
if matlab_native:
self._engine.exit()
else:
self._engine.stop()
def _run_native(self, code):
out = StringIO()
err = StringIO()
if sys.version_info[0] < 3:
code = str(code)
try:
self._engine.eval(code, nargout=0, stdout=out, stderr=err)
except (SyntaxError, MatlabExecutionError) as exc:
return dict(success=False, content=dict(stdout=exc.args[0]))
return dict(success=True, content=dict(stdout=out.getvalue()))
def evaluation(self, test_data, test_label):
mlab = Matlab()
mlab.start()
res = mlab.run_func(
os.path.realpath(os.sep.join([os.getcwd(), "pudt", "PUDT.m"])), {
'w': self.w,
'dataset': self.dataset
})
self.predictR = res['result']
mlab.stop()
# score = self.predictR[test_data[:, 0], test_data[:, 1]]
score = self.predictR
import pandas as pd
score = pd.DataFrame(score)
score.to_csv('../data/datasets/EnsambleDTI/pudt_' + str(self.dataset) +
'_s' + str(self.cvs) + '_' + str(self.seed) + '_' +
str(self.num) + '.csv',
index=False)
prec, rec, thr = precision_recall_curve(np.array(score['test_label']),
np.array(score['score']))
aupr_val = auc(rec, prec)
# plt.step(rec, prec, color='b', alpha=0.2,
# where='post')
# plt.fill_between(rec, prec, step='post', alpha=0.2,
# color='b')
#
# plt.xlabel('Recall')
# plt.ylabel('Precision')
# plt.ylim([0.0, 1.05])
# plt.xlim([0.0, 1.0])
# plt.title('2-class Precision-Recall curve: AP={0:0.2f}')
fpr, tpr, thr = roc_curve(np.array(score['test_label']),
np.array(score['score']))
auc_val = auc(fpr, tpr)
print("AUPR: " + str(aupr_val) + ", AUC: " + str(auc_val))
return aupr_val, auc_val
class MatlabKernel(MetaKernel):
implementation = 'Matlab Kernel'
implementation_version = __version__,
language = 'matlab'
language_version = '0.1',
banner = "Matlab Kernel"
language_info = {
'mimetype': 'text/x-matlab',
'name': 'octave',
'file_extension': '.m',
'help_links': MetaKernel.help_links,
}
_first = True
def __init__(self, *args, **kwargs):
super(MatlabKernel, self).__init__(*args, **kwargs)
executable = os.environ.get('MATLAB_EXECUTABLE', 'matlab')
subprocess.check_call([executable, '-e'], stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
self._matlab = Matlab(executable)
self._matlab.start()
def get_usage(self):
return "This is the Matlab kernel."
def do_execute_direct(self, code):
if self._first:
self._first = False
fig_code = "set(0, 'defaultfigurepaperunits', 'inches');"
self._matlab.run_code(fig_code)
self._matlab.run_code("set(0, 'defaultfigureunits', 'inches');")
self.handle_plot_settings()
self.log.debug('execute: %s' % code)
resp = self._matlab.run_code(code.strip())
self.log.debug('execute done')
if 'stdout' not in resp['content']:
raise ValueError(resp)
if 'figures' in resp['content']:
for fname in resp['content']['figures']:
try:
im = Image(filename=fname)
self.Display(im)
except Exception as e:
self.Error(e)
if not resp['success']:
self.Error(resp['content']['stdout'].strip())
else:
return resp['content']['stdout'].strip()
def get_kernel_help_on(self, info, level=0, none_on_fail=False):
obj = info.get('help_obj', '')
if not obj or len(obj.split()) > 1:
if none_on_fail:
return None
else:
return ""
return self.do_execute_direct('help %s' % obj)
def handle_plot_settings(self):
"""Handle the current plot settings"""
settings = self.plot_settings
settings.setdefault('size', '560,420')
width, height = 560, 420
if isinstance(settings['size'], tuple):
width, height = settings['size']
elif settings['size']:
try:
width, height = settings['size'].split(',')
width, height = int(width), int(height)
except Exception as e:
self.Error(e)
size = "set(0, 'defaultfigurepaperposition', [0 0 %s %s])\n;"
self.do_execute_direct(size % (width / 150., height / 150.))
def repr(self, obj):
return obj
def restart_kernel(self):
"""Restart the kernel"""
self._matlab.stop()
def do_shutdown(self, restart):
with open('test.txt', 'w') as fid:
fid.write('hey hey\n')
self._matlab.stop()
def callMatlabFunc(mlab, funcName, inputArgs, nbOutputArg, debug=False, setupCode=""):
if debug:
print("Entering callMatlabFunc...")
closeMatlab = False
if mlab is None:
if debug:
print("Starting Matlab...")
mlab = Matlab() #Matlab(matlab='C:/Program Files/MATLAB/R2015a/bin/matlab.exe')
mlab.start()
closeMatlab = True
if len(setupCode):
result = mlab.run_code(setupCode)
if not result["success"]:
raise RuntimeError(result["content"]["stdout"] )
if debug:
print("Setting input variables...")
inputStr = ""
if len(inputArgs):
for i, arg in enumerate(inputArgs):
mlab.set_variable("in" + str(i), arg)
inputStr += "in" + str(i) + ","
inputStr = inputStr[:-1]
if debug:
print("Input variables set...")
matlabCode = ""
if nbOutputArg == 1:
matlabCode += "out0 = "
elif nbOutputArg > 1:
matlabCode += "["
for i in range(nbOutputArg):
matlabCode += "out" + str(i) + ","
matlabCode = matlabCode[:-1]
matlabCode += "] = "
matlabCode += funcName + "(" + inputStr + ")"
if debug:
print("Matlab Code: ")
print(matlabCode)
result = mlab.run_code(matlabCode)
if debug:
print("run_code executed.")
print(result)
outArgs = [mlab.get_variable("out" + str(i)) for i in range(nbOutputArg)]
if debug:
print("Out args: ")
print(outArgs)
sucess = result["success"]
stdout = result["content"]["stdout"]
if closeMatlab :
if debug:
print("Stoping Matlab...")
mlab.stop()
if not sucess:
raise RuntimeError(stdout)
return outArgs
class cvWorker(threading.Thread):
def __init__(self, worker_id, mlab_path, socket_prefix, id_prefix):
threading.Thread.__init__(self)
self.redis_obj = redis.Redis()
self.worker_id = worker_id
#Create a matlab instance; ie one matlab instance is created per worker
cv_socket = socket_prefix + worker_id
mlab_id = id_prefix + worker_id
self.mlab_inst = Matlab(matlab=mlab_path,
socket_addr=cv_socket,
id=mlab_id)
self.mlab_inst.start()
time.sleep(2)
self.createHash()
def createHash(self):
self.redis_obj.hmset('cloudcv_worker:' + self.worker_id,
{'status': 'Started'})
def run(self):
# Keep polling the redis queue for jobs
# If present, execute it else keep polling till instructed to stop
loop = 1
self.redis_obj.rpush('cloudcv:' + self.worker_id + ':status',
'Running')
while loop == 1:
json_args = self.redis_obj.lpop('cloudcv_jobs')
if json_args is not None:
parsed_dict = json.loads(json_args)
re.run(parsed_dict, self.mlab_inst)
print json_args
'''
if task_id is not None:
# Set status to "Executing Job<ID> @ Time" and execute the task
json_args = self.redis_obj.get('cloudcv:'+task_id+':args')
exec_path = self.redis_obj.get('cloudcv:'+task_id+':exec')
## HAVE TO CLEAN UP REDIS AFTER THIS
task_args = json.loads(json_args)
#task_args = {'imagePath': '/home/mclint/pythonbridge/testin','outputPath': '/home/mclint/pythonbridge/testout','featList': 'lbp','verbosity': '2' }
## HAVE TO ADD TIME
time_str = time.asctime(time.localtime(time.time()))
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Executing Job: ' + task_id + ' at ' + time_str)
self.redis_obj.set('cloudcv:'+task_id+':status', 'Executing on Worker: ' + self.worker_id + ' at ' + time_str)
res = self.mlab_inst.run_func(exec_path, task_args)
print res
self.redis_obj.set('cloudcv:'+task_id+':result', res)
## HAVE TO ADD TIME
time_str = time.asctime(time.localtime(time.time()))
if res['result'] == 0:
# Set status to "Completed Job<ID> @ Time"
print task_id + ' Completed Successfully by Worker: ' + self.worker_id + ' at ' + time_str
self.redis_obj.set('cloudcv:'+task_id+':status', 'Completed by Worker: ' + self.worker_id + ' at ' + time_str)
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Completed Job: ' + task_id + ' at ' + time_str)
else:
# Set status to "FAILED Job<ID> @ Time"
print task_id + ' FAILED - worker: ' + self.worker_id + ' at ' + time_str
self.redis_obj.set('cloudcv:'+task_id+':status', 'Job FAILED - Worker: ' + self.worker_id + ' at ' + time_str)
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Job FAILED: ' + task_id + ' at ' + time_str)
'''
if self.redis_obj.get('cloudcv:stop') != 'False':
loop = 0
self.redis_obj.rpush('cloudcv:' + self.worker_id + ':status',
'Stopping Matlab')
print 'Quit command issued'
time.sleep(0.1)
# Go to terminate here
self.terminate()
def terminate(self):
# Stop Matlab instance and set status
self.mlab_inst.stop()
self.redis_obj.rpush('cloudcv:' + self.worker_id + ':status',
'Stoped Matlab')
self.redis_obj.rpush('cloudcv:' + self.worker_id + ':status',
'Exiting Thread')
from sklearn.metrics import average_precision_score
import matplotlib.pyplot as plt
with open("exp.txt", "r") as inf:
inf.readline()
int_array = [line.strip("\n").split()[:] for line in inf]
predictR = np.array(int_array, dtype=np.float64)
with open("exp1.txt", "r") as inf1:
inf1.readline()
int_array1 = [line.strip("\n").split()[:] for line in inf1]
final_lable = np.array(int_array1, dtype=np.float64)
mlab = Matlab()
mlab.start()
# print os.getcwd()
# self.predictR = mlab.run_func(os.sep.join([os.getcwd(), "kbmf2k", "kbmf.m"]), {'Kx': drugMat, 'Kz': targetMat, 'Y': R, 'R': self.num_factors})['result']
res = mlab.run_func(os.path.realpath(os.sep.join(["..\pudt", "AUC.m"])), {
'test_targets': final_lable,
'output': predictR
})
predictAUC = res['result']
# print os.path.realpath(os.sep.join(['../kbmf2k', "kbmf.m"]))
mlab.stop()
# score = self.predictR[test_data[:, 0], test_data[:, 1]]
score = predictAUC
fpr, tpr, thr = roc_curve(final_lable, np.array(predictR))
auc_val = auc(fpr, tpr)
print("predictAUC: " + str(predictAUC) + ", AUC: " + str(auc_val))
a = mlab.run_code('cd(\'/home/bejar/PycharmProjects/PeakDataAnalysis/Matlab/\')')
print a
datasufix = ''#'-RawResampled'
wtime = '120e-3' # Window length in miliseconds
for expname in lexperiments:
datainfo = experiments[expname]
sampling = datainfo.sampling #/ 6.0
for file in [datainfo.datafiles[0]]:
print time.ctime()
nfile = '/home/bejar/Data/Cinvestav/' + file + datasufix + '.mat'
nfiler = '/home/bejar/Data/Cinvestav/' + file + datasufix + '-peaks2.mat'
print 'Processing ', file
print 'IN= ', nfile
print 'OUT= ', nfiler
a = mlab.run_code('cdp_identification(\'' + nfile + '\', \'' + nfiler + '\', '+ wtime + ',' + str(sampling) + ')')
print a
print '************************************************'
print time.ctime()
mlab.stop()
# print results
# print mlab.get_variable('a')
#res = mlab.run_func('jk.m', {'arg1': 3, 'arg2': 5})
class MatlabKernel(MetaKernel):
implementation = "Matlab Kernel"
implementation_version = (__version__,)
language = "matlab"
language_version = ("0.1",)
banner = "Matlab Kernel"
language_info = {
"mimetype": "text/x-matlab",
"name": "octave",
"file_extension": ".m",
"codemirror_mode": "Octave",
"help_links": MetaKernel.help_links,
}
_first = True
def __init__(self, *args, **kwargs):
super(MatlabKernel, self).__init__(*args, **kwargs)
executable = os.environ.get("MATLAB_EXECUTABLE", "matlab")
subprocess.check_call([executable, "-e"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
self._matlab = Matlab(executable)
self._matlab.start()
def get_usage(self):
return "This is the Matlab kernel."
def do_execute_direct(self, code):
if self._first:
self._first = False
fig_code = "set(0, 'defaultfigurepaperunits', 'inches');"
self._matlab.run_code(fig_code)
self._matlab.run_code("set(0, 'defaultfigureunits', 'inches');")
self.handle_plot_settings()
self.log.debug("execute: %s" % code)
resp = self._matlab.run_code(code.strip())
self.log.debug("execute done")
if "stdout" not in resp["content"]:
raise ValueError(resp)
if "figures" in resp["content"]:
for fname in resp["content"]["figures"]:
try:
im = Image(filename=fname)
self.Display(im)
except Exception as e:
self.Error(e)
if not resp["success"]:
self.Error(resp["content"]["stdout"].strip())
else:
return resp["content"]["stdout"].strip() or None
def get_kernel_help_on(self, info, level=0, none_on_fail=False):
obj = info.get("help_obj", "")
if not obj or len(obj.split()) > 1:
if none_on_fail:
return None
else:
return ""
return self.do_execute_direct("help %s" % obj)
def handle_plot_settings(self):
"""Handle the current plot settings"""
settings = self.plot_settings
settings.setdefault("size", "560,420")
width, height = 560, 420
if isinstance(settings["size"], tuple):
width, height = settings["size"]
elif settings["size"]:
try:
width, height = settings["size"].split(",")
width, height = int(width), int(height)
except Exception as e:
self.Error(e)
size = "set(0, 'defaultfigurepaperposition', [0 0 %s %s])\n;"
self.do_execute_direct(size % (width / 150.0, height / 150.0))
def repr(self, obj):
return obj
def restart_kernel(self):
"""Restart the kernel"""
self._matlab.stop()
def do_shutdown(self, restart):
with open("test.txt", "w") as fid:
fid.write("hey hey\n")
self._matlab.stop()
class MatlabKernel(MetaKernel):
implementation = 'Matlab Kernel'
implementation_version = __version__,
language = 'matlab'
language_version = '0.1',
banner = "Matlab Kernel"
language_info = {
'mimetype': 'text/x-matlab',
'name': 'matlab',
'file_extension': '.m',
'help_links': MetaKernel.help_links,
}
_first = True
def __init__(self, *args, **kwargs):
excecutable = kwargs.pop('excecutable', 'matlab')
super(MatlabKernel, self).__init__(*args, **kwargs)
self._matlab = Matlab(excecutable)
self._matlab.start()
def get_usage(self):
return "This is the Matlab kernel."
def do_execute_direct(self, code):
if self._first:
self._first = False
fig_code = "set(0, 'defaultfigurepaperunits', 'inches');"
self._matlab.run_code(fig_code)
self._matlab.run_code("set(0, 'defaultfigureunits', 'inches');")
self.handle_plot_settings()
self.log.debug('execute: %s' % code)
resp = self._matlab.run_code(code.strip())
self.log.debug('execute done')
if 'stdout' not in resp['content']:
raise ValueError(resp)
if 'figures' in resp['content']:
for fname in resp['content']['figures']:
try:
im = Image(filename=fname)
self.Display(im)
except Exception as e:
self.Error(e)
return resp['content']['stdout'].strip()
def get_kernel_help_on(self, info, level=0, none_on_fail=False):
obj = info.get('help_obj', '')
if not obj or len(obj.split()) > 1:
if none_on_fail:
return None
else:
return ""
return self.do_execute_direct('help %s' % obj)
def handle_plot_settings(self):
"""Handle the current plot settings"""
settings = self.plot_settings
settings.setdefault('size', '560,420')
width, height = 560, 420
if isinstance(settings['size'], tuple):
width, height = settings['size']
elif settings['size']:
try:
width, height = settings['size'].split(',')
width, height = int(width), int(height)
except Exception as e:
self.Error(e)
size = "set(0, 'defaultfigurepaperposition', [0 0 %s %s])\n;"
self.do_execute_direct(size % (width / 150., height / 150.))
def repr(self, obj):
return obj
def restart_kernel(self):
"""Restart the kernel"""
self._matlab.stop()
def Run(C, R, mic, Plot):
CHUNK = 44100 # number of data points to read at a time 4096
CHUNK = C
# 4096 byte
# the number of frames
RATE = 44100 # 176400 # time resolution for reading device (Hz) 44100 samples/second
RATE = R
# sampling rate i.e the number of frames per second
serSignal = 'S'
KnockSignal = 'K'
Input_Device_Index = 2
Input_Device_Index = mic
plot = Plot
# Define the serial port
ser_port = "COM8" # for window computer, int must be used COM1 = 0,COM2=1 ...
baud_rate = 9600
count = 0
flag = False
signal = False
mlab = Matlab(executable=r"D:\MATLAB\bin\matlab.exe")
mlab.start()
p = pyaudio.PyAudio()
# while True:
# ser.write(serSignal.encode('utf-8'))
# if ser.readline().decode('utf-8') != "Spray":
# break
stream = p.open(format=pyaudio.paInt16,
channels=1,
rate=RATE,
input=True,
input_device_index=None,
frames_per_buffer=CHUNK)
ser = serial.Serial(ser_port, baud_rate)
print(ser.readline().decode("utf-8"))
print("Input delay is %f" % stream.get_input_latency())
while (True):
for i in range(int(3)): #only loop forA int(??) times
#if(count>1):
# sleep(1)
if (count == 1):
ser.write(KnockSignal.encode(
"utf-8")) # encode is used for string.encode()
sleep(.32) # **change here (0.1s per 5000samples)
flag = True
print("Must Knock Here")
# The input device id "2" => built-in microphone
# info = p.get_host_api_info_by_index(0)
# numdevices = info.get('deviceCount')
# for i in range(0, numdevices):
# if (p.get_device_info_by_host_api_device_index(0, i).get('maxInputChannels')) > 0:
# pass
#print('Input Device id', i, '-', p.get_device_info_by_host_api_device_index(0, i).get('name'))
# get the default device info
#print(p.get_default_input_device_info())
# create a numpy array holding a single read of audio data
#now = datetime.now()
if flag == True:
# if count ==1:
# sleep(.5)
np.set_printoptions(threshold=sys.maxsize)
data = np.fromstring(stream.read(CHUNK), dtype=np.short)
#print(stream)
time = np.arange(0, CHUNK)
#peak=np.average(np.abs(data))*21
#bars="#"*int(50*peak/2**16)
#print("%04d %s"%(i,data))
#print("%s %s" % (data/32768,now ))
#print("Input data is ", type(data))
# Test Matlab data 1
#res = mlab.run_func('jk.m', {'arg1': data})
#print("Output data is ", type(res['result']))
#data1 = res['result'] # The data in matlab is float64 (e.g for 64bit window) https://stackoverflow.com/questions/8855574/convert-ndarray-from-float64-to-integer
#M_data1 = data1[0] / 32768
#print("jk.m is",res)
# data1 = np.array(res['result'], dtype=np.float64).astype(np.int64)
# print(type(data1))
#Write data to text file before matlab
# with open("SignalTest1.txt", "wt") as file:
# file.write("%s" % (str(M_data1).lstrip('[').rstrip(']')))
# file.flush()
# file.close()
# # file.writelines("%s %04d %s\n"%(now,i,data))
# # close the stream gracefully
# max_val =np.amax(data)
# print(max_val)
# if max_val >30000:
#data/32768
#print(M_data1)
if count == 1:
print("Write")
with open("SignalTest.txt", "wt") as out_file:
out_file.writelines(
str(data)) #it can only write string
if plot == True and count == 2:
past = stream.get_time()
np.set_printoptions(threshold=sys.maxsize)
data = np.fromstring(stream.read(CHUNK), dtype=np.short)
present = stream.get_time()
delay = present - past
print("The delay is %f" % delay)
plt.title('AudioSample')
plt.plot(time, data)
plt.ylim(-40000, 40000)
plt.ylabel('Amplitude')
plt.xlabel('Sample Size')
#plt.pause(.0000000000000000000000000000000000000000000000000000000001)
#plt.clf()
#print(stream.get_time())
dataprocess = mlab.run_func(
'final_judge.m', {"arg1": data}) # ,{'arg1':data}
# print("The input data is ",M_data1)
print(np.amax(data))
print(dataprocess['result'])
d1 = dataprocess['result']
if d1 == 1:
ser.write(serSignal.encode(
"utf-8")) # encode is used for string.encode()
# print(ser.write(serSignal.encode("utf-8")))
#print(ser.readline().decode("utf-8"))
#d1 = 2
plt.show()
flag = False
count = 0
count += 1
#ser.reset_output_buffer()
mlab.stop()
out_file.close()
stream.stop_stream()
stream.close()
p.terminate()
sys.exit(0)
class cvWorker (threading.Thread):
def __init__(self, worker_id, mlab_path, socket_prefix, id_prefix):
threading.Thread.__init__(self)
self.redis_obj = redis.Redis()
self.worker_id = worker_id
#Create a matlab instance; ie one matlab instance is created per worker
cv_socket = socket_prefix + worker_id
mlab_id = id_prefix + worker_id
self.mlab_inst = Matlab(matlab=mlab_path, socket_addr=cv_socket, id=mlab_id)
self.mlab_inst.start()
time.sleep(2)
self.createHash()
def createHash(self):
self.redis_obj.hmset('cloudcv_worker:'+self.worker_id, {'status' : 'Started'})
def run(self):
# Keep polling the redis queue for jobs
# If present, execute it else keep polling till instructed to stop
loop = 1
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Running')
while loop == 1:
json_args = self.redis_obj.lpop('cloudcv_jobs')
if json_args is not None:
parsed_dict = json.loads(json_args)
re.run(parsed_dict, self.mlab_inst)
print json_args
'''
if task_id is not None:
# Set status to "Executing Job<ID> @ Time" and execute the task
json_args = self.redis_obj.get('cloudcv:'+task_id+':args')
exec_path = self.redis_obj.get('cloudcv:'+task_id+':exec')
## HAVE TO CLEAN UP REDIS AFTER THIS
task_args = json.loads(json_args)
#task_args = {'imagePath': '/home/mclint/pythonbridge/testin','outputPath': '/home/mclint/pythonbridge/testout','featList': 'lbp','verbosity': '2' }
## HAVE TO ADD TIME
time_str = time.asctime(time.localtime(time.time()))
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Executing Job: ' + task_id + ' at ' + time_str)
self.redis_obj.set('cloudcv:'+task_id+':status', 'Executing on Worker: ' + self.worker_id + ' at ' + time_str)
res = self.mlab_inst.run_func(exec_path, task_args)
print res
self.redis_obj.set('cloudcv:'+task_id+':result', res)
## HAVE TO ADD TIME
time_str = time.asctime(time.localtime(time.time()))
if res['result'] == 0:
# Set status to "Completed Job<ID> @ Time"
print task_id + ' Completed Successfully by Worker: ' + self.worker_id + ' at ' + time_str
self.redis_obj.set('cloudcv:'+task_id+':status', 'Completed by Worker: ' + self.worker_id + ' at ' + time_str)
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Completed Job: ' + task_id + ' at ' + time_str)
else:
# Set status to "FAILED Job<ID> @ Time"
print task_id + ' FAILED - worker: ' + self.worker_id + ' at ' + time_str
self.redis_obj.set('cloudcv:'+task_id+':status', 'Job FAILED - Worker: ' + self.worker_id + ' at ' + time_str)
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Job FAILED: ' + task_id + ' at ' + time_str)
'''
if self.redis_obj.get('cloudcv:stop') != 'False':
loop = 0
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Stopping Matlab')
print 'Quit command issued'
time.sleep(0.1)
# Go to terminate here
self.terminate()
def terminate(self):
# Stop Matlab instance and set status
self.mlab_inst.stop()
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Stoped Matlab')
self.redis_obj.rpush('cloudcv:'+self.worker_id+':status', 'Exiting Thread')
# Store local results
hdf5storage.savemat(local_dir + '/results.mat', {
'bler_ae': bler_ae[run_idx],
'ber_ae': ber_ae[run_idx],
'bler_aeq': bler_aeq[run_idx],
'ber_aeq': ber_aeq[run_idx],
'bler_enc': bler_enc[run_idx],
'ber_enc': ber_enc[run_idx],
'bler_encq': bler_encq[run_idx],
'ber_encq': ber_encq[run_idx],
'val_loss': history.history['val_loss']
},
truncate_existing=True)
# Store global results incrementally
hdf5storage.savemat(global_dir + '/results_global%d.mat' % global_seed, {
'bler_ae': bler_ae,
'ber_ae': ber_ae,
'bler_aeq': bler_aeq,
'ber_aeq': ber_aeq,
'bler_enc': bler_enc,
'ber_enc': ber_enc,
'bler_encq': bler_encq,
'ber_encq': ber_encq,
'local_seed_collect': local_seed_collect
},
truncate_existing=True)
# Close MATLAB engine
eng.stop()
def backtest(filename, data, schedule_data):
f = open(filename)
f.readline()
player_data = {}
time_data = []
for i in xrange(50):
line = f.readline()
if line is None or len(line) == 0:
break
date = int(line[:3])
print date
jsonvalue = "{"+f.readline()+"}"
value = json.loads(jsonvalue)
time_data.insert(0,(date,value))
for p in value:
if not p in player_data:
player_data[p] = [0]
player_data[p].insert(0,value[p])
time_data2 = convertToPlayersTimeData(time_data, data)
teams = set([i.team for i in data])
for i in xrange(len(time_data2)):
stamp_data = time_data2[i][1]
Tracer()()
portfolio = ["rohit sharma", "ajinkya rahane", "david warner", "glenn maxwell", "robin uthappa", "shane watson", "sandeep sharma", "sunil narine", "pravin tambe", "yuzvendra chahal", "bhuvneshwar kumar"]
# portfolio = ["yuzvendra chahal", "shakib al hasan", "shane watson", "rohit sharma", "sandeep sharma", "sunil narine", "ajinkya rahane", "jacques kallis", "robin uthappa", "jayant yadav","bhuvneshwar kumar"]
# portfolio = ["manish pandey", "rohit sharma","jacques kallis","robin uthappa", "aditya tare", "ambati rayudu", "morne morkel","piyush chawla","sunil narine","lasith malinga","pragyan ojha"]
power_player = "glenn maxwell"
# power_player = "bhuvneshwar kumar"
portfolio_p = set([getPlayer(data, p)[0] for p in portfolio])
power_player_p = getPlayer(data, power_player)[0]
points = 0
subs = 75
mlab = Matlab(matlab='/Applications/MATLAB_R2013a.app/bin/matlab')
mlab.start()
for i in xrange(4,len(time_data2)):
# START = str(time_data2[i][0])
# CURRENT_TEAM = set(portfolio)
# SUBSTITUTIONS = subs
# PAST_STATS = time_data[i][1]
print "\n\n\n\n\n\n"
print (subs, str(time_data2[i][0]))
print set(portfolio_p)
print points
print "\n\n\n\n\n\n"
# print time_data[i-1][1]
# Tracer()()
inp = (subs, str(time_data2[i][0]), set(portfolio), time_data[i-1][1])
backtest_pickteam.pickTeam(data, schedule_data, inp)
res = mlab.run_func('/Users/deedy/Dev/FantasyIPL-Moneyball/python2matlab.m', {}, maxtime = 500)
changes = backtest_results.getResults(data, schedule_data, res['result'])
subs -= changes[2]
portfolio_p = changes[0]
power_player_p = changes[1]
# Tracer()()
# update portfolio
# update subs
# update power player
# Tracer()()
teams = [(p,time_data2[i][1][p] - time_data2[i-1][1][p] ) for p in time_data2[i][1] if p in portfolio_p]
print teams
pthis = 0
for i in teams:
if power_player_p == i[0]:
pthis += 2*i[1]
else:
pthis += i[1]
points+= pthis
print "{0}\t{1}\t{2}\n\n".format(points, pthis, subs)
# print "{0}\t{1}".format(time_data2[i][0] , teams)
mlab.stop()
Tracer()()
f.close()
class FingerprintUpdate:
def __init__(self):
self.mlab = Matlab()
self.mlab.start()
# 该文件无用,只是为了避免一个路径引起的bug
res = self.mlab.run_func(
'C:/Users/ovewa/Desktop/git-storage/OS-ELM-matlab/test.m', 1)
# 生成中间数据
def get_median(self, ditu, data, model_num, ap_num):
if os.path.isdir('middata' + str(ap_num) + '/'):
pass
else:
os.mkdir('middata' + str(ap_num) + '/')
with open('middata' + str(ap_num) + '/' + str(model_num) + '.txt',
'wt') as f:
for x in range(len(data)):
for y in range(len(data[0])):
if int(data[x][y]) != 0 and int(ditu[x][y]) != 0:
f.write(
str(data[x][y] / ditu[x][y] - 1) + " " + str(x) +
" " + str(y) + "\n")
def get_none(self, ditu, ap_num):
if os.path.isdir('middata' + str(ap_num) + '/'):
pass
else:
os.mkdir('middata' + str(ap_num) + '/')
with open('middata' + str(ap_num) + '/none.txt', 'wt') as f:
for x in range(len(ditu)):
for y in range(len(ditu[0])):
f.write(str(0) + " " + str(x) + " " + str(y) + "\n")
# 训练过程
# 可优化
# 1是训练条件不同结果不同
# 2是随机参数不同结果不同
# 多次训练取最优解
def training(self, model_num, ditu, ap_num):
# 初始训练
res = self.mlab.run_func('OSELM_initial_training.m',
'middata' + str(ap_num) + '/1.txt',
10,
'sin',
nargout=5)
IW = res['result'][0]
Bias = res['result'][1]
M = res['result'][2]
beta = res['result'][3]
# 增量学习
# ####!!!添加将每一次增量学习结果的误差输出出来并可视化
for x in range(2, (model_num + 1)):
res = self.mlab.run_func('OSELM_increase_study.m',
'middata' + str(ap_num) + '/' + str(x) +
'.txt',
IW,
Bias,
M,
beta,
'sin',
1,
nargout=4)
IW = res['result'][0]
Bias = res['result'][1]
M = res['result'][2]
beta = res['result'][3]
# 获取完整指纹库
res = self.mlab.run_func('OSELM_test_value.m',
'middata' + str(ap_num) + '/none.txt', IW,
Bias, beta, 'sin')
result = res['result']
y = 0
data = []
for i in range(len(ditu)):
data.append([])
for j in range(len(ditu[0])):
data[i].append(-1)
for x in range(len(result)):
###重点,现在直接将初次训练结果保存,没有进行比较分析,待完善
data[x % 10][y] = int(ditu[x % 10][y] * (result[x] + 1))
if (x + 1) % 10 == 0:
y = y + 1
return data
def mlab_stop(self, ap_mac):
self.mlab.stop()
# 删除中间文件
for x in range(len(ap_mac)):
if os.path.isdir('middata' + str(x) + '/'):
shutil.rmtree('middata' + str(x) + '/')
class DataPreprocess:
def __init__(self):
file = xlrd.open_workbook('excel/0.xls')
table = file.sheets()[sheet] #通过索引顺序获取工作表
nrows = table.nrows #行数
self.mlab = Matlab()
self.mlab.start()
# 该文件无用,只是为了避免一个路径引起的bug
res = self.mlab.run_func(
'C:/Users/ovewa/Desktop/git-storage/OS-ELM-matlab/test.m', 1)
self.ditu = []
for i in range(1, nrows):
self.ditu.append(table.row_values(i)[1:])
# 生成中间数据
def get_median(self):
for j in range(0, 20):
file = xlrd.open_workbook('excel/' + str(j) + '.xls')
table = file.sheets()[sheet] #通过索引顺序获取工作表
nrows = table.nrows #行数
data = []
for i in range(1, nrows):
data.append(table.row_values(i)[1:])
if os.path.isdir('middata' + str(sheet) + '/'):
pass
else:
os.mkdir('middata' + str(sheet) + '/')
with open('middata' + str(sheet) + '/' + str(j) + '.txt',
'wt') as f:
for y in range(len(data)):
for x in range(len(data[0])):
if int(data[y][x]) != 0 and int(self.ditu[y][x]) != 0:
f.write(
str(data[y][x] / self.ditu[y][x] - 1) + " " +
str(x) + " " + str(y) + "\n")
def get_none(self):
with open('middata' + str(sheet) + '/none.txt', 'wt') as f:
for y in range(13):
for x in range(10):
f.write(str(0) + " " + str(x) + " " + str(y) + "\n")
# 训练过程
# 可优化
# 1是训练条件不同结果不同
# 2是随机参数不同结果不同
# 多次训练取最优解
def training(self, model_num):
# 初始训练
res = self.mlab.run_func('OSELM_initial_training.m',
'middata' + str(sheet) + '/0.txt',
10,
'sin',
nargout=5)
IW = res['result'][0]
Bias = res['result'][1]
M = res['result'][2]
beta = res['result'][3]
# 增量学习
# ####!!!添加将 每一次增量学习结果的误差输出出来并可视化
for x in range(1, model_num + 1):
res = self.mlab.run_func('OSELM_increase_study.m',
'middata' + str(sheet) + '/' + str(x) +
'.txt',
IW,
Bias,
M,
beta,
'sin',
1,
nargout=4)
IW = res['result'][0]
Bias = res['result'][1]
M = res['result'][2]
beta = res['result'][3]
# 获取完整指纹库
res = self.mlab.run_func('OSELM_test_value.m',
'middata' + str(sheet) + '/none.txt', IW,
Bias, beta, 'sin')
result = res['result']
y = 0
data = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
for x in range(len(result)):
###重点,现在直接将初次训练结果保存,没有进行比较分析,待完善
data[x % 10][y] = int(self.ditu[y][x % 10] * (result[x] + 1))
if (x + 1) % 10 == 0:
y = y + 1
return data
def mlab_stop(self):
self.mlab.stop()
