def run(self, data, label):
"""
Init samples
for i in range(iterations):
Update posterior distribution by gaussian process.
Find the next sample maximizing acquisition function.
Add new sample to the original samples.
The last new sample is the best result.
"""
# initial parameters
samples, ys = self.init_samples(data, label, 10)
optimal_y = np.min(ys)
# define the gp
gp = self.base_estimator
for _ in range(self.max_iterations):
# Fit gp on the hyperparameters.
gp.fit(samples, ys)
# Sample next hyperparameter.
next_sample, y = self.propose_next_sample(data, label, optimal_y,
gp)
# Update samples
samples = np.r_([samples, next_sample])
ys = np.r_([ys, y])
optimal_y = np.min(ys)
return samples, ys
def yanchang(self, nummber, yushu):
x2 = self.x[:yushu]
y2 = self.y[:yushu]
z2 = self.z[:yushu]
self.x = np.tile(self.x, nummber)
self.y = np.tile(self.y, nummber)
self.z = np.tile(self.z, nummber)
self.x = np.r_(self.x, x2)
self.y = np.r_(self.y, y2)
self.z = np.r_(self.z, z2)
def PyWavelet(img,level=1, wavlet="db1", mode="sym"):
#画像ファイルをグレースケールへ変換
gray = cv2.cvtColor(im, cv2.COLOR_RGB2GRAY)
res = []
tmp = gray.astype(np.uint16)
res_pywt = pywt.wavedec2(gray,wavlet, level=level, mode=mode)
print(res_pywt)
res_kinji, (res_x, res_y, res_xy) = res_pywt
#マージ
np.c_(tmp,res_x)
np.r_(tmp,res_y)
np.r_(tmp,res_xy)
print("after merge")
print(tmp)
return tmp
def transform(self, X):
"""
Transform a set of images.
Returns the features from each layer.
Parameters
----------
X : array-like, shape = [n_images, height, width, color]
or
shape = [height, width, color]
Returns
-------
T : array-like, shape = [n_images, n_features]
If force_reshape = False,
list of array-like, length output_layers,
each shape = [n_images, n_windows,
n_window_features]
Returns the features extracted for each of the n_images in X..
"""
X = check_tensor(X, dtype=np.float32, n_dim=4)
if self.batch_size is None:
if self.force_reshape:
return self.transform_function(X.transpose(
*self.transpose_order))[0].reshape((len(X), -1))
else:
return self.transform_function(
X.transpose(*self.transpose_order))
else:
XT = X.transpose(*self.transpose_order)
n_samples = XT.shape[0]
for i in range(0, n_samples, self.batch_size):
transformed_batch = self.transform_function(
XT[i:i + self.batch_size])
# at first iteration, initialize output arrays to correct size
if i == 0:
shapes = [(n_samples,) + t.shape[1:] for t in
transformed_batch]
ravelled_shapes = [np.prod(shp[1:]) for shp in shapes]
if self.force_reshape:
output_width = np.sum(ravelled_shapes)
output = np.empty((n_samples, output_width),
dtype=transformed_batch[0].dtype)
break_points = np.r_([0], np.cumsum(ravelled_shapes))
raw_output = [
output[:, start:stop] for start, stop in
zip(break_points[:-1], break_points[1:])]
else:
output = [np.empty(shape,
dtype=transformed_batch.dtype)
for shape in shapes]
raw_output = [arr.reshape(n_samples, -1)
for arr in output]
for transformed, out in zip(transformed_batch, raw_output):
out[i:i + batch_size] = transformed
return output
def KF_measurement(self, X_ins, P_k1_pr, r_i_gps, v_i_gps):
# カルマンフィルタ観測更新
r_i = np.array([[X_ins[0, 0]], [X_ins[1, 0]], [X_ins[2, 0]]])
v_i = np.array([[X_ins[3, 0]], [X_ins[4, 0]], [X_ins[5, 0]]])
# 残差計算
d_r_i = r_i_gps - r_i
d_v_i = v_i_gps - v_i
y = np.r_(d_r_i, d_v_i)
C = np.eye(6, 16)
R = self.MeasureNoiCovMat()
# カルマンゲインの算出
PC_T = np.dot(P_k1_pr, C.T)
invCPC_R = np.linalg.inv(np.dot(C, PC_T) + R)
KalG = np.dot(PC_T, invCPC_R)
# 誤差を推定
X_k1_pl = np.dot(KalG, y) # X^が基本常に0なので簡素化される
# Pを算出
P_k1_me = np.dot(np.eye(16) - np.dot(KalG, C), P_k1_pr)
X_ins = X_ins + X_k1_pl
return X_ins, KalG, P_k1_me
def populate_gp_model(self,
observable,
lecs,
energy=None,
rescale=False,
fixvariance=0):
"""Creates a model based on given data and kernel.
Args:
observable - numpy array with observable. (1 row for each observable from each lec sample)
lecs - numpy array with lec parameters fit should be done with regard to (lec 1 coloum 1 and so on, sample 1 on row 1 and so on)
energy - energy values
"""
# Add row with energies to parameters for fit (c for col if that is that is the right way)
if energy is not None:
lecs = np.r_(lecs, energy)
if rescale:
(lecs, observable) = self.rescale(lecs, observable)
lecs.transpose()
observable.transpose()
self.model = GPRegression(lecs, observable, self.kernel)
self.model.Gaussian_noise.variance.unconstrain()
self.model.Gaussian_noise.variance = fixvariance
self.model.Gaussian_noise.variance.fix()
def featureConnecting(self, inputFeaturePath):
print('inputFeaturePath = ' + inputFeaturePath)
inputFileHandler = open(inputFeaturePath, 'rb')
inputTensor = pickle.load(inputFileHandler)
print('inputTensor.shape = ' + str(inputTensor.shape))
if self.outputTensorExists:
self.outputTensor = np.r_(outputTensor, inputTensor)
else:
self.outputTensor = inputTensor
self.outputTensorExists = 1
print('outputTensor.shape = ' + str(outputTensor.shape))
def observ_step(action, sentences, adjusted_sentence, timestep):
reward = 0.0
for o in range(len(action)):
if action[o] == 1:
word = sentences[o][timestep]
reward = 1.0
if action[o] == 0:
word = [0] * input_size
reward = 0.0
np.r_(adjusted_sentence[o], word)
done = False
with tf.variable_scope('lstm', reuse=tf.AUTO_REUSE):
basic_cell = rnn.BasicLSTMCell(hidden_size)
outputs, states = tf.nn.dynamic_rnn(basic_cell,
adjusted_sentence,
dtype=tf.float32)
observ = outputs[:, -1, :]
with tf.Session() as sess:
sess = tf.Session()
sess.run(tf.initialize_all_variables())
obs = sess.run(observ)
if timestep >= 27:
done = True
return obs, reward, done
def NoiseCovMat(self, X_ins, T):
# プロセスノイズの共分散行列を計算
# 各成分の式展開は『搬送波位相DGPS/INS 複合航法アルゴリズムの開発』を参考にした．URL:https://repository.exst.jaxa.jp/dspace/handle/a-is/32573
qbi = np.array([[X_ins[6, 0]], [X_ins[7, 0]], [X_ins[8, 0]],
[X_ins[9, 0]]])
q1 = qbi[0, 0]
q2 = qbi[1, 0]
q3 = qbi[2, 0]
q4 = qbi[3, 0]
Q = 0.5 * np.array([[q4, -q3, q2], [q3, q4, -q1], [-q2, q1, q4],
[-q1, -q2, -q3]])
Cbi = self.Quate_ToDCM(qbi)
# 時間積分時の近似値（指数で与えてもほとんど問題ないと思われる．参考論文は90年代のもの）
T1g = T * (1 - T / self.Tau_g + 2 / 3 * (T / self.Tau_g)**2)
T1a = T * (1 - T / self.Tau_a + 2 / 3 * (T / self.Tau_a)**2)
T2g = T**2 * (1 / 2 - 1 / 3 * T / self.Tau_g + 1 / 6 *
(T / self.Tau_g)**2)
T2a = T**2 * (1 / 2 - 1 / 3 * T / self.Tau_a + 1 / 6 *
(T / self.Tau_a)**2)
T3 = 1 / 3 * T**3
I_33 = np.eye(3)
Ze33 = np.zeros(3, 3)
Ze34 = np.zeros(3, 4)
Ze43 = np.zeros(4, 3)
Q_22 = T3 * self.Wno_a * Cbi.T
Q_25 = T2a * self.Wno_a * Cbi
Q_33 = T3 * self.Wno_g * np.dot(Q, Q.T)
Q_34 = T2g * self.Wno_g * Q
Q_43 = T2g * self.Wno_g * Q.T
Q_44 = T1g * self.Wno_g * I_33
Q_52 = T2a * self.Wno_a * Cbi.T
Q_55 = T1a * self.Wno_a * I_33
Q_noise = np.r_(np.c_(Ze33, Ze33, Ze34, Ze33, Ze33),
np.c_(Ze33, Q_22, Ze34, Ze33, Q_25),
np.c_(Ze43, Ze43, Q_33, Q_34, Ze43),
np.c_(Ze33, Ze33, Q_43, Q_44, Ze33),
np.c_(Ze33, Q_52, Ze34, Ze33, Q_55))
return Q_noise
def KF_System(self, a, w, X_ins):
# カルマンフィルタのシステム行列算出
# Fは，INS誤差のシステム行列
r_i = np.array([[X_ins[0, 0]], [X_ins[1, 0]], [X_ins[2, 0]]])
v_i = np.array([[X_ins[3, 0]], [X_ins[4, 0]], [X_ins[5, 0]]])
qbi = np.array([[X_ins[6, 0]], [X_ins[7, 0]], [X_ins[8, 0]],
[X_ins[9, 0]]])
wBias = np.array([[X_ins[10, 0]], [X_ins[11, 0]], [X_ins[12, 0]]])
aBias = np.array([[X_ins[13, 0]], [X_ins[14, 0]], [X_ins[15, 0]]])
w_b = w - wBias
a_b = a - aBias
r = np.linalg.norm(r_i)
x = r_i[0, 0]
y = r_i[1, 0]
z = r_i[2, 0]
q1 = qbi[0, 0]
q2 = qbi[1, 0]
q3 = qbi[2, 0]
q4 = qbi[3, 0]
wx = w_b[0, 0]
wy = w_b[1, 0]
wz = w_b[2, 0]
ax = a_b[0, 0]
ay = a_b[1, 0]
az = a_b[2, 0]
I_33 = np.eye(3)
Ze33 = np.zeros(3, 3)
Ze34 = np.zeros(3, 4)
Ze43 = np.zeros(4, 3)
G = 3 * self.Mu / (r**5) * np.array(
[x * x, x * y, x * z], [x * y, y * y, y * z],
[x * z, y * z, z * z]) - self.Mu / (r**3) * I_33
Ome = 0.5 * np.array([[0, wz, -wy, wx], [-wz, 0, wx, wy],
[wy, -wx, 0, wz], [-wx, -wy, -wz, 0]])
Q = 0.5 * np.array([[q4, -q3, q2], [q3, q4, -q1], [-q2, q1, q4],
[-q1, -q2, -q3]])
Rbar = np.c_[2 * Q, -qbi]
Abar = np.array([[0, -az, ay], [az, 0, -ax], [-ay, ax, 0],
[-ax, -ay, -az]])
Cbi = self.Quate_ToDCM(qbi)
D = np.dot(2 * Cbi, np.dot(Abar.T, Rbar.T))
Fbg = -1 / self.Tau_g * I_33
Fba = -1 / self.Tau_a * I_33
F = np.r_(np.c_(Ze33, I_33, Ze34, Ze33, Ze33),
np.c_(G, Ze33, D, Ze33, Cbi), np.c_(Ze43, Ze43, Ome, Q,
Ze43),
np.c_(Ze33, Ze33, Ze34, Fbg, Ze33),
np.c_(Ze33, Ze33, Ze34, Ze33, Fba))
return F
def nonzip(self):
print np.r_(self.x_array, self.y_array, self.cl_array)
print np.c_(self.x_array, self.y_array, self.cl_array)
def transform(self, X):
"""
Transform a set of images.
Returns the features from each layer.
Parameters
----------
X : array-like, shape = [n_images, height, width, color]
or
shape = [height, width, color]
Returns
-------
T : array-like, shape = [n_images, n_features]
If force_reshape = False,
list of array-like, length output_layers,
each shape = [n_images, n_windows,
n_window_features]
Returns the features extracted for each of the n_images in X..
"""
X = check_tensor(X, dtype=np.float32, n_dim=4)
if self.batch_size is None:
if self.force_reshape:
return self.transform_function(
X.transpose(*self.transpose_order))[0].reshape(
(len(X), -1))
else:
return self.transform_function(
X.transpose(*self.transpose_order))
else:
XT = X.transpose(*self.transpose_order)
n_samples = XT.shape[0]
for i in range(0, n_samples, self.batch_size):
transformed_batch = self.transform_function(
XT[i:i + self.batch_size])
# at first iteration, initialize output arrays to correct size
if i == 0:
shapes = [(n_samples, ) + t.shape[1:]
for t in transformed_batch]
ravelled_shapes = [np.prod(shp[1:]) for shp in shapes]
if self.force_reshape:
output_width = np.sum(ravelled_shapes)
output = np.empty((n_samples, output_width),
dtype=transformed_batch[0].dtype)
break_points = np.r_([0], np.cumsum(ravelled_shapes))
raw_output = [
output[:, start:stop] for start, stop in zip(
break_points[:-1], break_points[1:])
]
else:
output = [
np.empty(shape, dtype=transformed_batch.dtype)
for shape in shapes
]
raw_output = [
arr.reshape(n_samples, -1) for arr in output
]
for transformed, out in zip(transformed_batch, raw_output):
out[i:i + batch_size] = transformed
return output
print "Counter", counter
if __name__ == '__main__':
carbons_init_list = [[2, 5], [1, 5]]
# carbons_init_list = [[1,5]]
pulses = 1
DD_scheme = 'auto'
el_after_init = 1
optimize = True
ssrocalib = True
debug = True
# FET = [0.015/(2.*pulses)]
FET = np.r_(0.01, 0.5)
wait_gate = True
logic_state_list = ['mX', 'pX']
# logic_state_list = ['mX']
debug = False
sleep = 1
full_Tomo_basis_list = ([['X', 'X'], ['Y', 'Y'], ['Z', 'Z']])
full_Tomo_basis_list = ([['X', 'X'], ['Y', 'Y'], ['Z', 'Z']])
full_Tomo_basis_list = ([['X', 'X']])
# full_Tomo_basis_list = ([['X','X']])
# full_Tomo_basis_list = ([['DFS']])
# el_RO_list = ['positive']
def visible(mesh: Mesh.Mesh, r: np.ndarray) -> np.ndarray:
rotated_vertices = r.dot(
np.hstack([mesh.vertices,
np.ones([len(mesh.vertices), 1])]).T).T[:, :3]
z = rotated_vertices[:, 2]
uv = rotated_vertices[:, :]
uv[:, 0] = uv - np.min(uv[:, 0], axis=0)
uv = uv + 1
uv = uv / np.max(uv) * 1000
width = 1000
height = 1000
faces = np.array(mesh.tvi)
v1 = faces[:, 0]
v2 = faces[:, 1]
v3 = faces[:, 2]
nfaces = np.shape(faces)[0]
x = np.c_[uv[v1, 0], uv[v2, 0], uv[v3, 0]]
y = np.c_[uv[v1, 1], uv[v2, 1], uv[v3, 1]]
minx = np.ceil(x.min(1))
maxx = np.floor(x.max(1))
miny = np.ceil(y.min(1))
maxy = np.floor(y.max(1))
del x, y
minx = np.clip(minx, 0, width - 1)
maxx = np.clip(maxx, 0, width - 1)
miny = np.clip(miny, 0, height - 1)
maxy = np.clip(maxy, 0, height - 1)
[rows, cols] = np.meshgrid(np.linspace(1, 1000, num=1000),
np.linspace(1, 1000, num=1000))
zbuffer = -np.inf(height, width)
fbuffer = np.zeros(height, width)
for i in range(nfaces):
if minx[i] <= maxx[i] and miny[i] <= maxy[i]:
px = rows[miny[i]:maxy[i], minx[i]:maxx[i]]
py = cols[miny[i]:maxy[i], minx[i]:maxx[i]]
px = px[:]
py = py[:]
e0 = uv[v1[i], :]
e1 = uv[v2[i], :]
e2 = uv[v3[i], :]
det = e1[0] * e2[1] - e1[1] * e2[0]
tmpx = px - e0[0]
tmpy = py - e0[1]
a = (tmpx * e2[1] - tmpy * e2[0]) / det
b = (tmpx * e1[0] - tmpy * e1[1]) / det
test = a >= 0 & b >= 0 & a + b <= 1
if np.any(test):
px = px[test]
py = py[test]
w2 = a[test]
w3 = b[test]
w1 = 1 - w3 - w2
pz = z[v1[i]] * w1 + z[v2[i]] * w2 + z[v3[i]] * w3
if pz > zbuffer[py, px]:
zbuffer[py, px] = pz
fbuffer[py, px] = i
test = fbuffer != 0
f = np.unique(fbuffer[test])
v = np.unique(np.r_(v1[f], v2[f], v3[f]))
return v
def sequential_stream_track(q_len,
traces,
access_type,
seq_size_threshold=None):
'''
[n_seq_cmd, n_seq_stream, n_read_cmd, n_total_cmd,size_dist,seq_stream_length_count,seq_stream_length_count_limited,ex_record]=sequential_stream_track(q_len, traces, access_type,seq_size_threshold)
calculate the near sequential stream's stack
input:
q_len: designed queue length
traces: nx3 matrix for IO events (start_lba, size, access mode)
access_type: decide if only consider read 1/write 0 or combine 2
seq_size_threshold: the threshold to role in sequential stream, i.e., if
the stream size >=seq_size_threshold, the stream will be counted as a
sequential stream
output:
n_seq_cmd: number of sequential commands
n_seq_stream: number of sequential streams
n_read_cmd: number of read commands
n_total_cmd: number of total commands
size_dist: request size distribution for sequential commands
seq_stream_length_count: 1 value at array index i corresponding to the number/frequecy of commands with sequence command length =i; 2: total request size in this index; --> 2/1 average request size
seq_stream_length_count_limited: similar to above with constraint seq_size_threshold; only the stream request size is >= seq_size_threshold, it is counted. --> less than above
ex_record: record for contrained cmd and stream number
Author: [email protected]
'''
# access_type: decide if only consider read 1/write 0 or combine 2
total_cmd, b = shape(traces)
queue_index = 0
print('Sequence analysis: Queue length =' + str(q_len) +
' and access type =' + str(access_type))
LRU_queue = -ones((q_len, 4), dtype=uint64)
seq_cmd_count = 0
seq_stream_count = 0
max_stream_length = 1024
seq_stream_length_count = zeros((max_stream_length, 2), dtype=uint32)
seq_stream_length_count_limited = zeros((max_stream_length, 2),
dtype=uint32)
max_size = max(traces[:, 1])
size_dist = zeros((max_size, 1))
idx_read = nonzero(traces[:, 2] == 1)
read_cmd_count = shape(idx_read)[1]
ex_record = ex_record_class(0, 0)
# ex_record.cmd_number = (0)
# ex_record.stream_number = (0)
for cmd_id in arange(0, total_cmd).reshape(-1):
#Get the trace information
start_lba = traces[cmd_id, 0]
end_lba = traces[cmd_id, 0] + traces[cmd_id, 1] - 1
access_mode = traces[cmd_id, 2]
#Here, only read or write?
if (access_type == 0):
if access_mode == 1:
continue
else:
if access_type == 1:
if access_mode == 0:
continue
#We scan through the LRU queue to see whether this command can be connected
#to a sequential stream
find_sequential = 0
for q_i in arange(0, queue_index).reshape(-1):
if start_lba == LRU_queue[q_i, 1] + 1:
if LRU_queue[q_i, 2] == 1:
seq_cmd_count = seq_cmd_count + 1
LRU_queue[q_i, 3] = LRU_queue[q_i, 3] + 1
size_dist[traces[cmd_id, 1] -
1] = size_dist[traces[cmd_id, 1] - 1] + 1
else:
LRU_queue[q_i, 2] = 1
LRU_queue[q_i, 3] = 2
seq_stream_count = seq_stream_count + 1
seq_cmd_count = seq_cmd_count + 2
first_cmd_length = int(LRU_queue[q_i, 1] -
LRU_queue[q_i, 0] + 1)
size_dist[first_cmd_length -
1] = size_dist[first_cmd_length - 1] + 1
size_dist[traces[cmd_id, 1] -
1] = size_dist[traces[cmd_id, 1] - 1] + 1
find_sequential = 1
LRU_queue[q_i, 1] = end_lba
break
#######################################################################
# if there is no sequential stream for attaching.
if logical_not(find_sequential):
queue_index = queue_index + 1
if queue_index > q_len:
queue_index = (q_len)
if LRU_queue[0, 3] > max_stream_length:
seq_stream_length_count = (r_[seq_stream_length_count,
zeros((LRU_queue[0, 3] -
max_stream_length, 2),
dtype=uint32)])
seq_stream_length_count_limited = (
r_[seq_stream_length_count_limited,
zeros((LRU_queue[0, 3] - max_stream_length, 2),
dtype=uint32)])
max_stream_length = LRU_queue[0, 3]
# # used to record the exceptation over 1024
# if LRU_queue(1,4)>1024
# ex_record.number=ex_record.number+1;
# end
idx = int(LRU_queue[0, 3])
if idx > 0:
#print(idx)
seq_stream_length_count[
idx - 1, 0] = seq_stream_length_count[idx - 1, 0] + 1
seq_stream_length_count[
idx - 1, 1] = seq_stream_length_count[
idx - 1, 1] + LRU_queue[0, 1] - LRU_queue[0, 0] + 1
# seq_stream_length_count[idx,0]=seq_stream_length_count[idx,0] + 1
# seq_stream_length_count[idx,1]=seq_stream_length_count[idx,1] + LRU_queue[0,1] - LRU_queue[0,0] + 1
if (idx > 0) and (LRU_queue[0, 1] - LRU_queue[0, 0] + 1 >=
seq_size_threshold):
seq_stream_length_count_limited[
idx - 1,
0] = seq_stream_length_count_limited[idx - 1, 0] + 1
seq_stream_length_count_limited[
idx - 1, 1] = seq_stream_length_count_limited[
idx - 1, 1] + LRU_queue[0, 1] - LRU_queue[0, 0] + 1
# seq_stream_length_count_limited[idx,0]=seq_stream_length_count_limited[idx,0] + 1
# seq_stream_length_count_limited[idx,1]=seq_stream_length_count_limited[idx,1] + LRU_queue[0,1] - LRU_queue[0,0] + 1
ex_record.cmd_number = (ex_record.cmd_number + idx)
LRU_queue[0:queue_index - 1, :] = LRU_queue[1:queue_index, :]
LRU_queue[queue_index - 1, 0] = start_lba
LRU_queue[queue_index - 1, 1] = end_lba
LRU_queue[queue_index - 1, 2] = 0
LRU_queue[queue_index - 1, 3] = 0
for j in arange(0, q_len).reshape(-1):
if LRU_queue[j, 3] > max_stream_length:
seq_stream_length_count = (r_([
seq_stream_length_count,
zeros((LRU_queue[j, 3] - max_stream_length, 2))
]))
seq_stream_length_count_limited = (
r_[seq_stream_length_count_limited,
zeros((LRU_queue[j, 3] - max_stream_length, 2))])
max_stream_length = LRU_queue[j, 3]
## need to debug the following lines
# if LRU_queue(j,4)>0
# seq_stream_length_count(LRU_queue(j,4),1)=seq_stream_length_count(LRU_queue(j,4),1)+1;
# seq_stream_length_count(LRU_queue(j,4),2)=seq_stream_length_count(LRU_queue(j,4),2)+1+LRU_queue(q_i, 2)-LRU_queue(q_i, 1);
# end
# if (LRU_queue(q_i,4)>0) && (LRU_queue(q_i, 2)-LRU_queue(q_i, 1)+1>=seq_size_threshold)
# seq_stream_length_count_limited(LRU_queue(q_i,4),1)=seq_stream_length_count_limited(LRU_queue(q_i,4),1)+1;
# seq_stream_length_count_limited(LRU_queue(q_i,4),2)=seq_stream_length_count_limited(LRU_queue(q_i,4),2)+1+LRU_queue(q_i, 2)-LRU_queue(q_i, 1);
# ex_record.cmd_number=ex_record.cmd_number+LRU_queue(q_i,4);
# end
n_seq_cmd = copy(seq_cmd_count)
n_seq_stream = copy(seq_stream_count)
n_read_cmd = copy(read_cmd_count)
n_total_cmd = copy(total_cmd)
ex_record.stream_number = (sum(seq_stream_length_count_limited[:, 0]))
return n_seq_cmd, n_seq_stream, n_read_cmd, n_total_cmd, size_dist, seq_stream_length_count, seq_stream_length_count_limited, ex_record
levels = rvect("list", length(levels))
names(levels) = levels(conditions)
for l in levels(conditions):
levels[[l]] = which(conditions == l)
if length(levels[[l]]) < 2:
stop("condition level '",l,"' has less than two replicates")
# end sanity check
if verbose == True:
print("sanity check complete")
# Summarize the relative abundance (rab) win and all groups
rab = rvect( "list", 3 )
names(rab) = np.r_( "all", "win", "spl" )
rab$win = tuple()
#this is the median value across all monte carlo replicates
cl2p = NULL
for m in getMonteCarloInstances(clr):
cl2p = cbind(cl2p, m)
rab$all = t(apply(cl2p, 1, median))
rm(cl2p)
gc()
if verbose == True
print("rab.all complete")
#this is the median value across all monte carlo replicates per level
def multilayer_extraction(edgelist, seed, min_score, prop_sample):
m = max(list(edgelist['layer']))
n = len(np.unique(edgelist['node1'].append(edgelist['node2'])))
# Calculate the Modularity Matrix
# Use Expectation_CM
print("Estimation Stage")
mod_mat = expCM.expectation_CM(edgelist)
# Initialize the Communities
print("Initialization Stage")
initial_set = None
for i in range(0, m + 1):
graph = nx.parse_edgelist(
format_edgelist.format_edgelist(edgelist[edgelist['layer'] == i]))
if i == 0:
initial_set = init.initialization(graph, prop_sample, m, n)
else:
initial_set.append(init.initialization(graph, prop_sample, m, n))
# Search Across Initial Sets
print("Search Stage")
print("Seaching over",
len(initial_set['vertex_set']),
"seed sets \n",
sep=" ")
results_temp = pd.DataFrame()
k = len(initial_set['vertex_set'])
# Detect number of cores present on your machine
cores = mp.cpu_count()
for i in range(0, k):
starter = pd.DataFrame()
starter['vertex_set'] = initial_set["vertex_set"][i]
if len(starter["vertex_set"] < 2):
starter["vertex_set"] = np.r_(
starter["vertex_set"],
list(set(range(1, n)) - set(starter["vertex_set"]))[i])
starter["layer_set"] = initial_set["layer_set"][i]
temp = single_swap(starter, mod_mat, m, n)
results_temp.extend(temp)
print("Cleaning Stage")
if len(results_temp) < 1:
return "No Community Found"
scores = np.repeat(0, len(results_temp))
for i in range(1, len(results_temp)):
if len(results_temp["layer_set"][i]) == 0:
scores[i] = -1000
if len(results_temp["layer_set"][i]) > 0:
scores[i] = results_temp[i]
scores = round(scores[5])
indx = np.where(np.unique(scores))
indx2 = np.where(scores > min_score)
results2 = results_temp[list(set(indx).intersection(indx2))]
betas = list()
mean_score = list()
number_communities = list()
results3 = list()
if len(results2) <= 0:
results = None
return None
elif len(results2) > 0:
betas = [1] * 100
number_communities = [0] * len(betas)
mean_score = [0] * len(betas)
for i in range(0, len(betas)):
temp = None # Cleanup
results3[i] = None # List of betas and communities
mean_score[i] = None # mean score of temp list
number_communities[i] = None # length of temp communities
z = pd.DataFrame({
"Betas": betas,
"Mean Score": mean_score,
"Number Communities": number_communities
})
multi = pd.DataFrame({"Community List": results3, "Diagnostics": z})
return multi
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy.spatial import ConvexHull
points = np.random.rand(30, 2)
hull = ConvexHull(points)
plt.plot(points[:, 0], points[:, 1], 'o')
for simplex in hull.simplices:
plt.plot(points[simplex, 0], points[simplex, 1], 'k-')
plt.show()
plt.scatter()
data = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
data.reset_index()
data.sort_values()
a1 = [1, 2, 3]
a2 = [4, 5, 6]
np.r_(a1, a2)
np.concatenate()
np.append()
np.stack()
np.hstack()
pd.cut()
import numpy as np
import skfuzzy as fuzz
# taking fuzzy sets A and B as user inputs
print("Enter elements of A")
a_x = input()
a_x = np.r_(a_x)
# print(a_x)
print("Enter memership values of corresponding elements of A")
a_mx = input()
a_mx = np.r_(a_mx)
# print(a_mx)
print("Enter elements of B")
b_x = input()
b_x = np.r_(b_x)
# print(b_x)
print("Enter memership values of corresponding elements of B")
b_mx = input()
b_mx = np.r_(b_mx)
# print(b_mx)
# LHS wrong
m, mfm = fuzz.fuzzymath.fuzzy_or(a_x, a_mx, b_x, b_mx)
print("Union:")
print(m)
print(mfm)
'''
