def get(self, image=None, region=None, hog_color_space_convert=None, hog_channels=None,
hog_cell_per_block=None, hog_orient=None, hog_pix_per_cell=None):
# key = repr((image, region))
key = str(zlib.crc32(image.data.tobytes())) + str(hog_pix_per_cell[0]) + str(hog_pix_per_cell[1])
# key = zlib.crc32(bytes(repr([image_key, region['top_left']['x'], region['top_left']['y'], region['bottom_right']['x'],
# region['bottom_right']['y'], hog_color_space_convert, hog_channels, hog_cell_per_block, hog_orient,
# hog_pix_per_cell]), encoding='ascii'))
feature_extractor = FeatureExtractor(
region=region,
hog_color_space_convert=hog_color_space_convert,
hog_channels=hog_channels,
hog_pix_per_cell=hog_pix_per_cell,
hog_cell_per_block=hog_cell_per_block,
hog_orient=hog_orient
)
if key in self.cache:
feature_extractor.features = self.cache[key]
else:
feature_extractor.extract(image)
self.cache[key] = feature_extractor.features
return feature_extractor
def __preprocess(self):
feature_extractor = FeatureExtractor(self.dataset_path,
self.feature_groups)
for valid_dir in ["valid{}".format(str(n)) for n in range(5)]:
print("\t\t=== {} : {:^10} ===".format(valid_dir, "train"))
feature_extractor.extract(part="train", valid_dir=valid_dir)
print("\t\t=== {} : {:^10} ===".format(valid_dir, "validate"))
feature_extractor.extract(part="validate", valid_dir=valid_dir)
if need_prediction() or only_prediction():
print("\t\t=== {} : {:^10} ===".format(valid_dir, "test"))
feature_extractor.extract(part="test", valid_dir=valid_dir)
return feature_extractor.get_feature_names()
def send_frames(size, host_ip):
extractor = FeatureExtractor('../ncs/ncs_models/ucf101-resnet18.bin',
'../ncs/ncs_models/ucf101-resnet18.xml')
video_capture = cv2.VideoCapture(0)
sender = imagezmq.ImageSender(connect_to='tcp://%s:5555' % host_ip)
while True:
ret, frame = video_capture.read()
# frame = np.copy(f.array)
sender.send_image(socket.gethostname(), frame)
frame = extractor.preprocess_frame(frame)
features = extractor.extract(frame)
sender.send_image(socket.gethostname(), features['218'])
if cv2.waitKey(1) == ord('q'):
break
video_capture.release()
cv2.destroyAllWindows()
def extract_features(self, image):
# Create a list to append feature vectors to
region = {
'top_left': {
'x': 0,
'y': 0,
},
'bottom_right': {
'x': image.shape[1],
'y': image.shape[0],
}
}
feature_extractor = FeatureExtractor(
hog_color_space_convert=self.hog_color_space_convert,
region=region,
hog_channels=self.hog_channels,
hog_pix_per_cell=self.hog_pix_per_cell,
hog_cell_per_block=self.hog_cell_per_block,
hog_orient=self.hog_orient
)
return feature_extractor.extract(image)
from PIL import Image
from feature_extractor import FeatureExtractor
from pathlib import Path
import numpy as np
import pickle
if __name__ == '__main__':
fe = FeatureExtractor()
img_paths=[]
features=[]
for img_path in sorted(Path("./static/img").glob("*.jpg")):
print(img_path) # e.g., ./static/img/xxx.jpg
feature = fe.extract(img=Image.open(img_path))
features.append(feature)
img_paths.append(img_path)
features = np.array(features)
print(len(img_paths),len(features))
img_paths_Pickle = open('./static/img_paths_Pickle', 'wb')
pickle.dump(img_paths, img_paths_Pickle)
features_Pickle = open('./static/feature/features_Pickle', 'wb')
pickle.dump(features, features_Pickle)
from pathlib import Path
import numpy as np
from PIL import UnidentifiedImageError
from tensorflow.keras.preprocessing.image import load_img
from feature_extractor import FeatureExtractor
from PIL.Image import open
if __name__ == '__main__':
fe = FeatureExtractor()
for img_path in sorted(Path("./static/img").glob("*.jpg")):
try:
feature_path = Path("./static/feature") / (
img_path.stem + ".npy") # e.g., ./static/feature2/xxx.npy
if feature_path.exists():
continue
print(img_path) # e.g., ./static/img/xxx.jpg
feature = fe.extract(load_img(img_path, color_mode='rgb'))
np.save(feature_path, feature)
except UnidentifiedImageError as e:
print("Wrong Image" + str(e))
while True:
## Read in a frame
ret, frame = video_stream.read()
if frame is None: break
height, width, _ = frame.shape
frame_id += 1
## Buffer to annotate the original video
frame_buffer.append(frame)
## Collect and predict action for 60 frames
if len(frame_buffer) == 60:
processed_frames = extractor.preprocess_clip_stream(
frame_buffer)
prediction, score = detector.detect(
extractor.extract(processed_frames))
## Annotate 60 frames and write it out to the output file
for f in frame_buffer:
cv2.putText(f, "%s: %f" % (prediction, score), (30, 50),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2,
cv2.LINE_AA)
if not LOG:
out.write(f)
if LOG:
print("%d %s %f" % (frame_id, prediction, score))
## Reset the buffer
frame_buffer = []
## If the 'q' key is pressed, break from the loop
if __name__ == '__main__':
args = sys.argv
if not len(args) == 2:
print('Usage: cmd modelpath')
exit()
modelpath = args[1]
print('Loading feature extractor...')
start = time.time()
fe = FeatureExtractor(modelpath)
fe.loadModel()
print('Model Load time: {:.4f}s'.format(time.time() - start))
# Change to use appropriate models
feMap = dict()
for k, _ in LABELS.items():
feMap[k] = fe
print('Warming up model...')
fe.extract(
np.random.randint(
0, 255, (fe.INPUT_HEIGHT, fe.INPUT_HEIGHT, 3)).astype(np.uint8))
fedb = FeatureVectorDatabase()
idAssociator = IdAssociator(feMap, fedb)
server = CentralServer(MQTT_SERVER, idAssociator)
server.run()
frame_id, frame_buffer = 0, []
with torch.no_grad():
while True:
ret, frame = video_stream.read()
if frame is None: break
height, width, _ = frame.shape
frame_id+=1
## Buffer to annotate the original video
frame_buffer.append(frame)
## Collect and predict action for CLIP_LEN frames
if len(frame_buffer) == CLIP_LEN:
processed_frames = extractor.preprocess_clip_stream(frame_buffer)
prediction, score = detector.detect(extractor.extract(processed_frames))
## Annotate CLIP_LEN frames and write it out to the output file
for f in frame_buffer:
cv2.putText(f,"%s: %f"%(prediction, score),(30,50),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,0),2,cv2.LINE_AA)
if not LOG:
out.write(f)
if LOG:
print("%d %s %f"%(frame_id, prediction, score))
## Reset the buffer
frame_buffer = []
## If the 'q' key is pressed, break from the loop
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
.avg_count_synsets() \
.difference_in_length() \
.similarity_diff_to_target() \
.max_dependency_tree_depth() \
.target_word_synset_count() \
.token_count_norm_diff()\
.elmo_similarity()
model_trainer = ModelTrainer(german_config, german_config.logger)
german_classifier = WordSenseAlignmentClassifier(german_config,
feature_extractor,
model_trainer)
data = german_classifier.load_data().get_preprocessed_data()
feats = feature_extractor.extract(data,
feats_to_scale=['len_diff', 'pos_diff'])
feats = feature_extractor.keep_feats(['pos_diff', 'lemma_match_normalized', 'NOUN', 'CCONJ', 'PUNCT',
'synsets_count_diff', 'len_diff', 'simdiff_to_target',
'target_word_synset_count', 'token_count_norm_diff', 'elmo_sim']) \
x_trainset, x_testset = model_trainer.split_data(feats, 0.0)
with open(
'models/en_nuig_split_biggestRandomForestClassifier20200331-0117.pickle',
'rb') as pickle_file:
clf = pickle.load(pickle_file)
predicted = clf.predict(x_trainset)
print(predicted)
predicted_series = pd.Series(predicted)
data['relation'] = predicted_series
german_predicted = data[['word', 'pos', 'def1', 'def2', 'relation']]
import glob
import os
import pickle
from PIL import Image
from feature_extractor import FeatureExtractor
fe = FeatureExtractor()
for img_path in sorted(glob.glob('static/img/*.jpg')):
print(img_path)
img = Image.open(img_path) # PIL image
print(img)
feature = fe.extract(img)
feature_path = 'static/feature/' + os.path.splitext(os.path.basename(img_path))[0] + '.pkl'
pickle.dump(feature, open(feature_path, 'wb'))
continue
if db_object.is_doc_type:
"""document"""
if db_object.contains_images:
images_array = []
images_id = []
for image in db_object.files:
pdf_image = str(uuid.uuid4()) + ".jpg"
with open(pdf_image, 'wb') as file_to_save:
file_to_save.write(image.file.read())
images_array.append(pdf_image)
images_id.append(image.file)
to_save = list()
for image, image_id in zip(images_array, images_id):
try:
image_feature = fe.extract(image)
feature_to_save = pickle.dumps(image_feature)
save_to_db(db_object, feature_to_save, file=image_id)
except Exception as e:
print(str(e) + "Exception in predict")
err_logger(str(e) + "Exception in predict")
continue
print(".....................FINISHED PROCESSING FILE.....................")
update_state(file_name)
else:
print(".....................FINISHED PROCESSING FILE.....................")
else:
"""image"""
with open(file_name, 'wb') as file_to_save:
file_to_save.write(db_object.file.read())
.difference_in_length() \
.similarity_diff_to_target() \
.max_dependency_tree_depth() \
.target_word_synset_count()
model_trainer = ModelTrainer(german_config, german_config.logger)
german_classifier = WordSenseAlignmentClassifier(german_config,
feature_extractor,
model_trainer)
data = german_classifier.load_data().get_preprocessed_data()
feats = feature_extractor.extract(data,
feats_to_scale=[
'similarities', 'len_diff', 'pos_diff',
'max_depth_deptree_1',
'max_depth_deptree_2', 'synset_count_1',
'synset_count_2',
'target_word_synset_count'
])
x_trainset, x_testset = model_trainer.split_data(feats, 0.0)
with open('models/en_nuig_svmVotingClassifier20200325-1321.pickle',
'rb') as pickle_file:
clf = pickle.load(pickle_file)
predicted = clf.predict(x_trainset)
print(predicted)
predicted_series = pd.Series(predicted)
data['relation'] = predicted_series
german_predicted = data[['word', 'pos', 'def1', 'def2', 'relation']]
german_predicted.to_csv('english_nuig_svm_20200325.csv',
sep='\t',
def make_training_data(feature_funcs, annotations):
"""
Given the FrameNet annotations, return the training instances in terms of the tree nodes
>>> from annotation import parse_fulltext
>>> annotations = parse_fulltext("test_data/annotation.xml")
>>> from features import DummyNodeFeature
>>> instances = make_training_data([DummyNodeFeature], annotations)
>>> len(instances) # 27 nodes times 2 annotations
52
>>> [i for i in instances if i[1] == 'Recipient'][0][0]
{'node_dummy': ([u'to', u'Goodwill'], u'PP')}
>>> [i for i in instances if i[1] == 'Donor'][0][0]
{'node_dummy': ([u'Your'], u'PRP$')}
>>> [i for i in instances if i[1] == 'Means'][0][0]
{'node_dummy': ([u'Your', u'contribution', u'to', u'Goodwill'], u'NP')}
>>> [i for i in instances if i[1] == 'Value'][0][0]
{'node_dummy': ([u'more', u'than', u'you', u'may', u'know'], u'ADVP')}
>>> from features import PathToFrame
>>> annotations = parse_fulltext("test_data/annotation3.xml")
>>> instances = make_training_data([PathToFrame], annotations)
"""
extractor = FeatureExtractor(feature_funcs)
training_instances = []
for sent_str, anns in annotations:
tree = parser.raw_parse(sent_str).next()
tree = convert_brackets(tree)
# print tree
# some preprocessing, align the positions and
# also use the sentence string given the parse tree
anns = align_annotation_with_sentence(sent_str,
' '.join(tree.leaves()), anns)
sent_str = ' '.join(tree.leaves())
for ann in anns:
frame_name = ann.frame_name
start, end = ann.target.start, ann.target.end
frame = Frame(start, end, frame_name)
frame_node = find_node_by_positions(tree, start, end)
# TODO: bug here
if frame_node is None:
sys.stderr.write(
"Warning: %r does not correspond to any tree node in sentence \"%s\"\nSkip it\n "
% (frame, sent_str))
continue
for node, (node_start_pos, node_end_pos) in collect_nodes(tree):
node_pos = NodePosition(node_start_pos, node_end_pos)
context = Context(sent_str, tree, frame, node_pos)
feature_values = extractor.extract(node, context)
# try to see the it has some semantic role
found_matching_node = False
for fe in ann.FE:
other_node = find_node_by_positions(tree, fe.start, fe.end)
if node == other_node:
training_instances.append((feature_values, fe.name))
found_matching_node = True
break
# semantic role => NULL
if not found_matching_node:
training_instances.append((feature_values, 'NULL'))
return training_instances
## return render_template('index.html')
##
##if __name__=="__main__":
## app.run()
##@app.route('/', methods=['GET', 'POST'])
#file = request.files['query_img']
#file="D:/tensorflow/sis-master/static/img/pic_559.png"
file = sys.argv[1]
img = Image.open(file) # PIL image
#img = Image.open(file.stream) # PIL image
#uploaded_img_path = "static/uploaded/" + datetime.now().isoformat() + "_" + file.filename
#img.save(uploaded_img_path)
query = fe.extract(img)
dist = np.linalg.norm(features - query, axis=1) # Do search
ids = np.argsort(dist)[:3]
dist = [dist[id] for id in ids]
retrieved_img_paths = [img_paths[id] for id in ids]
#print(retrieved_img_paths)
file = open("image_path.txt", "w")
print(dist)
for score, x in zip(dist, retrieved_img_paths):
img = Image.open(x)
img.show()
print(x + ',' + str(score))
file.write(x + "|" + str(score) + "\n")
file.close()
## cv2.imshow("Results 1-5", x)
## cv2.waitKey(0)
if not os.path.isfile(srcfile):
print(srcfile + " not exist!")
else:
fpath, fname = os.path.split(dstfile) #分离文件名和路径
if not os.path.exists(fpath):
os.makedirs(fpath) #创建路径
shutil.move(srcfile, dstfile) #移动文件
print("move " + srcfile + " -> " + dstfile + "\n")
fe = FeatureExtractor()
while True:
for img_path in sorted(glob.glob('static/processing-image/*.jpg')):
try:
print(img_path)
img = Image.open(img_path) # PIL image
feature = fe.extract(img)
feature_path_tmp = 'static/feature/' + os.path.splitext(
os.path.basename(img_path))[0] + '.tmp'
feature_path = 'static/feature/' + os.path.splitext(
os.path.basename(img_path))[0] + '.pkl'
pickle.dump(feature, open(feature_path_tmp, 'wb'))
movefile(img_path,
img_path.replace("static/processing-image", "static/img"))
movefile(feature_path_tmp, feature_path)
except:
pass
time.sleep(5)
# Convert arguments to description of features.
size = args.char_n_gram_size
character_grams = list(map(lambda x: (x, size), args.char_n_gram))
size = args.special_n_gram_size
special_grams = list(map(lambda x: (x, size), args.special_n_gram))
word_frequencies = args.word_frequencies
size = args.postag_n_gram_size
postag_grams = list(map(lambda x: (x, size), args.postag_n_gram))
size = args.word_n_gram_size
word_grams = list(map(lambda x: (x, size), args.word_n_gram))
# Get authors from input folder.
authors = analyse_input_folder(args.data_folder)
feature_extractor = FeatureExtractor(authors,
character_grams=character_grams,
special_character_grams=special_grams,
word_frequencies=word_frequencies,
postag_grams=postag_grams,
word_grams=word_grams,
corpus=args.corpus,
normalize=args.normalize,
feature_header=args.feature_header)
feature_extractor.extract(args.outfile, args.master_file)
folder = args[1]
modelpath = args[2]
md_file = os.path.join(folder, 'normalized_class_mapping.txt')
if not os.path.exists(md_file):
md_file = os.path.join(folder, 'class_mapping.txt')
if not os.path.exists(md_file):
print('No metadata found in folder {}'.format(folder))
exit()
fe = FeatureExtractor(modelpath)
print('Loading Model...')
start = time.time()
fe.loadModel()
print('Warming up model...')
fe.extract(cv2.imread('amur_small/002019.jpg'))
print('Total time to load model: {:.4f}s'.format(time.time() - start))
x_train_names, y_train, x_val_names, y_val = getTrainValData(folder, md_file)
print('Train classes: {}, Valid Classes: {}'.format(len(set(y_train)), len(set(y_val))))
print('Total Train images: {}, Total validation images: {}'.format(len(x_train_names), len(x_val_names)))
print('Extracting features...This could take a while...')
start = time.time()
# Extract feature for each image in training set
x_train = np.asarray([fe.extract(cv2.imread(x)) for x in x_train_names])
x_val = np.asarray([fe.extract(cv2.imread(x)) for x in x_val_names])
total_time = time.time() - start
print('Total Feature extraction time: {:.4f}s, Average time per feature extraction: {:.4f}s'.format(total_time, total_time / (len(x_train) + len(x_val))))
from log_parser import LogParser
from feature_extractor import FeatureExtractor
from clustering import Clustering
from idf import IDF
parser = LogParser('../../data/HDFS_2K.log')
tagged_events, log_sequences = parser.parse()
extractor = FeatureExtractor(log_sequences, list(tagged_events.keys()))
log_sequences = extractor.extract()
clustering = Clustering(log_sequences, tagged_events)
cluster_ids, cluster_values, silhouette = clustering.cluster()
for cluster_value in cluster_values:
if cluster_value['num_possible_abnormal_events'] != 0:
print(cluster_value)
print()
#print ("El coeficiente de silueta es =", silhouette)
.tfidf() \
.ont_hot_pos() \
.matching_lemma() \
.count_each_pos() \
.cosine() \
.jaccard() \
.difference_in_length()
model_trainer = ModelTrainer(german_config, german_config.logger)
german_classifier = WordSenseAlignmentClassifier(german_config,
feature_extractor,
model_trainer)
data = german_classifier.load_data().get_preprocessed_data()
feats = feature_extractor.extract(
data, feats_to_scale=['similarities', 'len_diff', 'pos_diff'])
feats = feature_extractor.keep_feats([
'similarities', 'cos_tfidf', 'ADP', 'DET', 'pos_diff', 'len_diff', 'PRON',
'CONJ', 'X', 'PROPN', 'NOUN', 'cos', 'ADJ', 'VERB', 'jaccard', 'PUNCT',
'noun', 'ADV', 'adjective'
])
x_trainset, x_testset = model_trainer.split_data(feats, 0.0)
with open(
'models/dutch_all_features_nonebalanceRandomForestClassifier20200329-1354.pickle',
'rb') as pickle_file:
clf = pickle.load(pickle_file)
predicted = clf.predict(x_trainset)
print(predicted)
predicted_series = pd.Series(predicted)
data['relation'] = predicted_series
import os
from feature_extractor import FeatureExtractor
import feature_extractor as fe
from PIL import Image
import glob
import numpy as np
dir_path = os.path.dirname(os.path.realpath(__file__))
data_dir = dir_path + '/' + "static/data"
feature_dir = dir_path + '/' + "features"
os.makedirs(data_dir, exist_ok=True)
os.makedirs(feature_dir, exist_ok=True)
f = FeatureExtractor()
#f.store_features(data_dir , feature_dir)
#fe.store_features(data_dir , feature_dir)
data_path = data_dir
storing_path = feature_dir
for each in glob.glob(data_path + '/*'):
image_name = (each.rsplit('/', 1)[-1]).rsplit('.jpg')[0]
img = Image.open(each)
feature = f.extract(img)
np.save(storing_path + '/' + image_name, feature)
