def __init__(self, vggModelPath='module/vgg16_weights.npz', modelPath=None, load = True):
self._fg = feature_generator.FeatureGenerator(vggModelPath)
if (not modelPath is None) and (load is True):
self._model = tf.keras.models.load_model(modelPath)
else:
self._model = None
self._modelPath = modelPath
def compute_min(self): import feature_generator as fg fg = fg.FeatureGenerator(self.num_features) max_value = np.inf max_num_vec = [] for num in range(2**self.num_features): num_vec = np.array([fg.get_binary(num, self.num_features)], dtype=np.int32) print(num_vec) value = self.run(num_vec) if(value < max_value): max_value = value max_num_vec = num_vec return max_value, max_num_vec
def main(yaml_file_path):
with open(yaml_file_path, 'r') as f:
configs = yaml.load(f)
logging.debug(str(configs))
json_path = ("{}\\{}").format(configs['directory_json_location'],
configs['json_file_name'])
logging.debug(json_path)
with open(json_path, 'r') as f:
pic_listings = json.load(f)
feature_generator = fg.FeatureGenerator(configs, pic_listings)
feature_pic_listing = feature_generator.generate_features()
with open('pics_features\\features_' + str(time.time()) + '.json',
'w') as f:
json.dump(feature_pic_listing, f)
def run(self, feature_vector):
x = feature_vector
'''
if(x.ndim != 1):
print("ERROR in dimension ", x.ndim)
return -1
#model_val = (x.dot(self.Q)*x).sum() # compute x^TQx row-wise
'''
model_val = (x.dot(self.Q)*x).sum() # compute x^TQx row-wise
penalty = self.lam*np.sum(x)
return (model_val - penalty)
def run_list(self, feature_vector):
x = feature_vector
# model_val = (x.dot(self.Q)*x).sum(axis=1) # compute x^TQx row-wise
model_val = (x.dot(self.Q)*x).sum(axis=1) # compute x^TQx row-wise
penalty = self.lam*np.sum(x,axis=1)
return (model_val - penalty)
if __name__=="__main__":
num_features = 10
x1 = fg.FeatureGenerator(num_features).generate_n_random_feature(1)
x = fg.FeatureGenerator(num_features).generate_n_random_feature(3)
suc_vec = fg.FeatureGenerator(num_features).generate_successor_graph(x[0])
for i in [100]:
for j in [1e-4]:
sim = BPQ_Sim(num_features, i, j)
print(sim.compute_min())
print(sim.run(np.array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1])[np.newaxis, :]))
# self.func_list[self.func_name](scaled_feature_vector),
# self.feature_restriction)
return self.func_list[self.func_name](scaled_feature_vector)
def run_list(self, feature_vector_list):
y_out_list = []
for feature_vector in feature_vector_list:
y_out_list.append(self.run(feature_vector))
return np.array(y_out_list)
if __name__ == "__main__":
import feature_generator as fg
sim = Simulator("borehole", True, 100, 1)
x = fg.FeatureGenerator(sim).generate_n_random_feature(3)
print(x)
print(sim.run_list(x))
sim = Simulator("univariate", True, 10, 10)
x = fg.FeatureGenerator(sim).generate_n_random_feature(3)
print(x)
print(sim.run_list(x))
sim = Simulator("univariate", True, 2, 6)
fg1 = fg.FeatureGenerator(sim)
x = fg1.generate_n_random_feature(3)
print(x)
print(sim.run_list(x))
for x1 in x:
print(sim.get_continous_value(x1, 0) * 64)
import feature_generator
import random
import cv2
import numpy as np
import tensorflow as tf
import tqdm
import logging
import perspective_param_generator
import os
import openimg
fg = feature_generator.FeatureGenerator("module/vgg16_weights.npz")
img1 = openimg.OpenImage("./images/1.jpeg", False)
img2 = openimg.OpenImage("./images/2.jpeg", False)
img3 = openimg.OpenImage("./images/3.jpeg", False)
w1, h1, _ = img1.shape
w2, h2, _ = img2.shape
w3, h3, _ = img3.shape
o, n, H, HL, HV = perspective_param_generator.GenerateRandomPerspectiveTransform(
[100, 100], 224, 0.3)
img_t = cv2.warpPerspective(img1, HV, dsize=(h1, w1))
piece = img1[o[0][0]:o[2][0], o[0][1]:o[1][1]]
piece_t = img_t[o[0][0]:o[2][0], o[0][1]:o[1][1]]
print(piece.shape)
baseFeature = fg.MakeFeature(piece)
subFeature = fg.MakeFeature(piece_t)
feature = fg.MakeDiffFeature(baseFeature, subFeature)