def sparse_sift(image, fraction=1.0):
""" sparse oriented SIFT at Harris-LaPlace and Difference of Gaussians keypoints
use VLFEAT vl_covdet through octave; expects a grayscale image
"""
octave.eval("addpath ~/CC/vlfeat/vlfeat-0.9.20/toolbox")
octave.eval("vl_setup")
octave.push("im", image)
octave.eval("im = single(im);")
octave.eval(
"[kp,sift_hl] = vl_covdet(im, 'method', 'HarrisLaplace', 'EstimateOrientation', true); "
)
octave.eval(
"[kp,sift_dog] = vl_covdet(im, 'method', 'DoG', 'EstimateOrientation', true); "
)
octave.eval("descrs = [sift_hl, sift_dog];")
descriptors = octave.pull("descrs")
kp = octave.pull("kp")
# flip from column-major to row-major
descriptors = descriptors.T
if fraction < 1.0:
descriptors = random_sample(descriptors, fraction)
return kp, descriptors
def getData(self, filepath):
octave.eval(
"load('" + filepath +
"', '-mat')") #todo: separate octave instanz für jeden user
data = octave.pull('Data')
#todo: fehler check + memoisierung
return data
def get(self, expid, variables):
'''
Retrieve one or more variables from the workspace of the current Octave session
'''
toReturn = {}
n = len(variables)
for i in range(n):
name = variables[i]
try:
toReturn[name] = octave.pull(name)
except:
pass
return toReturn
def fit(self, K, y):
"""Learn a low-rank kernel approximation.
:param K: (``numpy.ndarray``) or of (``Kinterface``). The kernel to be approximated with G.
:param y: (``numpy.ndarray``) Class labels :math:`y_i \in {-1, 1}` or regression targets.
"""
# Convert to explicit form
K = K[:, :]
y = y.reshape((len(y), 1))
# Call original implementation
octave.push(["K", "y", "rank", "centering", "kappa", "delta", "tol"], [
K, y, self.rank, self.centering, self.kappa, self.delta, self.tol
])
octave.eval(
"[G, P, Q, R, error1, error2, error, predicted_gain, true_gain] = csi(K, y, rank, centering, kappa, delta, tol)",
verbose=False)
G, P, Q, R, error1, error2, error, predicted_gain, true_gain = \
octave.pull(["G", "P", "Q", "R", "error1", "error2", "error", "predicted_gain", "true_gain"])
R = np.atleast_2d(np.array(R))
# Octave indexes from 1
P = P.ravel().astype(int) - 1
# Resort rows to respect the order
n, k = K.shape[0], self.rank
self.I = self.active_set_ = list(P[:k])
Go = np.zeros((n, k))
Qo = np.zeros((n, k))
Ro = np.zeros((k, k))
km = min(k, G.shape[1])
Go[P, :km] = G[:, :km]
Qo[P, :km] = Q[:, :km]
Ro[:km, :km] = R[:km, :km]
self.G = Go[:, :self.rank]
self.P = P[:self.rank]
self.Q = Qo[:, :]
self.R = Ro[:, :self.rank]
self.error1 = error1
self.error1 = error2
self.error = error
self.predicted_gain = predicted_gain
self.true_gain = true_gain
self.trained = True
self.active_set_ = self.I[:self.rank]
def plot_calibration_mapping(calibration_model,
min_score,
max_score,
resolution=1000,
file_name='calibration_mapping.png'):
# Function for plotting what probabilities different scores get mapped to.
# "General purpose prediction function"
# PERHAPS ADD PROBABILITY DISTRIBUTION OF TRAINING DATA (OR TESTING?)?
# WOULD INDICATE HOW MANY SAMPLES FALL INTO ONE BIN.
diff = max_score - min_score
scores = [
min_score + i * diff / float(resolution) for i in range(resolution + 1)
]
try: # IR model
probabilities = calibration_model.predict(scores)
except:
try: # ENIR
import rpy2.robjects as robjects
from rpy2.robjects.packages import importr
enir = importr('enir')
r = robjects.r
# Automatic conversion or numpy arrays to R-vectors
import rpy2.robjects.numpy2ri
rpy2.robjects.numpy2ri.activate()
# ENIR-MODEL MIGHT NEED TO BE PUSHED TO R-ENVIRONMENT?
probabilities = enir.enir_predict(calibration_model,
robjects.FloatVector(scores))
probabilities = np.array(probabilities)
except:
try: # BBQ
from oct2py import octave
octave.eval("addpath('./calibration/BBQ/')", verbose=False)
octave.push('scores', scores, verbose=False)
octave.push('calibration_model',
calibration_model,
verbose=False)
octave.eval(
'probabilities = predict(calibration_model, scores, 1)',
verbose=False)
probabilities = octave.pull('probabilities', verbose=False)
probabilities = np.array([item[0] for item in probabilities])
except:
pass # Continue with BIR and WABIR? RCIR?
# Plot score vs. probability:
plt.plot(scores, probabilities)
plt.title("Calibration mapping")
plt.savefig(file_name)
plt.gcf().clear()
def dense_sift(image, fraction=1.0):
""" dense SIFT
use VLFEAT vl_phow through octave; expects a grayscale image
"""
octave.push("im", image)
octave.eval("im = single(im);")
octave.eval("[kp,siftd] = vl_phow(im); ")
descriptors = octave.pull("siftd")
# flip from column-major to row-major
descriptors = descriptors.T
if fraction < 1.0:
descriptors = random_sample(descriptors, fraction)
return descriptors
os.environ[
"OCTAVE_EXECUTABLE"] = "C:\\Octave\\Octave-4.2.2\\bin\\octave-cli.exe"
from oct2py import octave
from flask import Flask
from dash import Dash
from dash.dependencies import Input, Output
import dash_html_components as html
import dash_core_components as dcc
flask_app = Flask(__name__)
dash_app = Dash(__name__, server=flask_app)
filepath = 'C:\\Users\\SEC\\Documents\\Alperia\\HydroptModel\\vsm.mod'
octave.eval("load('" + filepath + "', '-mat')")
globalData = octave.pull('Data')
dash_app.layout = html.Div(id='page-content',
children=[dcc.Location(id='url', refresh=False)])
@dash_app.callback(Output('page-content', 'children'),
[Input('url', 'pathname')])
def display_page(pathname):
return dash_router(pathname)
def dash_router(url):
children = render_cockpit(globalData)
return children
from oct2py import octave
from numpy import matrix
from numpy import linalg
from numpy import ma
from numpy import sum
#script ouputs possible combos of boggle board
#arbitrary point arithmetic is nice
octave.addpath('.')
octave.eval('boggleAdjentMatrix')
AdjentMatrix = octave.pull('boggleAdj')
AdjentMatrix = matrix(AdjentMatrix)
SumAdjentMatrix = matrix(ma.zeros((16,16),dtype=int))
for n in range(2,16): #len(word) >= 3 and len(word) == len(path+1)
SumAdjentMatrix+=AdjentMatrix**n
NPaths = sum(SumAdjentMatrix)
print(NPaths)
# Naeini's model
# Comparison to Naeini's model (it's a matlab model, using Octave).
print(
"Training Naeini-model. This might take a while (~20 minutes on a laptop)."
)
octave.push('training_scores', naeini_training_scores, verbose=False)
octave.push('training_class', naeini_training_class, verbose=False)
octave.eval("options.N0 = 2", verbose=False)
octave.eval(
"BBQ_model = build(training_scores', training_class', options)",
verbose=False)
# In the following, '1' indicates model averaging, as done in the paper by Naeini & al.
octave.eval("training_bbq_prob = predict(BBQ_model, training_scores, 1)",
verbose=False)
training_bbq_prob = octave.pull("training_bbq_prob", verbose=False)
training_bbq_prob = np.array([item[0] for item in training_bbq_prob])
octave.push('test_scores', test_scores, verbose=False)
octave.eval("test_bbq_prob = predict(BBQ_model, test_scores, 0)",
verbose=False)
test_bbq_prob = octave.pull("test_bbq_prob", verbose=False)
test_bbq_prob = np.array([item[0] for item in test_bbq_prob])
naeini_bins = len(np.unique(training_bbq_prob))
naeini_mse = sum((test_bbq_prob - test_class)**2) / len(test_bbq_prob)
naeini_auc_roc = roc_auc_score(test_class, test_bbq_prob)
samples_per_bin = int(len(naeini_training_class) / naeini_bins)
naeini_p = max(training_bbq_prob) # Highest predicted value.
# Estimate credible intervals. np.unique() returns a list of two lists. The first one contains probabilities,
# the second counts. Their product corresponds to 'k', whereas the counts correspond to 'n'.
# For some reason, the library produces some negative values. These are set to zero.
naeini_data = np.unique(training_bbq_prob, return_counts=True)
test_class = data_class[:n_rows * 1 // 3]
test_scores = data_scores[:n_rows * 1 // 3]
training_class = data_class[n_rows * 1 // 3:]
training_scores = data_scores[n_rows * 1 // 3:]
# Create BBQ-model
octave.push('training_scores', training_scores, verbose=False)
octave.push('training_class', training_class, verbose=False)
octave.eval('options.N0 = 2', verbose=False)
octave.eval(
"bbq_model = build(training_scores', training_class', options)",
verbose=False)
octave.push('test_scores', test_scores)
octave.eval("test_prob = predict(bbq_model, test_scores, 1)",
verbose=False)
bbq_prob = octave.pull('test_prob', verbose=False)
bbq_prob = np.array([item[0] for item in bbq_prob])
bbq_metrics.append(isotonic.get_metrics(test_class, bbq_prob, k=k))
# Create isotonic regression model
ir_model = IsotonicRegression(y_min=y_min,
y_max=y_max,
out_of_bounds='clip')
ir_model.fit(X=training_scores, y=training_class)
ir_prob = isotonic.predict(ir_model, test_scores)
ir_metrics.append(isotonic.get_metrics(test_class, ir_prob, k=k))
# Create ENIR model using R:
enir_model = enir.enir_build(
robjects.FloatVector(training_scores.tolist()),
robjects.BoolVector(training_class.tolist()))
enir_prob = enir.enir_predict(enir_model,
robjects.FloatVector(test_scores.tolist()))
def load_hydopt_data(filepath):
octave.eval("load('" + filepath + "', '-mat')") #todo: separate octave instanz für jeden user
data = octave.pull('Data')
return data
def index():
octave.eval('x = struct("y", {1, 2}, "z", {3, 4});')
x = octave.pull('x')
return str(x[0, 1].z)
import os
os.environ["OCTAVE_EXECUTABLE"] = "C:\\Octave\\Octave-4.2.2\\bin\\octave-cli.exe"
from oct2py import octave
filepath = 'C:\\Users\\SEC\\Documents\\Alperia\\HydroptModel\\vsm.mod'
octave.eval("load('" + filepath + "', '-mat')")
#x = octave.pull('x')
#return str(x[0, 1].z)
octave.eval("revenue = Data.Asset(1).ScenarioWaterManager.Result.OverallRevenue;")
x = octave.pull('revenue')
print(str(x))
#x = octave.pull('Data.Asset(1).ScenarioWaterManager.Result.OverallRevenue') --> erzeugt fehler
data = octave.pull('Data')
x = data.Asset.ScenarioWaterManager.Result.OverallRevenue
print(str(x))
# Create isotonic regression model
ir_model = IsotonicRegression(y_min=0, y_max=1, out_of_bounds='clip')
ir_model.fit(X=training_scores, y=training_class)
# Create BBQ-model
octave.push('training_scores', training_scores, verbose=False)
octave.push('training_class', training_class, verbose=False)
octave.eval('options.N0 = 2', verbose=False)
octave.eval(
"bbq_model = build(training_scores', training_class', options)",
verbose=False)
octave.push('test_scores', test_scores)
octave.eval("test_prob = predict(bbq_model, test_scores, 1)",
verbose=False)
bbq_test_prob = octave.pull('test_prob', verbose=False)
bbq_test_prob = [item[0] for item in bbq_test_prob]
# Create RCIR model with d = .20 (?)
# QUICK HACK TO TEST RCIR-CV INSTEAD OF RCIR WITH SOME d:
# NOTE THAT RCIR-CV GETS _MORE_ _DATA_ THAN
# rcir_model = isotonic.train_rcir_cv(training_scores, training_class , d=.1)
rcir_model = isotonic.train_rcir_cv(training_class, training_scores,
validation_class, validation_scores)
# Create bootstrap IR model
bir_model = isotonic.bootstrap_isotonic_regression(training_class,
training_scores,
sampling_rate=.95,
n_models=1000)
from oct2py import octave
octave.addpath('/home/iso/PycharmProjects/git_dcstest/matVM')
octave.addpath('/home/iso/PycharmProjects/git_dcstest/matVM/matpower6.0')
octave.addpath('/home/iso/PycharmProjects/git_dcstest/matVM/matpower6.0/t')
octave.addpath('/home/iso/dcstest/matVM')
octave.addpath('/home/iso/dcstest/matVM/matpower6.0')
octave.addpath('/home/iso/dcstest/matVM/matpower6.0/t')
import numpy as np
from pprint import pprint as ppr
import sys
octave.eval("y=1")
#print(octave.eval("y"))
print(octave.pull("y"))
mpc = octave.case33bw_dcs2()
r = octave.runopf(mpc)
ppr(r["gen"])
def snmf_fhals(A, k, init='normal'):
"""
Nonnegative Matrix Factorization.
Hierarchical alternating least squares algorithm
for computing the approximate low-rank nonnegative matrix factorization of
a square `(m, m)` matrix `A`. Given the target rank `k << m`,
the input matrix `A` is factored as `A = W Wt`. The nonnegative factor
matrices `W` and `Wt` are of dimension `(m, k)` and `(k, m)`, respectively.
Parameters
----------
A : array_like, shape `(m, m)`.
Real nonnegative input matrix.
k : integer, `k << m`.
Target rank.
init : str `{'normal'}`.
'normal' : Factor matrices are initialized with nonnegative
Gaussian random numbers.
tol : float, default: `tol=1e-4`.
Tolerance of the stopping condition.
maxiter : integer, default: `maxiter=100`.
Number of iterations.
verbose : boolean, default: `verbose=False`.
The verbosity level.
Returns
-------
W: array_like, `(m, k)`.
Solution to the non-negative least squares problem.
"""
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Error catching
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
m, n = A.shape
assert m == n
if (A < 0).any():
raise ValueError("Input matrix with nonnegative elements is required.")
if A.dtype == sci.float32:
data_type = sci.float32
elif A.dtype == sci.float64:
data_type = sci.float64
else:
raise ValueError("A.dtype is not supported.")
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Initialization methods for factor matrices W and H
# 'normal': nonnegative standard normal random init
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if init == 'normal':
n, _ = A.shape
H = 2 * np.sqrt(np.mean(np.mean(A)) / k) * np.random.rand(n, k)
maxiter = 10000
tol = 1e-3
alpha = np.max(H)**2
W = H.copy()
I_k = alpha * np.identity(k)
else:
raise ValueError('Initialization method is not supported.')
#End if
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Iterate the HALS algorithm until convergence or maxiter is reached
# i) Update factor matrix H and normalize columns
# ii) Update low-dimensional factor matrix W
# iii) Compute fit log( ||A-WH|| )
# -> break if fit <-5 or fit_change < tol
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
projnorm = float('inf')
left = H.T.dot(H)
right = A.dot(H)
octave.push('A', A)
octave.push('k', k)
for niter in range(maxiter):
octave.push('W', W)
octave.push('H', H)
octave.push('left', left)
octave.push('right', right)
octave.eval("[W, H, left, right, violation] = symnmf_anls_iter(A, W, H, left, right, k)", verbose=False)
W = octave.pull("W")
H = octave.pull("H")
left = octave.pull("left")
right = octave.pull("right")
violation = octave.pull("violation")
if niter == 0:
initgrad = violation
else:
projnorm = violation
if projnorm < tol * initgrad:
break
return H
