def predict(self, sentence):
"predict a sentence based on trained classifier"
if self.trained == 0:
print >> sys.stderr, 'please train the classifier first'
return None
sent_feat = util.get_feature(sentence, self.all_tokens)
return self.classifier.classify(sent_feat)
def predict(self, sentence):
"predict a sentence based on trained classifier"
if self.trained == 0:
print >> sys.stderr, 'please train the classifier first'
return None
sent_feat = util.get_feature(sentence, self.all_tokens)
return self.classifier.classify(sent_feat)
def __init__(self):
K.clear_session()
self.features = get_feature('./video_features/', './audio_features/')
self.video_features = self.features.load_video_features()
self.audio_features, self.audio_list = self.features.load_audio_features(
)
self.library_features, self.library_list = self.load_library_features()
self.dataset_length = len(self.audio_features)
self.generator = wgan.WGAN().build_generator()
self.generator.load_weights('./models/wgan_generator1_weights.hdf5')
def train(self, epochs=10000, batch_size=128):
#training features
features = util.get_feature(
'../final_video_features_with_scene_train/',
'../audio_features_train/', '../youtube_id.txt')
video_features = np.array(features.load_video_features())
audio_features = np.array(features.load_audio_features())
# Adversarial ground truths
valid = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
for epoch in range(epochs):
#training discriminator
idx = np.random.randint(0, len(audio_features), batch_size)
audio_feature = audio_features[idx]
video_feature = video_features[idx]
#generate audio features from generator
gen_audio_feature = self.generator.predict(video_feature)
#discriminator loss
d_loss_real = self.discriminator.train_on_batch(
audio_feature, valid)
d_loss_fake = self.discriminator.train_on_batch(
gen_audio_feature, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
#train generator
g_loss = self.combine.train_on_batch(video_feature, valid)
print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" %
(epoch, d_loss[0], 100 * d_loss[1], g_loss))
self.save_model()
def __init__(self):
self.features = get_feature('./final_video_features_with_scene_test/',
'./audio_features_test/',
'./youtube_id.txt')
self.video_features = self.features.load_video_features()
self.audio_features = self.features.load_audio_features()
self.dataset_length = len(self.audio_features)
self.library_features, self.library_list = self.load_library_features()
self.library_length = len(self.library_features)
self.cfa_video = pickle.load(
open('./models/saved_models/cfa_video.pickle', 'rb'))
self.cfa_audio = pickle.load(
open('./models/saved_models/cfa_audio.pickle', 'rb'))
self.cfa_video_features = np.dot(
np.array([x.tolist() for x in self.video_features]),
self.cfa_video)
self.cfa_audio_features = np.dot(
np.array([x.tolist() for x in self.audio_features]),
self.cfa_audio)
self.cfa_library_features = np.dot(
np.array([x.tolist() for x in self.library_features]),
self.cfa_audio)
ap.add_argument("input_image_path", help="Input Image Path")
ap.add_argument("--es_hosts",
default="http://127.0.0.1:9200",
help="Comma-separated elasticsearch host URLs.")
ap.add_argument("-k1", type=int, default=100, help="k1")
ap.add_argument("-k2", type=int, default=10, help="k2")
return vars(ap.parse_args())
if __name__ == '__main__':
args = get_args()
input_image_path = Path(args['input_image_path'])
img = Image.open(str(input_image_path))
print(input_image_path)
feature = get_feature(img)
search_id = 'search0000'
aknn_doc = {
"_id": search_id,
"_source": {
"path": '',
"_aknn_vector": feature.tolist()
}
}
index_name = 'images'
doc_type = 'image'
body = {
"_index": index_name,
"_type": doc_type,
from util import get_feature
import numpy as np
import pickle
training_features = get_feature('./final_video_features_with_scene_train/',
'./audio_features_train/', './youtube_id.txt')
video_features = training_features.load_video_features()
audio_features = training_features.load_audio_features()
np_video_features = np.array([x.tolist() for x in video_features]).transpose()
np_audio_features = np.array([x.tolist() for x in audio_features])
print(np_video_features.shape)
print(np_audio_features.shape)
input_features = np.dot(np_video_features, np_audio_features)
u, s, v = np.linalg.svd(input_features, full_matrices=False)
v = v.T
pickle.dump(u, open('./models/saved_models/cfa_video.pickle', 'wb'))
pickle.dump(v, open('./models/saved_models/cfa_audio.pickle', 'wb'))
import nltk import util feat_tokens = util.read_subj_obj_data(); classifier = nltk.NaiveBayesClassifier.train(feat_tokens[0]) sen = "it" sentence = util.filter_stop_words(util.tokenize(sen)) featureset = util.get_feature(sentence, feat_tokens[1]) print classifier.classify(featureset) print feat_tokens[0][-1] #print classifier.show_most_informative_features(100)
'--output_dir',
type=str,
default='features',
help='Directory output json')
args = vars(ap.parse_args())
image_dir = Path(args['image_dir'])
assert image_dir.exists(), 'no image directory found.'
output_dir = Path(args['output_dir'])
if not output_dir.exists():
output_dir.mkdir(parents=True, exist_ok=True)
image_paths = get_image_path(image_dir)
features = []
for i, image_path in enumerate(tqdm(image_paths, desc='extracting')):
img = Image.open(str(image_path))
img = img.convert('RGB')
binary_array = get_feature(img)
if len(binary_array) != 64:
print(f' {image_path}')
features.append({
'id': str(i),
'path': str(image_path),
'feature_vector': binary_array.tolist()
})
for i, feature in enumerate(tqdm(features, desc='writing')):
fname = f'features-{i:08}.json'
with gzip.open(str(output_dir / fname), 'wb') as f:
f.write(json.dumps(feature).encode())