def __init__(self, mat_data, label_data):
self.x = np.mat(convert.list2npfloat(mat_data))
self.ys = np.mat(np.sign(convert.list2npfloat(label_data) - 0.5))
self.outbit = self.ys.shape[1]
self.svm4bit = []
for i in range(self.outbit):
self.svm4bit.append(SVM(self.x, self.ys[:, i]))
def __init__(self, mat_data, label_data):
self.mat_data = convert.list2npfloat(mat_data)
self.label_data = convert.list2npfloat(label_data)
self.out_bit = len(label_data[0])
self.mat_w = np.array([ [random.random() * 0.001 + sys.float_info.epsilon\
for i in range(len(mat_data[0]))] \
for j in range(self.out_bit) ], dtype=np.float64)
self.mat_w0 = np.array([random.random() * 0.001 + sys.float_info.epsilon\
for i in range(self.out_bit) ], dtype=np.float64)
def __init__(self, mat_data, label_data):
self.mat_data = convert.list2npfloat(mat_data)
self.label_data = convert.list2npfloat(label_data)
self.out_bit = len(label_data[0])
self.mat_w = [ [ (random.random() * 0.0001 + sys.float_info.epsilon)\
for i in range(len(mat_data[0]))] \
for j in range(self.out_bit) ]
self.mat_w0 = [ random.random() * 0.0001 + sys.float_info.epsilon\
for i in range(self.out_bit) ]
def __init__(self, mat_data, label_data, hl_list):
self.mat_data = convert.list2npfloat(mat_data)
self.y = convert.list2npfloat(label_data)
self.il_size = self.mat_data.shape[1]
self.ol_size = self.y.shape[1]
self.hl_list = hl_list
self.W = {}
self.B = {}
self.hl_list.append(self.ol_size)
last_layer_num = self.il_size
for idx, hl_num in enumerate(hl_list):
self.W["WD_" + str(idx)] = 0.1 * random.randn(hl_num, last_layer_num)
self.B["BD_" + str(idx)] = 0.1 * random.randn(hl_num)
last_layer_num = hl_num
def __init__(self, mat_data, label_data, hl_list):
self.mat_data = convert.list2npfloat(mat_data)
self.y = convert.list2npfloat(label_data)
self.il_size = self.mat_data.shape[1]
self.ol_size = self.y.shape[1]
self.hl_list = hl_list
self.W = {}
self.B = {}
self.hl_list.append(self.ol_size)
last_layer_num = self.il_size
for idx, hl_num in enumerate(hl_list):
self.W['WD_' + str(idx)] = 0.00001 * np.random.randn(
hl_num, last_layer_num)
self.B['BD_' + str(idx)] = 0.00001 * np.random.randn(hl_num)
last_layer_num = hl_num
def __init__(self, mat_data, dist_func):
self.mat_data = convert.list2npfloat(mat_data)
self.dist_func = ptmath.distfunc(dist_func)
self.col_len = float(len(self.mat_data[0]))
self.row_len = float(len(self.mat_data))
self.min_col = self.mat_data.min(axis=0)
self.max_col = self.mat_data.max(axis=0)
def __init__(self, mat_data, eps, min_pts, dist_func):
self.mat_data = convert.list2npfloat(mat_data)
self.dist_func = ptmath.distfunc(dist_func)
self.eps = eps
self.min_pts = min_pts
self.col_len = len(self.mat_data[0])
self.row_len = len(self.mat_data)
def __init__(self, mat_data, eps, min_pts, dist_func):
self.mat_data = convert.list2npfloat(mat_data)
self.dist_func = ptmath.distfunc(dist_func)
self.eps = eps
self.min_pts = min_pts
self.col_len = len(self.mat_data[0])
self.row_len = len(self.mat_data)
def __init__(self, mat_data, label_data):
self.mat_data = convert.list2npfloat(mat_data)
self.label_data = label_data
self.mat_mean = {}
self.mat_variance = {}
self.label_count = {}
self.label_count_sum = 0
def __init__(self, mat_data, label_data):
self.mat_data = convert.list2npfloat(mat_data)
self.label_data = label_data
self.mat_mean = {}
self.mat_variance = {}
self.label_count = {}
self.label_count_sum = 0
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
deviate_arr = self.mat_mean_arr - tile(array_input,(self.num_label,1))
gaussian_bayes = (deviate_arr ** 2 / ((self.mat_variance_arr ** 2) * 2)) * -1 \
- log(self.mat_variance_arr)
gaussian_prob = gaussian_bayes.sum(axis=1) + log(self.label_count_arr)\
-log(tile(array(self.label_count_sum),(1,self.num_label)))
best_label_index = gaussian_prob[0].argsort()[::-1][0]
return self.label_map[ best_label_index]
def __init__(self, mat_data, K, dist_func):
self.mat_data = convert.list2npfloat(mat_data)
self.dist_func = ptmath.distfunc(dist_func)
self.K = K
self.col_len = len(self.mat_data[0])
self.row_len = len(self.mat_data)
self.unique_idx = 0
self.group_list = []
self.dist_list = []
self.cluster_points = []
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
deviate_arr = self.mat_mean_arr - tile(array_input,
(self.num_label, 1))
gaussian_bayes = (deviate_arr ** 2 / ((self.mat_variance_arr ** 2) * 2)) * -1 \
- log(self.mat_variance_arr)
gaussian_prob = gaussian_bayes.sum(axis=1) + log(self.label_count_arr)\
-log(tile(array(self.label_count_sum),(1,self.num_label)))
best_label_index = gaussian_prob[0].argsort()[::-1][0]
return self.label_map[best_label_index]
def predict(self, input_array):
input_array = convert.list2npfloat(input_array)
label_count = {}
for idx, trg in enumerate(self.mat_data):
if self.dist_func(input_array, trg) <= self.eps:
label = self.label_of_data[idx]
label_count[label] = label_count.get(label, 0) + 1
sorted_label_count = sorted(label_count.iteritems()\
, key=operator.itemgetter(1), reverse=True)
return sorted_label_count[0][0]
def predict(self, input_array):
input_array = convert.list2npfloat(input_array)
label_count = {}
for idx, trg in enumerate(self.mat_data):
if self.dist_func(input_array, trg) <= self.eps:
label = self.label_of_data[idx]
label_count[label] = label_count.get(label, 0) + 1
sorted_label_count = sorted(label_count.iteritems()\
, key=operator.itemgetter(1), reverse=True)
return sorted_label_count[0][0]
def quantile(data_mat):
data_mat = convert.list2npfloat(data_mat)
min_vals = data_mat.min(0)
max_vals = data_mat.max(0)
ranges = max_vals - min_vals
ranges = map(lambda x : x + sys.float_info.epsilon ,ranges)
normalized_data_mat = zeros(shape(data_mat))
rowsize = data_mat.shape[0]
normalized_data_mat = data_mat - tile(min_vals, (rowsize,1))
normalized_data_mat = normalized_data_mat / tile(ranges,(rowsize,1))
return normalized_data_mat
def quantile(data_mat):
data_mat = convert.list2npfloat(data_mat)
min_vals = data_mat.min(0)
max_vals = data_mat.max(0)
ranges = max_vals - min_vals
ranges = map(lambda x: x + sys.float_info.epsilon, ranges)
normalized_data_mat = zeros(shape(data_mat))
rowsize = data_mat.shape[0]
normalized_data_mat = data_mat - tile(min_vals, (rowsize, 1))
normalized_data_mat = normalized_data_mat / tile(ranges, (rowsize, 1))
return normalized_data_mat
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
distances = []
for trg in self.mat_data:
distances.append(self.dist_func(array_input, trg))
distances = np.array(distances)
sorted_distances = distances.argsort()
class_count = {}
for i in range(self.k):
kth_label = str(self.label_data[sorted_distances[i]])
class_count[kth_label] = class_count.get(kth_label, 0) + 1
sorted_class_count = sorted(class_count.iteritems(), key=operator.itemgetter(1), reverse=True)
return sorted_class_count[0][0]
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
distances = []
for trg in self.mat_data:
distances.append(self.dist_func(array_input, trg))
distances = np.array(distances)
sorted_distances = distances.argsort()
class_count = {}
for i in range(self.k):
kth_label = str(self.label_data[sorted_distances[i]])
class_count[kth_label] = class_count.get(kth_label, 0) + 1
sorted_class_count = sorted(class_count.iteritems(),
key=operator.itemgetter(1),
reverse=True)
return sorted_class_count[0][0]
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
return map(round,map(ptmath.sigmoid,(array_input * self.mat_w).sum(axis=1) \
+ self.mat_w0))
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
return map(round,map(ptmath.sigmoid,(array_input * self.mat_w).sum(axis=1) \
+ self.mat_w0))
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
return (array_input * self.mat_w).sum(axis=1) \
+ self.mat_w0
def predict(self, array_input):
array_input = np.mat(convert.list2npfloat(array_input))
output = []
for i in range(self.outbit):
output.append(self.svm4bit[i].predict(array_input))
return list(np.sign(np.array(output) + 1))
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
return (array_input * self.mat_w).sum(axis=1) \
+ self.mat_w0
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
out, layer = self.feedforward(array_input)
return out
def predict(self, input_array):
input_array = convert.list2npfloat(input_array)
return self.assign_row(self.cluster_points, input_array)
def __init__(self, mat_data, label_data, k, dist_func):
self.mat_data = convert.list2npfloat(mat_data)
self.dist_func = ptmath.distfunc(dist_func)
self.label_data = label_data
self.train_size = self.mat_data.shape[0]
self.k = k
def predict(self, array_input):
array_input = convert.list2npfloat(array_input)
out, layer = self.feedforward(array_input)
return out
def __init__(self, mat_data, label_data, k, dist_func):
self.mat_data = convert.list2npfloat(mat_data)
self.dist_func = ptmath.distfunc(dist_func)
self.label_data = label_data
self.train_size = self.mat_data.shape[0]
self.k = k
